feat(capture): support consented multi-monitor desktops with recovery (#32)
This commit is contained in:
1 parent
6d0e733cd7
commit
98af6fce28
19 files changed
+2164
-260
No files matched your search
+507
-110
@@ -2,10 +2,10 @@
|
||||
/*
|
||||
* uur-pw-capture — PipeWire ScreenCast consumer.
|
||||
*
|
||||
* Receives an inherited portal PipeWire fd (UUR_PW_FD) and the authorized
|
||||
* video node id (UUR_PW_NODE), streams the monitor as BGRx and publishes
|
||||
* frames into the private UUR_FRAME_PATH following the seqlock protocol in
|
||||
* docs/capture-protocol.md.
|
||||
* Receives an inherited portal PipeWire fd (UUR_PW_FD) and authorized monitor
|
||||
* stream specifications (UUR_PW_STREAMS), composites their BGRx frames and
|
||||
* publishes the virtual desktop into UUR_FRAME_PATH using the seqlock protocol
|
||||
* in docs/capture-protocol.md.
|
||||
*
|
||||
* The shared file is created only after the stream format is negotiated,
|
||||
* because its size depends on the negotiated stride. The uur PE hook maps
|
||||
@@ -48,35 +48,76 @@ struct frame_header {
|
||||
uint32_t stride;
|
||||
uint32_t format;
|
||||
_Atomic uint64_t total_frames;
|
||||
uint8_t reserved[32];
|
||||
uint32_t flags;
|
||||
uint32_t monitor_count;
|
||||
_Atomic uint64_t heartbeat_ms;
|
||||
uint8_t reserved[16];
|
||||
struct uurf_monitor_layout monitors[UURF_MAX_MONITORS];
|
||||
};
|
||||
|
||||
_Static_assert(sizeof(struct frame_header) == UURF_HEADER_BYTES,
|
||||
"frame protocol header size changed");
|
||||
|
||||
static uint32_t scale_floor(uint64_t value, uint32_t numerator,
|
||||
uint32_t denominator);
|
||||
static uint64_t scale_ceil(uint64_t value, uint32_t numerator,
|
||||
uint32_t denominator);
|
||||
|
||||
struct frame_slot {
|
||||
_Atomic uint64_t seq;
|
||||
/* frame bytes follow */
|
||||
};
|
||||
|
||||
struct capture {
|
||||
struct pw_main_loop *loop;
|
||||
struct capture;
|
||||
|
||||
struct capture_stream {
|
||||
struct capture *capture;
|
||||
struct pw_stream *stream;
|
||||
struct spa_hook listener;
|
||||
uint32_t node_id;
|
||||
int32_t x;
|
||||
int32_t y;
|
||||
int32_t layout_x;
|
||||
int32_t layout_y;
|
||||
uint32_t logical_width;
|
||||
uint32_t logical_height;
|
||||
int provided_logical_size;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
enum spa_video_format format;
|
||||
uint8_t *pixels;
|
||||
size_t pixels_size;
|
||||
int dmabuf_usable;
|
||||
int format_ready;
|
||||
int has_frame;
|
||||
int was_streaming;
|
||||
uint64_t paused_ms;
|
||||
uint64_t counter;
|
||||
};
|
||||
|
||||
struct capture {
|
||||
struct pw_main_loop *loop;
|
||||
struct capture_stream streams[16];
|
||||
uint32_t stream_count;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
uint32_t stride;
|
||||
enum spa_video_format format;
|
||||
uint32_t flags;
|
||||
uint64_t counter;
|
||||
uint8_t *composite;
|
||||
size_t composite_size;
|
||||
int32_t layout_x;
|
||||
int32_t layout_y;
|
||||
uint32_t layout_width;
|
||||
uint32_t layout_height;
|
||||
uint32_t scale_num;
|
||||
uint32_t scale_den;
|
||||
int shm_fd;
|
||||
uint8_t *shm;
|
||||
size_t shm_size;
|
||||
int dmabuf_usable;
|
||||
int exit_status;
|
||||
volatile sig_atomic_t stopping;
|
||||
int was_streaming;
|
||||
uint64_t started_ms;
|
||||
uint64_t paused_ms;
|
||||
char frame_path[PATH_MAX];
|
||||
};
|
||||
|
||||
@@ -111,6 +152,34 @@ static uint8_t *slot_frame(struct frame_slot *slot)
|
||||
return (uint8_t *)slot + sizeof(struct frame_slot);
|
||||
}
|
||||
|
||||
static struct uurf_monitor_layout monitor_layout(const struct capture *c,
|
||||
const struct capture_stream *s)
|
||||
{
|
||||
struct uurf_monitor_layout monitor = {0};
|
||||
monitor.logical_x = s->layout_x;
|
||||
monitor.logical_y = s->layout_y;
|
||||
monitor.logical_width = s->logical_width;
|
||||
monitor.logical_height = s->logical_height;
|
||||
monitor.capture_width = s->width;
|
||||
monitor.capture_height = s->height;
|
||||
if (c->flags == 0) {
|
||||
monitor.frame_width = c->width;
|
||||
monitor.frame_height = c->height;
|
||||
} else {
|
||||
uint64_t left = (uint64_t)((int64_t)s->layout_x - c->layout_x);
|
||||
uint64_t top = (uint64_t)((int64_t)s->layout_y - c->layout_y);
|
||||
uint32_t x0 = scale_floor(left, c->scale_num, c->scale_den);
|
||||
uint32_t y0 = scale_floor(top, c->scale_num, c->scale_den);
|
||||
uint64_t x1 = scale_ceil(left + s->logical_width, c->scale_num, c->scale_den);
|
||||
uint64_t y1 = scale_ceil(top + s->logical_height, c->scale_num, c->scale_den);
|
||||
monitor.frame_x = x0;
|
||||
monitor.frame_y = y0;
|
||||
monitor.frame_width = x1 > x0 ? (uint32_t)(x1 - x0) : 1;
|
||||
monitor.frame_height = y1 > y0 ? (uint32_t)(y1 - y0) : 1;
|
||||
}
|
||||
return monitor;
|
||||
}
|
||||
|
||||
/* Publish a new inode for every geometry. A Wine reader may still map the
|
||||
* previous inode: never truncate or resize memory another process is reading. */
|
||||
static int shm_setup(struct capture *c)
|
||||
@@ -157,6 +226,12 @@ static int shm_setup(struct capture *c)
|
||||
header->stride = c->stride;
|
||||
header->format = FRAME_FORMAT_BGRX;
|
||||
atomic_init(&header->total_frames, 0);
|
||||
atomic_init(&header->heartbeat_ms, monotonic_ms());
|
||||
header->flags = c->flags;
|
||||
header->monitor_count = c->stream_count;
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
header->monitors[i] = monitor_layout(c, &c->streams[i]);
|
||||
}
|
||||
for (uint32_t i = 0; i < UURF_SLOT_COUNT; ++i) {
|
||||
struct frame_slot *slot = (struct frame_slot *)(mapping +
|
||||
UURF_HEADER_BYTES + i * slot_bytes);
|
||||
@@ -184,10 +259,9 @@ static int shm_setup(struct capture *c)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void publish_frame(struct capture *c, const uint8_t *pixels,
|
||||
uint32_t src_stride, uint32_t src_height)
|
||||
static void publish_frame(struct capture *c)
|
||||
{
|
||||
if (c->shm == NULL)
|
||||
if (c->shm == NULL || c->composite == NULL)
|
||||
return;
|
||||
|
||||
c->counter += 1;
|
||||
@@ -196,31 +270,7 @@ static void publish_frame(struct capture *c, const uint8_t *pixels,
|
||||
memory_order_release); /* writing */
|
||||
|
||||
uint8_t *dst = slot_frame(slot);
|
||||
uint32_t rows = src_height < c->height ? src_height : c->height;
|
||||
for (uint32_t row = 0; row < rows; ++row) {
|
||||
uint8_t *target = dst + (size_t)row * c->stride;
|
||||
const uint8_t *source = pixels + (size_t)row * src_stride;
|
||||
if (c->format == SPA_VIDEO_FORMAT_BGRx ||
|
||||
c->format == SPA_VIDEO_FORMAT_BGRA) {
|
||||
memcpy(target, source, c->stride);
|
||||
} else if (c->format == SPA_VIDEO_FORMAT_RGBx ||
|
||||
c->format == SPA_VIDEO_FORMAT_RGBA) {
|
||||
for (uint32_t column = 0; column < c->width; ++column) {
|
||||
target[column * 4 + 0] = source[column * 4 + 2];
|
||||
target[column * 4 + 1] = source[column * 4 + 1];
|
||||
target[column * 4 + 2] = source[column * 4 + 0];
|
||||
target[column * 4 + 3] = 0;
|
||||
}
|
||||
} else {
|
||||
int rgb = c->format == SPA_VIDEO_FORMAT_RGB;
|
||||
for (uint32_t column = 0; column < c->width; ++column) {
|
||||
target[column * 4 + 0] = source[column * 3 + (rgb ? 2 : 0)];
|
||||
target[column * 4 + 1] = source[column * 3 + 1];
|
||||
target[column * 4 + 2] = source[column * 3 + (rgb ? 0 : 2)];
|
||||
target[column * 4 + 3] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
memcpy(dst, c->composite, c->composite_size);
|
||||
|
||||
atomic_store_explicit(&slot->seq, 2 * c->counter, memory_order_release);
|
||||
struct frame_header *header = (struct frame_header *)c->shm;
|
||||
@@ -238,15 +288,253 @@ static int sync_dmabuf(int fd, uint64_t flags)
|
||||
return result;
|
||||
}
|
||||
|
||||
static int all_streams_ready(const struct capture *c)
|
||||
{
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
if (!c->streams[i].format_ready)
|
||||
return 0;
|
||||
}
|
||||
return c->stream_count != 0;
|
||||
}
|
||||
|
||||
static int all_streams_have_frames(const struct capture *c)
|
||||
{
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
if (!c->streams[i].has_frame)
|
||||
return 0;
|
||||
}
|
||||
return c->stream_count != 0;
|
||||
}
|
||||
|
||||
static int ratio_less(uint64_t left_num, uint64_t left_den,
|
||||
uint64_t right_num, uint64_t right_den)
|
||||
{
|
||||
return left_num * right_den < right_num * left_den;
|
||||
}
|
||||
|
||||
static uint32_t scale_floor(uint64_t value, uint32_t numerator,
|
||||
uint32_t denominator)
|
||||
{
|
||||
return denominator == 0 ? 0 : (uint32_t)(value * numerator / denominator);
|
||||
}
|
||||
|
||||
static uint64_t scale_ceil(uint64_t value, uint32_t numerator,
|
||||
uint32_t denominator)
|
||||
{
|
||||
return denominator == 0 ? 0 :
|
||||
(value * numerator + denominator - 1) / denominator;
|
||||
}
|
||||
|
||||
static int configure_layout(struct capture *c)
|
||||
{
|
||||
uint32_t width, height, flags;
|
||||
uint64_t width64, height64;
|
||||
int missing_position = 0;
|
||||
int64_t min_x = INT64_MAX, min_y = INT64_MAX;
|
||||
int64_t max_x = INT64_MIN, max_y = INT64_MIN;
|
||||
uint32_t scale_num = 0, scale_den = 1;
|
||||
|
||||
if (!all_streams_ready(c))
|
||||
return 0;
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
struct capture_stream *s = &c->streams[i];
|
||||
if (s->logical_width == 0)
|
||||
s->logical_width = s->width;
|
||||
if (s->logical_height == 0)
|
||||
s->logical_height = s->height;
|
||||
if (s->x == INT32_MIN || s->y == INT32_MIN)
|
||||
missing_position = 1;
|
||||
}
|
||||
|
||||
if (c->stream_count == 1) {
|
||||
struct capture_stream *s = &c->streams[0];
|
||||
width64 = s->width;
|
||||
height64 = s->height;
|
||||
flags = 0;
|
||||
s->layout_x = 0;
|
||||
s->layout_y = 0;
|
||||
c->layout_x = 0;
|
||||
c->layout_y = 0;
|
||||
c->layout_width = s->width;
|
||||
c->layout_height = s->height;
|
||||
scale_num = 1;
|
||||
scale_den = 1;
|
||||
} else {
|
||||
int64_t next_x = 0;
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
struct capture_stream *s = &c->streams[i];
|
||||
if (missing_position && (next_x < INT32_MIN || next_x > INT32_MAX)) {
|
||||
fprintf(stderr, "monitor layout position is out of range\n");
|
||||
return -1;
|
||||
}
|
||||
s->layout_x = missing_position ? (int32_t)next_x : s->x;
|
||||
s->layout_y = missing_position ? 0 : s->y;
|
||||
next_x = (int64_t)s->layout_x + s->logical_width;
|
||||
int64_t right = (int64_t)s->layout_x + s->logical_width;
|
||||
int64_t bottom = (int64_t)s->layout_y + s->logical_height;
|
||||
if (s->layout_x < min_x)
|
||||
min_x = s->layout_x;
|
||||
if (s->layout_y < min_y)
|
||||
min_y = s->layout_y;
|
||||
if (right > max_x)
|
||||
max_x = right;
|
||||
if (bottom > max_y)
|
||||
max_y = bottom;
|
||||
|
||||
uint64_t ratio_num = s->width;
|
||||
uint64_t ratio_den = s->logical_width;
|
||||
if (ratio_less(s->height, s->logical_height, ratio_num, ratio_den)) {
|
||||
ratio_num = s->height;
|
||||
ratio_den = s->logical_height;
|
||||
}
|
||||
if (scale_num == 0 || ratio_less(ratio_num, ratio_den,
|
||||
scale_num, scale_den)) {
|
||||
scale_num = (uint32_t)ratio_num;
|
||||
scale_den = (uint32_t)ratio_den;
|
||||
}
|
||||
}
|
||||
if (min_x == INT64_MAX || min_y == INT64_MAX || max_x <= min_x ||
|
||||
max_y <= min_y || scale_num == 0 || scale_den == 0 ||
|
||||
min_x < INT32_MIN || min_x > INT32_MAX || min_y < INT32_MIN ||
|
||||
min_y > INT32_MAX || max_x - min_x > UINT32_MAX ||
|
||||
max_y - min_y > UINT32_MAX) {
|
||||
fprintf(stderr, "invalid monitor stream layout\n");
|
||||
return -1;
|
||||
}
|
||||
c->layout_x = (int32_t)min_x;
|
||||
c->layout_y = (int32_t)min_y;
|
||||
c->layout_width = (uint32_t)(max_x - min_x);
|
||||
c->layout_height = (uint32_t)(max_y - min_y);
|
||||
width64 = scale_ceil(c->layout_width, scale_num, scale_den);
|
||||
height64 = scale_ceil(c->layout_height, scale_num, scale_den);
|
||||
flags = UURF_FLAG_COMPOSITE;
|
||||
}
|
||||
|
||||
if (width64 == 0 || height64 == 0 || width64 > 16384 || height64 > 16384 ||
|
||||
width64 * 4 * height64 > 256u * 1024 * 1024) {
|
||||
fprintf(stderr, "composited capture geometry is unsupported\n");
|
||||
return -1;
|
||||
}
|
||||
width = (uint32_t)width64;
|
||||
height = (uint32_t)height64;
|
||||
|
||||
int changed = c->width != width || c->height != height || c->flags != flags;
|
||||
c->width = width;
|
||||
c->height = height;
|
||||
c->stride = width * 4;
|
||||
c->flags = flags;
|
||||
c->scale_num = scale_num;
|
||||
c->scale_den = scale_den;
|
||||
if (!changed && c->shm != NULL) {
|
||||
const struct frame_header *previous = (const struct frame_header *)c->shm;
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
struct uurf_monitor_layout current = monitor_layout(c, &c->streams[i]);
|
||||
if (memcmp(¤t, &previous->monitors[i], sizeof(current))) {
|
||||
changed = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (changed || c->composite == NULL || c->shm == NULL) {
|
||||
size_t bytes = (size_t)c->stride * height;
|
||||
uint8_t *fresh = realloc(c->composite, bytes);
|
||||
if (fresh == NULL) {
|
||||
fprintf(stderr, "could not allocate composited capture frame\n");
|
||||
return -1;
|
||||
}
|
||||
c->composite = fresh;
|
||||
c->composite_size = bytes;
|
||||
memset(c->composite, 0, bytes);
|
||||
if (shm_setup(c) < 0)
|
||||
return -1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void compose_frame(struct capture *c)
|
||||
{
|
||||
if (c->composite == NULL || c->width == 0 || c->height == 0)
|
||||
return;
|
||||
if (c->stream_count == 1) {
|
||||
memcpy(c->composite, c->streams[0].pixels, c->composite_size);
|
||||
return;
|
||||
}
|
||||
|
||||
memset(c->composite, 0, c->composite_size);
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
struct capture_stream *s = &c->streams[i];
|
||||
uint64_t left_logical = (uint64_t)((int64_t)s->layout_x - c->layout_x);
|
||||
uint64_t top_logical = (uint64_t)((int64_t)s->layout_y - c->layout_y);
|
||||
uint32_t left = scale_floor(left_logical, c->scale_num, c->scale_den);
|
||||
uint32_t top = scale_floor(top_logical, c->scale_num, c->scale_den);
|
||||
uint32_t right = scale_ceil(left_logical + s->logical_width,
|
||||
c->scale_num, c->scale_den);
|
||||
uint32_t bottom = scale_ceil(top_logical + s->logical_height,
|
||||
c->scale_num, c->scale_den);
|
||||
uint32_t target_width = right > left ? right - left : 1;
|
||||
uint32_t target_height = bottom > top ? bottom - top : 1;
|
||||
if (left >= c->width || top >= c->height)
|
||||
continue;
|
||||
if (target_width > c->width - left)
|
||||
target_width = c->width - left;
|
||||
if (target_height > c->height - top)
|
||||
target_height = c->height - top;
|
||||
if (target_width == s->width && target_height == s->height) {
|
||||
for (uint32_t row = 0; row < target_height; ++row) {
|
||||
memcpy(c->composite + (size_t)(top + row) * c->stride + (size_t)left * 4,
|
||||
s->pixels + (size_t)row * s->width * 4, (size_t)target_width * 4);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
for (uint32_t row = 0; row < target_height; ++row) {
|
||||
uint32_t source_y = (uint32_t)((uint64_t)row * s->height / target_height);
|
||||
uint8_t *target = c->composite + (size_t)(top + row) * c->stride + (size_t)left * 4;
|
||||
const uint8_t *source = s->pixels + (size_t)source_y * s->width * 4;
|
||||
for (uint32_t column = 0; column < target_width; ++column) {
|
||||
uint32_t source_x = (uint32_t)((uint64_t)column * s->width / target_width);
|
||||
memcpy(target + (size_t)column * 4, source + (size_t)source_x * 4, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void normalize_pixels(struct capture_stream *s, const uint8_t *pixels,
|
||||
uint32_t source_stride)
|
||||
{
|
||||
uint32_t source_bpp =
|
||||
s->format == SPA_VIDEO_FORMAT_BGR || s->format == SPA_VIDEO_FORMAT_RGB ? 3u : 4u;
|
||||
if (s->format == SPA_VIDEO_FORMAT_BGRx || s->format == SPA_VIDEO_FORMAT_BGRA) {
|
||||
for (uint32_t row = 0; row < s->height; ++row) {
|
||||
memcpy(s->pixels + (size_t)row * s->width * 4,
|
||||
pixels + (size_t)row * source_stride, (size_t)s->width * 4);
|
||||
}
|
||||
return;
|
||||
}
|
||||
for (uint32_t row = 0; row < s->height; ++row) {
|
||||
const uint8_t *source = pixels + (size_t)row * source_stride;
|
||||
uint8_t *target = s->pixels + (size_t)row * s->width * 4;
|
||||
for (uint32_t column = 0; column < s->width; ++column) {
|
||||
int rgb = s->format == SPA_VIDEO_FORMAT_RGBx ||
|
||||
s->format == SPA_VIDEO_FORMAT_RGBA ||
|
||||
s->format == SPA_VIDEO_FORMAT_RGB;
|
||||
target[column * 4] = source[column * source_bpp + (rgb ? 2 : 0)];
|
||||
target[column * 4 + 1] = source[column * source_bpp + 1];
|
||||
target[column * 4 + 2] = source[column * source_bpp + (rgb ? 0 : 2)];
|
||||
target[column * 4 + 3] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void on_process(void *userdata)
|
||||
{
|
||||
struct capture *c = userdata;
|
||||
struct pw_buffer *buffer = pw_stream_dequeue_buffer(c->stream);
|
||||
struct capture_stream *s = userdata;
|
||||
struct capture *c = s->capture;
|
||||
struct pw_buffer *buffer = pw_stream_dequeue_buffer(s->stream);
|
||||
if (buffer == NULL)
|
||||
return;
|
||||
struct spa_buffer *buf = buffer->buffer;
|
||||
|
||||
if (buf->n_datas >= 1 && c->shm != NULL) {
|
||||
if (buf->n_datas >= 1 && s->format_ready && s->pixels != NULL) {
|
||||
struct spa_data *plane = &buf->datas[0];
|
||||
uint8_t *pixels = NULL;
|
||||
void *mapping = MAP_FAILED;
|
||||
@@ -257,18 +545,17 @@ static void on_process(void *userdata)
|
||||
if (plane->chunk == NULL || plane->chunk->stride < 0 ||
|
||||
(plane->chunk->flags & (SPA_CHUNK_FLAG_CORRUPTED | SPA_CHUNK_FLAG_EMPTY)))
|
||||
goto done;
|
||||
uint32_t row_bytes = c->width *
|
||||
(c->format == SPA_VIDEO_FORMAT_BGR || c->format == SPA_VIDEO_FORMAT_RGB ? 3u : 4u);
|
||||
uint32_t source_bpp =
|
||||
s->format == SPA_VIDEO_FORMAT_BGR || s->format == SPA_VIDEO_FORMAT_RGB ? 3u : 4u;
|
||||
uint32_t row_bytes = s->width * source_bpp;
|
||||
uint32_t stride = plane->chunk->stride > 0 ?
|
||||
(uint32_t)plane->chunk->stride : row_bytes;
|
||||
uint64_t span = (uint64_t)stride * (c->height - 1) + row_bytes;
|
||||
uint64_t span = (uint64_t)stride * (s->height - 1) + row_bytes;
|
||||
uint32_t data_offset = plane->chunk->offset;
|
||||
if (stride < row_bytes || span > 256u * 1024 * 1024)
|
||||
goto done;
|
||||
if (dmabuf) {
|
||||
// DMA-BUF maxsize/chunk size may be zero or placeholders. Query
|
||||
// the fd and include BOTH the plane mapping and chunk offsets.
|
||||
if (!c->dmabuf_usable || plane->fd < 0)
|
||||
if (!s->dmabuf_usable || plane->fd < 0)
|
||||
goto done;
|
||||
off_t extent = lseek((int)plane->fd, 0, SEEK_END);
|
||||
uint64_t end = (uint64_t)plane->mapoffset + data_offset + span;
|
||||
@@ -302,10 +589,16 @@ static void on_process(void *userdata)
|
||||
pixels = (uint8_t *)mapping + delta;
|
||||
}
|
||||
if (pixels != NULL) {
|
||||
if (c->counter == 0)
|
||||
fprintf(stderr, "capture buffer: %s, source stride %u, chunk offset %u\n",
|
||||
dmabuf ? "linear DMA-BUF" : "shared memory", stride, data_offset);
|
||||
publish_frame(c, pixels, stride, c->height);
|
||||
if (s->counter == 0)
|
||||
fprintf(stderr, "stream %u buffer: %s, source stride %u, chunk offset %u\n",
|
||||
s->node_id, dmabuf ? "linear DMA-BUF" : "shared memory", stride, data_offset);
|
||||
normalize_pixels(s, pixels, stride);
|
||||
s->counter++;
|
||||
s->has_frame = 1;
|
||||
if (c->shm != NULL && all_streams_have_frames(c)) {
|
||||
compose_frame(c);
|
||||
publish_frame(c);
|
||||
}
|
||||
}
|
||||
done:
|
||||
if (synchronized)
|
||||
@@ -314,13 +607,14 @@ done:
|
||||
munmap(mapping, mapping_size);
|
||||
}
|
||||
|
||||
pw_stream_queue_buffer(c->stream, buffer);
|
||||
pw_stream_queue_buffer(s->stream, buffer);
|
||||
}
|
||||
|
||||
static void on_param_changed(void *userdata, uint32_t id,
|
||||
const struct spa_pod *param)
|
||||
{
|
||||
struct capture *c = userdata;
|
||||
struct capture_stream *s = userdata;
|
||||
struct capture *c = s->capture;
|
||||
if (param == NULL || id != SPA_PARAM_Format)
|
||||
return;
|
||||
|
||||
@@ -333,56 +627,89 @@ static void on_param_changed(void *userdata, uint32_t id,
|
||||
info.format != SPA_VIDEO_FORMAT_RGBA &&
|
||||
info.format != SPA_VIDEO_FORMAT_BGR &&
|
||||
info.format != SPA_VIDEO_FORMAT_RGB) {
|
||||
fprintf(stderr, "negotiated unexpected format %d\n", info.format);
|
||||
fprintf(stderr, "stream %u negotiated unexpected format %d\n",
|
||||
s->node_id, info.format);
|
||||
return;
|
||||
}
|
||||
|
||||
if (info.size.width == 0 || info.size.height == 0 ||
|
||||
info.size.width > 16384 || info.size.height > 16384 ||
|
||||
(uint64_t)info.size.width * 4 * info.size.height > 256u * 1024 * 1024) {
|
||||
fprintf(stderr, "unsupported capture geometry\n");
|
||||
fprintf(stderr, "stream %u has unsupported capture geometry\n", s->node_id);
|
||||
c->exit_status = 1;
|
||||
pw_main_loop_quit(c->loop);
|
||||
return;
|
||||
}
|
||||
c->width = (uint32_t)info.size.width;
|
||||
c->height = (uint32_t)info.size.height;
|
||||
c->format = info.format;
|
||||
c->stride = SPA_ROUND_UP_N(c->width * 4, 4);
|
||||
int changed = !s->format_ready || s->width != info.size.width ||
|
||||
s->height != info.size.height || s->format != info.format;
|
||||
s->width = (uint32_t)info.size.width;
|
||||
s->height = (uint32_t)info.size.height;
|
||||
if (!s->provided_logical_size) {
|
||||
s->logical_width = s->width;
|
||||
s->logical_height = s->height;
|
||||
}
|
||||
s->format = info.format;
|
||||
/* The DMA-BUF path mmaps the fd directly, which is only correct for a
|
||||
* linear layout. A tiled modifier needs a real importer (GBM/EGL), so
|
||||
* refuse to publish garbage rather than emit a corrupt frame. */
|
||||
c->dmabuf_usable = spa_pod_find_prop(param, NULL, SPA_FORMAT_VIDEO_modifier) != NULL &&
|
||||
s->dmabuf_usable = spa_pod_find_prop(param, NULL, SPA_FORMAT_VIDEO_modifier) != NULL &&
|
||||
info.modifier == DRM_FORMAT_MOD_LINEAR;
|
||||
fprintf(stderr, "negotiated: %ux%u stride %u modifier %#llx%s\n", c->width,
|
||||
c->height, c->stride, (unsigned long long)info.modifier,
|
||||
c->dmabuf_usable ? "" : " (DMA-BUF CPU mapping disabled)");
|
||||
|
||||
const struct frame_header *header = (const struct frame_header *)c->shm;
|
||||
if (header == NULL || header->width != c->width || header->height != c->height) {
|
||||
if (shm_setup(c) < 0) {
|
||||
if (changed) {
|
||||
size_t bytes = (size_t)s->width * s->height * 4;
|
||||
size_t source_total = bytes;
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
if (&c->streams[i] != s)
|
||||
source_total += c->streams[i].pixels_size;
|
||||
}
|
||||
if (source_total > 512u * 1024 * 1024) {
|
||||
fprintf(stderr, "monitor source buffers exceed the memory limit\n");
|
||||
c->exit_status = 1;
|
||||
pw_main_loop_quit(c->loop);
|
||||
return;
|
||||
}
|
||||
uint8_t *fresh = realloc(s->pixels, bytes);
|
||||
if (fresh == NULL) {
|
||||
fprintf(stderr, "could not allocate stream %u frame buffer\n", s->node_id);
|
||||
c->exit_status = 1;
|
||||
pw_main_loop_quit(c->loop);
|
||||
return;
|
||||
}
|
||||
s->pixels = fresh;
|
||||
s->pixels_size = bytes;
|
||||
memset(s->pixels, 0, bytes);
|
||||
s->has_frame = 0;
|
||||
}
|
||||
s->format_ready = 1;
|
||||
fprintf(stderr, "stream %u negotiated: %ux%u modifier %#llx%s\n", s->node_id,
|
||||
s->width, s->height, (unsigned long long)info.modifier,
|
||||
s->dmabuf_usable ? "" : " (DMA-BUF CPU mapping disabled)");
|
||||
int layout = configure_layout(c);
|
||||
if (layout < 0) {
|
||||
c->exit_status = 1;
|
||||
pw_main_loop_quit(c->loop);
|
||||
} else if (layout > 0 && all_streams_have_frames(c)) {
|
||||
compose_frame(c);
|
||||
publish_frame(c);
|
||||
}
|
||||
}
|
||||
|
||||
static void on_state_changed(void *userdata, enum pw_stream_state old,
|
||||
enum pw_stream_state state, const char *error)
|
||||
{
|
||||
struct capture *c = userdata;
|
||||
fprintf(stderr, "stream state: %s%s%s\n",
|
||||
struct capture_stream *s = userdata;
|
||||
struct capture *c = s->capture;
|
||||
fprintf(stderr, "stream %u state: %s%s%s\n", s->node_id,
|
||||
pw_stream_state_as_string(state),
|
||||
error != NULL && error[0] != '\0' ? " - " : "",
|
||||
error != NULL ? error : "");
|
||||
if (c->stopping)
|
||||
return;
|
||||
if (state == PW_STREAM_STATE_STREAMING) {
|
||||
c->was_streaming = 1;
|
||||
c->paused_ms = 0;
|
||||
} else if (state == PW_STREAM_STATE_PAUSED && c->was_streaming) {
|
||||
if (c->paused_ms == 0)
|
||||
c->paused_ms = monotonic_ms();
|
||||
s->was_streaming = 1;
|
||||
s->paused_ms = 0;
|
||||
} else if (state == PW_STREAM_STATE_PAUSED && s->was_streaming) {
|
||||
if (s->paused_ms == 0)
|
||||
s->paused_ms = monotonic_ms();
|
||||
} else if (state == PW_STREAM_STATE_ERROR ||
|
||||
(state == PW_STREAM_STATE_UNCONNECTED && old != state)) {
|
||||
c->exit_status = 75;
|
||||
@@ -395,14 +722,20 @@ static void on_watchdog(void *userdata, uint64_t expirations)
|
||||
struct capture *c = userdata;
|
||||
(void)expirations;
|
||||
uint64_t now = monotonic_ms();
|
||||
// A static desktop can legitimately produce no new frames while streaming.
|
||||
// Only a prolonged PAUSED state or a stream with no FIRST frame is fatal.
|
||||
if (c->shm != NULL)
|
||||
atomic_store_explicit(&((struct frame_header *)c->shm)->heartbeat_ms,
|
||||
now, memory_order_release);
|
||||
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||
struct capture_stream *s = &c->streams[i];
|
||||
if (!c->stopping &&
|
||||
((c->paused_ms != 0 && now - c->paused_ms >= 10000) ||
|
||||
(c->counter == 0 && now - c->started_ms >= 30000))) {
|
||||
fprintf(stderr, "capture stream stopped producing usable frames; reconnecting\n");
|
||||
((s->paused_ms != 0 && now - s->paused_ms >= 10000) ||
|
||||
(!s->has_frame && now - c->started_ms >= 30000))) {
|
||||
fprintf(stderr, "stream %u stopped producing usable frames; reconnecting\n",
|
||||
s->node_id);
|
||||
c->exit_status = 75;
|
||||
pw_main_loop_quit(c->loop);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -451,30 +784,75 @@ static const struct spa_pod *capture_format(struct spa_pod_builder *builder,
|
||||
return spa_pod_builder_pop(builder, &frame);
|
||||
}
|
||||
|
||||
static int parse_stream_specs(struct capture *c, const char *text)
|
||||
{
|
||||
char *copy = strdup(text);
|
||||
if (copy == NULL)
|
||||
return -1;
|
||||
char *save = NULL;
|
||||
char *item = strtok_r(copy, ";", &save);
|
||||
while (item != NULL) {
|
||||
unsigned node, width, height;
|
||||
int x, y;
|
||||
if (c->stream_count >= sizeof(c->streams) / sizeof(c->streams[0]) ||
|
||||
sscanf(item, "%u,%d,%d,%u,%u", &node, &x, &y, &width, &height) != 5) {
|
||||
free(copy);
|
||||
return -1;
|
||||
}
|
||||
struct capture_stream *s = &c->streams[c->stream_count++];
|
||||
s->node_id = node;
|
||||
s->x = x;
|
||||
s->y = y;
|
||||
s->logical_width = width;
|
||||
s->logical_height = height;
|
||||
s->provided_logical_size = width != 0 && height != 0;
|
||||
item = strtok_r(NULL, ";", &save);
|
||||
}
|
||||
free(copy);
|
||||
return c->stream_count == 0 ? -1 : 0;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
const char *fd_text = getenv("UUR_PW_FD");
|
||||
const char *node_text = getenv("UUR_PW_NODE");
|
||||
if (fd_text == NULL || node_text == NULL) {
|
||||
fprintf(stderr,
|
||||
"UUR_PW_FD and UUR_PW_NODE must be set by 'uur capture'\n");
|
||||
return 2;
|
||||
}
|
||||
const char *spec_text = getenv("UUR_PW_STREAMS");
|
||||
const char *legacy_node = getenv("UUR_PW_NODE");
|
||||
const char *frame_path = getenv("UUR_FRAME_PATH");
|
||||
if (frame_path == NULL || frame_path[0] != '/' ||
|
||||
if (fd_text == NULL || frame_path == NULL || frame_path[0] != '/' ||
|
||||
strlen(frame_path) >= PATH_MAX) {
|
||||
fprintf(stderr, "UUR_FRAME_PATH must be a short absolute path\n");
|
||||
fprintf(stderr, "UUR_PW_FD and an absolute UUR_FRAME_PATH are required\n");
|
||||
return 2;
|
||||
}
|
||||
int pw_fd = atoi(fd_text);
|
||||
uint32_t node_id = (uint32_t)strtoul(node_text, NULL, 10);
|
||||
|
||||
pw_init(NULL, NULL);
|
||||
|
||||
struct capture c;
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.shm_fd = -1;
|
||||
if (spec_text != NULL) {
|
||||
if (parse_stream_specs(&c, spec_text) < 0) {
|
||||
fprintf(stderr, "invalid UUR_PW_STREAMS specification\n");
|
||||
return 2;
|
||||
}
|
||||
} else if (legacy_node != NULL) {
|
||||
char *end = NULL;
|
||||
errno = 0;
|
||||
unsigned long node = strtoul(legacy_node, &end, 10);
|
||||
if (errno != 0 || end == legacy_node || *end != '\0' || node > UINT32_MAX) {
|
||||
fprintf(stderr, "invalid UUR_PW_NODE\n");
|
||||
return 2;
|
||||
}
|
||||
c.stream_count = 1;
|
||||
c.streams[0].node_id = (uint32_t)node;
|
||||
c.streams[0].x = INT32_MIN;
|
||||
c.streams[0].y = INT32_MIN;
|
||||
} else {
|
||||
fprintf(stderr, "UUR_PW_STREAMS must be set by uur\n");
|
||||
return 2;
|
||||
}
|
||||
memcpy(c.frame_path, frame_path, strlen(frame_path) + 1);
|
||||
fprintf(stderr, "capturing %u ScreenCast stream(s)\n", c.stream_count);
|
||||
|
||||
pw_init(NULL, NULL);
|
||||
active_capture = &c;
|
||||
signal(SIGINT, stop_capture);
|
||||
signal(SIGTERM, stop_capture);
|
||||
@@ -494,8 +872,7 @@ int main(void)
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Connect through the portal's private PipeWire instance: only the
|
||||
* consented node is reachable on this descriptor. */
|
||||
/* The portal fd only exposes streams covered by this ScreenCast consent. */
|
||||
struct pw_core *core = pw_context_connect_fd(context, pw_fd, NULL, 0);
|
||||
if (core == NULL) {
|
||||
fprintf(stderr, "pw_context_connect_fd failed\n");
|
||||
@@ -503,16 +880,7 @@ int main(void)
|
||||
}
|
||||
struct spa_hook core_listener;
|
||||
pw_core_add_listener(core, &core_listener, &core_events, &c);
|
||||
|
||||
struct pw_properties *props = pw_properties_new(
|
||||
PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture",
|
||||
PW_KEY_MEDIA_ROLE, "Screen", NULL);
|
||||
c.stream = pw_stream_new(core, "uur-capture", props);
|
||||
if (c.stream == NULL) {
|
||||
fprintf(stderr, "pw_stream_new failed\n");
|
||||
return 1;
|
||||
}
|
||||
pw_stream_add_listener(c.stream, &c.listener, &stream_events, &c);
|
||||
struct spa_source *watchdog = NULL;
|
||||
|
||||
uint8_t pod_buffer[1024];
|
||||
struct spa_pod_builder pod_builder =
|
||||
@@ -522,28 +890,56 @@ int main(void)
|
||||
params[1] = capture_format(&pod_builder, 0);
|
||||
c.started_ms = monotonic_ms();
|
||||
|
||||
if (pw_stream_connect(c.stream, PW_DIRECTION_INPUT, node_id,
|
||||
for (uint32_t i = 0; i < c.stream_count; ++i) {
|
||||
struct capture_stream *s = &c.streams[i];
|
||||
s->capture = &c;
|
||||
char name[64];
|
||||
snprintf(name, sizeof(name), "uur-capture-%u", i + 1);
|
||||
struct pw_properties *props = pw_properties_new(
|
||||
PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture",
|
||||
PW_KEY_MEDIA_ROLE, "Screen", NULL);
|
||||
s->stream = pw_stream_new(core, name, props);
|
||||
if (s->stream == NULL) {
|
||||
fprintf(stderr, "pw_stream_new failed for node %u\n", s->node_id);
|
||||
c.exit_status = 1;
|
||||
goto cleanup;
|
||||
}
|
||||
pw_stream_add_listener(s->stream, &s->listener, &stream_events, s);
|
||||
if (pw_stream_connect(s->stream, PW_DIRECTION_INPUT, s->node_id,
|
||||
PW_STREAM_FLAG_MAP_BUFFERS |
|
||||
PW_STREAM_FLAG_AUTOCONNECT,
|
||||
params, 2) < 0) {
|
||||
fprintf(stderr, "pw_stream_connect failed\n");
|
||||
return 1;
|
||||
fprintf(stderr, "pw_stream_connect failed for node %u\n", s->node_id);
|
||||
c.exit_status = 1;
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
struct spa_source *watchdog = pw_loop_add_timer(pw_main_loop_get_loop(loop),
|
||||
on_watchdog, &c);
|
||||
watchdog = pw_loop_add_timer(pw_main_loop_get_loop(loop), on_watchdog, &c);
|
||||
struct timespec interval = {.tv_sec = 1};
|
||||
if (watchdog == NULL || pw_loop_update_timer(pw_main_loop_get_loop(loop),
|
||||
watchdog, &interval, &interval, false) < 0) {
|
||||
fprintf(stderr, "could not start capture watchdog\n");
|
||||
return 1;
|
||||
c.exit_status = 1;
|
||||
goto cleanup;
|
||||
}
|
||||
pw_main_loop_run(loop);
|
||||
|
||||
c.stopping = 1;
|
||||
active_capture = NULL;
|
||||
cleanup:
|
||||
c.stopping = 1;
|
||||
active_capture = NULL;
|
||||
if (watchdog != NULL)
|
||||
pw_loop_destroy_source(pw_main_loop_get_loop(loop), watchdog);
|
||||
pw_stream_destroy(c.stream);
|
||||
for (uint32_t i = 0; i < c.stream_count; ++i) {
|
||||
struct capture_stream *s = &c.streams[i];
|
||||
if (s->stream != NULL) {
|
||||
pw_stream_destroy(s->stream);
|
||||
spa_hook_remove(&s->listener);
|
||||
}
|
||||
free(s->pixels);
|
||||
}
|
||||
spa_hook_remove(&core_listener);
|
||||
pw_core_disconnect(core);
|
||||
pw_context_destroy(context);
|
||||
@@ -555,6 +951,7 @@ int main(void)
|
||||
}
|
||||
if (c.shm_fd >= 0)
|
||||
close(c.shm_fd);
|
||||
free(c.composite);
|
||||
unlink(c.frame_path);
|
||||
pw_deinit();
|
||||
return c.exit_status;
|
||||
|
||||
@@ -24,7 +24,9 @@
|
||||
struct frame_header {
|
||||
uint32_t magic, version, width, height, stride, format;
|
||||
_Atomic uint64_t total_frames;
|
||||
uint8_t reserved[32];
|
||||
uint32_t flags, monitor_count;
|
||||
uint8_t reserved[24];
|
||||
struct uurf_monitor_layout monitors[UURF_MAX_MONITORS];
|
||||
};
|
||||
_Static_assert(sizeof(struct frame_header) == UURF_HEADER_BYTES, "frame header ABI");
|
||||
|
||||
@@ -136,6 +138,18 @@ static int setup_ring(struct capture *c)
|
||||
header->width = c->width; header->height = c->height;
|
||||
header->stride = c->width * 4; header->format = 1;
|
||||
atomic_init(&header->total_frames, 0);
|
||||
header->flags = 0;
|
||||
header->monitor_count = 1;
|
||||
header->monitors[0].logical_x = 0;
|
||||
header->monitors[0].logical_y = 0;
|
||||
header->monitors[0].logical_width = c->width;
|
||||
header->monitors[0].logical_height = c->height;
|
||||
header->monitors[0].frame_x = 0;
|
||||
header->monitors[0].frame_y = 0;
|
||||
header->monitors[0].frame_width = c->width;
|
||||
header->monitors[0].frame_height = c->height;
|
||||
header->monitors[0].capture_width = c->width;
|
||||
header->monitors[0].capture_height = c->height;
|
||||
for (uint32_t i = 0; i < UURF_SLOT_COUNT; ++i) {
|
||||
_Atomic uint64_t *seq = (_Atomic uint64_t *)((uint8_t *)c->ring +
|
||||
UURF_HEADER_BYTES + i * (sizeof(uint64_t) + bytes));
|
||||
|
||||
@@ -62,7 +62,7 @@ RAII cleanup terminates only those helper groups and the one managed Wine
|
||||
prefix. There are no permanent daemons, global `pkill` calls, or required
|
||||
systemd units.
|
||||
|
||||
Frame data lives in `$XDG_RUNTIME_DIR/uur/frames.v1` with mode 0600. The path is
|
||||
Frame data lives in `$XDG_RUNTIME_DIR/uur/frames.v3` with mode 0600. The path is
|
||||
passed through the adapter configuration, so users and concurrent sessions do
|
||||
not share a global `/dev/shm` object.
|
||||
|
||||
|
||||
+45
-15
@@ -1,16 +1,18 @@
|
||||
# Capture frame protocol
|
||||
|
||||
How frames travel from the compositor (via PipeWire) into the client's
|
||||
capture calls. Two producers/consumers, one shared file, no locks.
|
||||
capture calls. Multiple selected monitor streams are composed into one virtual
|
||||
desktop frame in the shared transport; the Windows hook crops each monitor
|
||||
request from that frame.
|
||||
|
||||
```text
|
||||
xdg-desktop-portal ScreenCast
|
||||
│ (portal-consented session; per-monitor)
|
||||
│ (portal-consented session; one stream per selected monitor)
|
||||
▼
|
||||
uur-pw-capture (C) ── PipeWire stream, BGRx, SHM buffers
|
||||
uur-pw-capture (C) ── PipeWire streams, BGRx, desktop composition
|
||||
│ writes slots, seqlock per slot
|
||||
▼
|
||||
$XDG_RUNTIME_DIR/uur/frames.v1 (mode 0600, 64-byte header + 3 slots)
|
||||
$XDG_RUNTIME_DIR/uur/frames.v3 (mode 0600, 704-byte header + 3 slots)
|
||||
│ mapped read-only by the PE hook through its configured Wine Z: path
|
||||
▼
|
||||
uur-hook.dll ── intercepts static/dynamic gdi32!BitBlt/StretchBlt calls;
|
||||
@@ -19,20 +21,31 @@ uur-hook.dll ── intercepts static/dynamic gdi32!BitBlt/StretchBlt calls;
|
||||
|
||||
## Shared file layout
|
||||
|
||||
All integers little-endian. Total size = 64 + 3 × (8 + stride × height).
|
||||
All integers little-endian. Total size = 704 + 3 × (8 + stride × height).
|
||||
|
||||
| offset | type | field |
|
||||
| --- | --- | --- |
|
||||
| 0 | u32 | magic `0x46525555` ("UURF") |
|
||||
| 4 | u32 | protocol version = 1 |
|
||||
| 4 | u32 | protocol version = 3 |
|
||||
| 8 | u32 | frame width (px) |
|
||||
| 12 | u32 | frame height (px) |
|
||||
| 16 | u32 | stride (bytes per row) |
|
||||
| 20 | u32 | format: 1 = BGRx (32 bits per pixel) |
|
||||
| 24 | u64 | total frames written (monotonic counter) |
|
||||
| 32..64 | — | reserved, zero |
|
||||
| 32 | u32 | flags: bit 0 means the frame is a virtual-desktop composite |
|
||||
| 36 | u32 | monitor layout record count (1..16) |
|
||||
| 40 | u64 | producer CLOCK_MONOTONIC heartbeat in milliseconds; zero if unsupported |
|
||||
| 48..64 | — | reserved, zero |
|
||||
|
||||
Slot *i* (i = 0, 1, 2) at offset `64 + i × (8 + stride × height)`:
|
||||
The fixed-size monitor table starts at offset 64 and contains 16 records of
|
||||
40 bytes each. Unused records are zero. Each record contains signed logical
|
||||
`x` and `y`, logical `width` and `height`, then unsigned `frame_x`, `frame_y`,
|
||||
`frame_width` and `frame_height` describing that monitor's rectangle in the
|
||||
composited frame, then `capture_width` and `capture_height` for the negotiated
|
||||
source stream resolution. A single-stream capture has one record covering the
|
||||
full frame.
|
||||
|
||||
Slot *i* (i = 0, 1, 2) at offset `704 + i × (8 + stride × height)`:
|
||||
|
||||
| offset | type | field |
|
||||
| --- | --- | --- |
|
||||
@@ -50,12 +63,27 @@ the managed prefix configuration. It is never a global shared-memory name.
|
||||
|
||||
## Geometry and session changes
|
||||
|
||||
An exact Wine monitor rectangle maps onto the entire selected frame when their
|
||||
aspect ratios match. Pixel dimensions may differ under fractional scaling, where
|
||||
Xwayland's render size can exceed the portal's native frame size. Partial regions
|
||||
and whole-virtual-desktop requests retain the existing virtual-desktop mapping.
|
||||
This does not establish monitor identity between Wine and the portal; selecting
|
||||
a non-primary monitor still requires consistent client/input coordinates.
|
||||
For one selected stream, an exact Wine monitor rectangle maps onto the entire
|
||||
frame when their aspect ratios match. With multiple selected monitor streams,
|
||||
the producer uses portal position/size metadata to compose the streams into a
|
||||
virtual desktop frame; Wine monitor rectangles then crop their matching region.
|
||||
If a portal omits layout metadata, streams are arranged left to right. Fractional
|
||||
scaling is normalized to a shared frame scale; each stream is resampled into
|
||||
its reported logical rectangle. The hook matches Wine monitor bounds to the
|
||||
captured layout and crops in monitor-local coordinates, so differing monitor
|
||||
resolutions and vertical offsets do not shift the top edge of a screen.
|
||||
The capture service's virtual display API uses the composed frame rectangles
|
||||
relative to the primary monitor, including a common pixel scale. UI and WebView
|
||||
processes retain native display geometry. Raw source pixel sizes remain metadata
|
||||
and are never combined with logical origins. Portals without stable output
|
||||
identity require the selected monitor count to match Wine's monitor count for
|
||||
per-monitor matching; otherwise the composite is used as a whole.
|
||||
|
||||
Multiple monitors are explicitly enabled with `uur display source monitor
|
||||
--multiple`, followed by a new session and monitor selection in the portal.
|
||||
Upgrading preserves existing grants. Choosing `uur display source monitor`
|
||||
returns to a single selected source. Absolute input selects the consented node
|
||||
containing the logical position, then sends that node's local coordinates.
|
||||
|
||||
Each transport inode has immutable geometry. A negotiated size change creates
|
||||
a new mode-0600 file, initializes its header and slots, then atomically replaces
|
||||
@@ -69,7 +97,9 @@ fd extent, readiness fence and CPU-access synchronization. Implicit modifiers
|
||||
require a graphics importer and are not advertised by this CPU consumer.
|
||||
|
||||
A stream error, lost connection or ten seconds in PAUSED after streaming makes
|
||||
the helper exit with status 75. The ScreenCast supervisor retries up to three
|
||||
the helper exit with status 75. A ten-second expired producer heartbeat also
|
||||
restarts a hung helper, independently of desktop changes. Both ScreenCast and
|
||||
combined RemoteDesktop supervisors retry up to three
|
||||
times using the saved restore token, with a one-second backoff. Thirty seconds
|
||||
of healthy capture resets the retry budget. An unchanged desktop in STREAMING
|
||||
does not trigger this watchdog. Recovery keeps the saved token and performs no
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
| X11 multi-monitor | Wine integration | Native Wine/XRandR display topology |
|
||||
| Wayland monitor/window selection | available | Persistent portal source selection |
|
||||
| Wayland virtual source | available when advertised | `uur display source virtual` → ScreenCast Virtual source |
|
||||
| Independent Wayland multi-screen switching | in progress | Multiple PipeWire streams → UU display topology adapter |
|
||||
| Wayland multi-screen capture | available | Multiple PipeWire streams → virtual desktop composite → per-monitor crops |
|
||||
| Clipboard and phone IME text | planned | RemoteDesktop Clipboard portal, then X11 fallback |
|
||||
| Speaker and microphone audio | available through Wine | PulseAudio, pipewire-pulse, or ALSA selected from live capabilities |
|
||||
| System-audio loopback and remote mute | Wine integration | WASAPI → winepulse/winealsa |
|
||||
|
||||
@@ -210,14 +210,17 @@ choice; this is independent from PipeWire's Wayland video role.
|
||||
```bash
|
||||
uur display status
|
||||
uur display source monitor
|
||||
uur display source monitor --multiple
|
||||
uur display source window
|
||||
uur display source virtual
|
||||
```
|
||||
|
||||
The command clears the old restore token so the next Portal session can create
|
||||
or select the requested source. X11 exposes its XRandR topology to Wine.
|
||||
Wayland currently carries one selected stream; independent multi-stream
|
||||
switching is the next display-topology adapter.
|
||||
or select the requested source. With `monitor --multiple`, the chooser can select
|
||||
multiple displays; uur composes those PipeWire streams into the virtual desktop
|
||||
frame and crops each Wine monitor request from it. X11 exposes its XRandR
|
||||
topology to Wine directly. Upgrades preserve existing restore tokens; multiple
|
||||
monitor selection is an explicit choice and applies to the next session.
|
||||
|
||||
## First run and normal use
|
||||
|
||||
|
||||
@@ -3,11 +3,12 @@
|
||||
## Frame sources
|
||||
|
||||
- X11 sessions expose the XRandR monitor topology directly to Wine.
|
||||
- Wayland monitor and window sources use ScreenCast/PipeWire.
|
||||
- Wayland monitor and window sources use ScreenCast/PipeWire. Monitor selection
|
||||
supports multiple outputs with `uur display source monitor --multiple` and
|
||||
composes their streams into the virtual desktop
|
||||
frame consumed by the Wine capture adapter.
|
||||
- `uur display source virtual` requests the portal's Virtual source type and
|
||||
stores its restore token.
|
||||
- A multi-stream compositor will combine or expose several PipeWire nodes to
|
||||
UU's display topology for independent Wayland screen switching.
|
||||
|
||||
## Codec capabilities
|
||||
|
||||
|
||||
+22
-2
@@ -5,9 +5,29 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#define UURF_MAGIC 0x46525555u
|
||||
#define UURF_VERSION 1u
|
||||
#define UURF_VERSION 3u
|
||||
#define UURF_SLOT_COUNT 3u
|
||||
#define UURF_HEADER_BYTES 64u
|
||||
#define UURF_BASE_HEADER_BYTES 64u
|
||||
#define UURF_MAX_MONITORS 16u
|
||||
#define UURF_MONITOR_BYTES 40u
|
||||
#define UURF_HEADER_BYTES \
|
||||
(UURF_BASE_HEADER_BYTES + UURF_MAX_MONITORS * UURF_MONITOR_BYTES)
|
||||
#define UURF_FLAG_COMPOSITE 1u
|
||||
|
||||
struct uurf_monitor_layout {
|
||||
int32_t logical_x;
|
||||
int32_t logical_y;
|
||||
uint32_t logical_width;
|
||||
uint32_t logical_height;
|
||||
uint32_t frame_x;
|
||||
uint32_t frame_y;
|
||||
uint32_t frame_width;
|
||||
uint32_t frame_height;
|
||||
uint32_t capture_width;
|
||||
uint32_t capture_height;
|
||||
};
|
||||
_Static_assert(sizeof(struct uurf_monitor_layout) == UURF_MONITOR_BYTES,
|
||||
"monitor layout ABI changed");
|
||||
|
||||
static inline size_t uurf_slot_offset(uint64_t sequence, size_t slot_bytes)
|
||||
{
|
||||
|
||||
@@ -75,6 +75,11 @@ static int capture_round_trip(void)
|
||||
put_u32(transport + 16, stride);
|
||||
put_u32(transport + 20, 1);
|
||||
put_u64(transport + 24, 1);
|
||||
put_u32(transport + 36, 1);
|
||||
put_u32(transport + UURF_BASE_HEADER_BYTES + 8, width);
|
||||
put_u32(transport + UURF_BASE_HEADER_BYTES + 12, height);
|
||||
put_u32(transport + UURF_BASE_HEADER_BYTES + 24, width);
|
||||
put_u32(transport + UURF_BASE_HEADER_BYTES + 28, height);
|
||||
unsigned char *slot = transport + uurf_slot_offset(1, slot_bytes);
|
||||
put_u64(slot, 2);
|
||||
for (size_t offset = 8; offset < slot_bytes; offset += 4) {
|
||||
|
||||
+857
-17
@@ -27,6 +27,7 @@
|
||||
#include <tlhelp32.h>
|
||||
#include <dxgi.h>
|
||||
|
||||
#include <limits.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
@@ -42,7 +43,35 @@
|
||||
static UINT(WINAPI *original_send_input)(UINT, LPINPUT, int);
|
||||
static HRESULT(WINAPI *original_create_dxgi_factory1)(REFIID, void **);
|
||||
static FARPROC(WINAPI *original_get_proc_address)(HMODULE, LPCSTR);
|
||||
static HMODULE hook_module;
|
||||
static int(WINAPI *original_get_system_metrics)(int);
|
||||
static BOOL(WINAPI *original_get_monitor_info_a)(HMONITOR, LPMONITORINFO);
|
||||
static BOOL(WINAPI *original_get_monitor_info_w)(HMONITOR, LPMONITORINFO);
|
||||
static BOOL(WINAPI *original_enum_display_settings_a)(LPCSTR, DWORD,
|
||||
LPDEVMODEA);
|
||||
static BOOL(WINAPI *original_enum_display_settings_w)(LPCWSTR, DWORD,
|
||||
LPDEVMODEW);
|
||||
static BOOL(WINAPI *original_enum_display_settings_ex_w)(LPCWSTR, DWORD,
|
||||
LPDEVMODEW, DWORD);
|
||||
static int(WINAPI *original_get_device_caps)(HDC, int);
|
||||
static LONG(WINAPI *original_query_display_config)(UINT, UINT *,
|
||||
DISPLAYCONFIG_PATH_INFO *,
|
||||
UINT *,
|
||||
DISPLAYCONFIG_MODE_INFO *,
|
||||
DISPLAYCONFIG_TOPOLOGY_ID *);
|
||||
UINT WINAPI hook_send_input(UINT count, LPINPUT inputs, int size);
|
||||
static int WINAPI hook_get_system_metrics(int);
|
||||
static BOOL WINAPI hook_get_monitor_info_a(HMONITOR, LPMONITORINFO);
|
||||
static BOOL WINAPI hook_get_monitor_info_w(HMONITOR, LPMONITORINFO);
|
||||
static BOOL WINAPI hook_enum_display_settings_a(LPCSTR, DWORD, LPDEVMODEA);
|
||||
static BOOL WINAPI hook_enum_display_settings_w(LPCWSTR, DWORD, LPDEVMODEW);
|
||||
static BOOL WINAPI hook_enum_display_settings_ex_w(LPCWSTR, DWORD, LPDEVMODEW,
|
||||
DWORD);
|
||||
static int WINAPI hook_get_device_caps(HDC, int);
|
||||
static LONG WINAPI hook_query_display_config(UINT, UINT *,
|
||||
DISPLAYCONFIG_PATH_INFO *, UINT *,
|
||||
DISPLAYCONFIG_MODE_INFO *,
|
||||
DISPLAYCONFIG_TOPOLOGY_ID *);
|
||||
|
||||
static volatile LONG dxgi_factories_patched = 0;
|
||||
static volatile LONG dxgi_adapters_patched = 0;
|
||||
@@ -50,6 +79,9 @@ static volatile LONG dxgi_outputs_patched = 0;
|
||||
static volatile LONG dxgi_duplicate_calls = 0;
|
||||
static volatile LONG dxgi_dup_acquires = 0;
|
||||
static volatile LONG dxgi_dup_frames = 0;
|
||||
static volatile LONG frame_crop_debug_count = 0;
|
||||
static volatile LONG offorigin_crop_debug_count = 0;
|
||||
static void hook_log(const char *text);
|
||||
|
||||
static HRESULT __attribute__((unused))(STDMETHODCALLTYPE *original_dxgi_acquire_next_frame)(
|
||||
void *duplication, UINT timeout, void *frame_info, void **resource) = NULL;
|
||||
@@ -234,6 +266,8 @@ static HANDLE frame_map_handle = NULL;
|
||||
static uint32_t frame_width;
|
||||
static uint32_t frame_height;
|
||||
static uint32_t frame_stride;
|
||||
static uint32_t frame_flags;
|
||||
static uint32_t frame_monitor_count;
|
||||
static uint64_t frame_slot_bytes;
|
||||
static unsigned char *frame_snapshot;
|
||||
static size_t frame_snapshot_capacity;
|
||||
@@ -241,6 +275,7 @@ static size_t frame_map_size;
|
||||
static BY_HANDLE_FILE_INFORMATION frame_identity;
|
||||
static ULONGLONG frame_checked_at;
|
||||
static SRWLOCK frame_lock = SRWLOCK_INIT;
|
||||
static int capture_geometry_enabled;
|
||||
|
||||
static char *read_ini_value(const char *path, const char *key);
|
||||
|
||||
@@ -280,6 +315,8 @@ static void clear_frame_map(void)
|
||||
frame_map = NULL;
|
||||
frame_map_handle = NULL;
|
||||
frame_map_size = 0;
|
||||
frame_flags = 0;
|
||||
frame_monitor_count = 0;
|
||||
}
|
||||
|
||||
/* Producers publish immutable geometry via atomic replacement. Re-check the
|
||||
@@ -347,10 +384,13 @@ static int ensure_frame_map(void)
|
||||
frame_width = load_u32(header + 8);
|
||||
frame_height = load_u32(header + 12);
|
||||
frame_stride = load_u32(header + 16);
|
||||
frame_flags = load_u32(header + 32);
|
||||
frame_monitor_count = load_u32(header + 36);
|
||||
frame_slot_bytes = 8ull + (uint64_t)frame_stride * frame_height;
|
||||
uint64_t expected = UURF_HEADER_BYTES + UURF_SLOT_COUNT * frame_slot_bytes;
|
||||
if (frame_width == 0 || frame_height == 0 ||
|
||||
frame_width > 16384 || frame_height > 16384 ||
|
||||
frame_monitor_count == 0 || frame_monitor_count > UURF_MAX_MONITORS ||
|
||||
frame_stride != frame_width * 4 ||
|
||||
(uint64_t)frame_stride * frame_height > 256ull * 1024 * 1024 ||
|
||||
expected > (uint64_t)size.QuadPart) {
|
||||
@@ -359,12 +399,515 @@ static int ensure_frame_map(void)
|
||||
frame_map_handle = NULL;
|
||||
return 0;
|
||||
}
|
||||
for (uint32_t i = 0; i < frame_monitor_count; ++i) {
|
||||
const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES;
|
||||
uint32_t x = load_u32(item + 16), y = load_u32(item + 20);
|
||||
uint32_t w = load_u32(item + 24), h = load_u32(item + 28);
|
||||
if (load_u32(item + 8) == 0 || load_u32(item + 12) == 0 ||
|
||||
w == 0 || h == 0 || x >= frame_width || y >= frame_height ||
|
||||
w > frame_width - x || h > frame_height - y) {
|
||||
UnmapViewOfFile(view);
|
||||
CloseHandle(frame_map_handle);
|
||||
frame_map_handle = NULL;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
frame_map_size = (size_t)size.QuadPart;
|
||||
frame_map = view;
|
||||
frame_identity = identity;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int64_t abs_i64(int64_t value)
|
||||
{
|
||||
return value < 0 ? -value : value;
|
||||
}
|
||||
|
||||
/* Compare relative extents, centers and aspect ratio, so a uniform XWayland
|
||||
* scale cannot make a larger adjacent monitor look like the smaller one. */
|
||||
static const unsigned char *find_frame_monitor(const unsigned char *header,
|
||||
const RECT *target,
|
||||
int screen_left,
|
||||
int screen_top,
|
||||
int screen_width,
|
||||
int screen_height)
|
||||
{
|
||||
const unsigned char *best = NULL;
|
||||
int64_t min_x = INT64_MAX, min_y = INT64_MAX;
|
||||
int64_t max_x = INT64_MIN, max_y = INT64_MIN;
|
||||
int64_t target_width = (int64_t)target->right - target->left;
|
||||
int64_t target_height = (int64_t)target->bottom - target->top;
|
||||
int64_t target_center_x = (int64_t)target->left + target->right;
|
||||
int64_t target_center_y = (int64_t)target->top + target->bottom;
|
||||
int64_t best_score = INT64_MAX;
|
||||
|
||||
if (screen_width <= 0 || screen_height <= 0 || target_width <= 0 ||
|
||||
target_height <= 0 || frame_monitor_count == 0 ||
|
||||
frame_monitor_count != (uint32_t)GetSystemMetrics(SM_CMONITORS))
|
||||
return NULL;
|
||||
|
||||
for (uint32_t i = 0; i < frame_monitor_count; ++i) {
|
||||
const unsigned char *item = header + UURF_BASE_HEADER_BYTES +
|
||||
i * UURF_MONITOR_BYTES;
|
||||
int64_t x = (int32_t)load_u32(item);
|
||||
int64_t y = (int32_t)load_u32(item + 4);
|
||||
int64_t width = load_u32(item + 8);
|
||||
int64_t height = load_u32(item + 12);
|
||||
if (x < min_x)
|
||||
min_x = x;
|
||||
if (y < min_y)
|
||||
min_y = y;
|
||||
if (x + width > max_x)
|
||||
max_x = x + width;
|
||||
if (y + height > max_y)
|
||||
max_y = y + height;
|
||||
}
|
||||
if (max_x <= min_x || max_y <= min_y)
|
||||
return NULL;
|
||||
|
||||
int64_t target_x = ((target_center_x - 2ll * screen_left) * 1000000) /
|
||||
(2ll * screen_width);
|
||||
int64_t target_y = ((target_center_y - 2ll * screen_top) * 1000000) /
|
||||
(2ll * screen_height);
|
||||
|
||||
for (uint32_t i = 0; i < frame_monitor_count; ++i) {
|
||||
const unsigned char *item = header + UURF_BASE_HEADER_BYTES +
|
||||
i * UURF_MONITOR_BYTES;
|
||||
int64_t x = (int32_t)load_u32(item);
|
||||
int64_t y = (int32_t)load_u32(item + 4);
|
||||
int64_t width = load_u32(item + 8);
|
||||
int64_t height = load_u32(item + 12);
|
||||
int64_t center_x = ((2 * x + width - 2 * min_x) * 1000000) /
|
||||
(2 * (max_x - min_x));
|
||||
int64_t center_y = ((2 * y + height - 2 * min_y) * 1000000) /
|
||||
(2 * (max_y - min_y));
|
||||
int64_t size_error =
|
||||
abs_i64(target_width * 1000000 / screen_width -
|
||||
width * 1000000 / (max_x - min_x)) +
|
||||
abs_i64(target_height * 1000000 / screen_height -
|
||||
height * 1000000 / (max_y - min_y));
|
||||
int64_t aspect_left = target_width * height;
|
||||
int64_t aspect_right = target_height * width;
|
||||
int64_t aspect_error =
|
||||
abs_i64(aspect_left - aspect_right) * 1000000 /
|
||||
(aspect_left > aspect_right ? aspect_left : aspect_right);
|
||||
int64_t position_error = abs_i64(target_x - center_x) +
|
||||
abs_i64(target_y - center_y);
|
||||
int64_t score = size_error * 2 + position_error * 4 + aspect_error;
|
||||
if (score < best_score) {
|
||||
best_score = score;
|
||||
best = item;
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
typedef struct uur_frame_monitor {
|
||||
int32_t logical_x;
|
||||
int32_t logical_y;
|
||||
uint32_t logical_width;
|
||||
uint32_t logical_height;
|
||||
uint32_t frame_x;
|
||||
uint32_t frame_y;
|
||||
uint32_t frame_width;
|
||||
uint32_t frame_height;
|
||||
uint32_t capture_width;
|
||||
uint32_t capture_height;
|
||||
} uur_frame_monitor;
|
||||
|
||||
/* Copy monitor metadata while holding the same lock used to remap the shared
|
||||
* frame. The primary monitor remains at (0,0); other monitors use their
|
||||
* captured stream's real pixel dimensions rather than XWayland's scaled
|
||||
* monitor rectangles. */
|
||||
static int copy_frame_monitors(const RECT *target, uur_frame_monitor *items,
|
||||
uint32_t *count, uint32_t *primary_index,
|
||||
uint32_t *target_index)
|
||||
{
|
||||
int result = 0;
|
||||
if (!capture_geometry_enabled)
|
||||
return 0;
|
||||
AcquireSRWLockExclusive(&frame_lock);
|
||||
if (!ensure_frame_map())
|
||||
goto done;
|
||||
if ((frame_flags & UURF_FLAG_COMPOSITE) == 0)
|
||||
goto done;
|
||||
|
||||
const unsigned char *header = (const unsigned char *)frame_map;
|
||||
int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN);
|
||||
int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN);
|
||||
int screen_width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
|
||||
int screen_height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
|
||||
if (screen_width < 1)
|
||||
screen_width = (int)frame_width;
|
||||
if (screen_height < 1)
|
||||
screen_height = (int)frame_height;
|
||||
|
||||
POINT origin = {0, 0};
|
||||
HMONITOR primary = MonitorFromPoint(origin, MONITOR_DEFAULTTOPRIMARY);
|
||||
MONITORINFO primary_info;
|
||||
ZeroMemory(&primary_info, sizeof(primary_info));
|
||||
primary_info.cbSize = sizeof(primary_info);
|
||||
if (primary == NULL || !GetMonitorInfoA(primary, &primary_info))
|
||||
goto done;
|
||||
const unsigned char *primary_layout = find_frame_monitor(
|
||||
header, &primary_info.rcMonitor, screen_left, screen_top,
|
||||
screen_width, screen_height);
|
||||
if (primary_layout == NULL)
|
||||
goto done;
|
||||
|
||||
const unsigned char *selected_layout = target != NULL
|
||||
? find_frame_monitor(header, target, screen_left, screen_top,
|
||||
screen_width, screen_height)
|
||||
: NULL;
|
||||
uint32_t total = frame_monitor_count;
|
||||
if (total == 0 || total > UURF_MAX_MONITORS)
|
||||
goto done;
|
||||
|
||||
uint32_t primary_i =
|
||||
(uint32_t)(primary_layout - (header + UURF_BASE_HEADER_BYTES)) /
|
||||
UURF_MONITOR_BYTES;
|
||||
uint32_t target_i = selected_layout != NULL
|
||||
? (uint32_t)(selected_layout - (header + UURF_BASE_HEADER_BYTES)) /
|
||||
UURF_MONITOR_BYTES
|
||||
: UINT32_MAX;
|
||||
for (uint32_t i = 0; i < total; ++i) {
|
||||
const unsigned char *item = header + UURF_BASE_HEADER_BYTES +
|
||||
i * UURF_MONITOR_BYTES;
|
||||
items[i].logical_x = (int32_t)load_u32(item);
|
||||
items[i].logical_y = (int32_t)load_u32(item + 4);
|
||||
items[i].logical_width = load_u32(item + 8);
|
||||
items[i].logical_height = load_u32(item + 12);
|
||||
items[i].frame_x = load_u32(item + 16);
|
||||
items[i].frame_y = load_u32(item + 20);
|
||||
items[i].frame_width = load_u32(item + 24);
|
||||
items[i].frame_height = load_u32(item + 28);
|
||||
items[i].capture_width = load_u32(item + 32);
|
||||
items[i].capture_height = load_u32(item + 36);
|
||||
if (items[i].capture_width == 0 || items[i].capture_height == 0) {
|
||||
items[i].capture_width = items[i].frame_width;
|
||||
items[i].capture_height = items[i].frame_height;
|
||||
}
|
||||
}
|
||||
if (primary_i >= total ||
|
||||
(target_i != UINT32_MAX && target_i >= total))
|
||||
goto done;
|
||||
*count = total;
|
||||
*primary_index = primary_i;
|
||||
if (target_index != NULL)
|
||||
*target_index = target_i;
|
||||
result = 1;
|
||||
|
||||
done:
|
||||
ReleaseSRWLockExclusive(&frame_lock);
|
||||
return result;
|
||||
}
|
||||
|
||||
static int frame_monitor_rect(const uur_frame_monitor *items,
|
||||
uint32_t primary_index, uint32_t index,
|
||||
RECT *rect)
|
||||
{
|
||||
if (items == NULL || rect == NULL || index >= UURF_MAX_MONITORS ||
|
||||
primary_index >= UURF_MAX_MONITORS ||
|
||||
items[index].frame_width == 0 || items[index].frame_height == 0)
|
||||
return 0;
|
||||
int64_t left = (int64_t)items[index].frame_x - items[primary_index].frame_x;
|
||||
int64_t top = (int64_t)items[index].frame_y - items[primary_index].frame_y;
|
||||
int64_t right = left + items[index].frame_width;
|
||||
int64_t bottom = top + items[index].frame_height;
|
||||
if (left < LONG_MIN || top < LONG_MIN || right > LONG_MAX ||
|
||||
bottom > LONG_MAX)
|
||||
return 0;
|
||||
rect->left = (LONG)left;
|
||||
rect->top = (LONG)top;
|
||||
rect->right = (LONG)right;
|
||||
rect->bottom = (LONG)bottom;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static LONG scale_monitor_offset(LONG value, LONG old_size, LONG new_size)
|
||||
{
|
||||
if (old_size <= 0)
|
||||
return 0;
|
||||
return (LONG)((int64_t)value * new_size / old_size);
|
||||
}
|
||||
|
||||
static void apply_monitor_layout(LPMONITORINFO info,
|
||||
const uur_frame_monitor *items,
|
||||
uint32_t primary_index, uint32_t index)
|
||||
{
|
||||
RECT adjusted;
|
||||
if (info == NULL ||
|
||||
!frame_monitor_rect(items, primary_index, index, &adjusted))
|
||||
return;
|
||||
RECT old_monitor = info->rcMonitor;
|
||||
RECT old_work = info->rcWork;
|
||||
LONG old_width = old_monitor.right - old_monitor.left;
|
||||
LONG old_height = old_monitor.bottom - old_monitor.top;
|
||||
LONG new_width = adjusted.right - adjusted.left;
|
||||
LONG new_height = adjusted.bottom - adjusted.top;
|
||||
info->rcMonitor = adjusted;
|
||||
info->rcWork.left = adjusted.left +
|
||||
scale_monitor_offset(old_work.left - old_monitor.left, old_width,
|
||||
new_width);
|
||||
info->rcWork.right = adjusted.left +
|
||||
scale_monitor_offset(old_work.right - old_monitor.left, old_width,
|
||||
new_width);
|
||||
info->rcWork.top = adjusted.top +
|
||||
scale_monitor_offset(old_work.top - old_monitor.top, old_height,
|
||||
new_height);
|
||||
info->rcWork.bottom = adjusted.top +
|
||||
scale_monitor_offset(old_work.bottom - old_monitor.top, old_height,
|
||||
new_height);
|
||||
}
|
||||
|
||||
static int copy_layout_for_monitor_rect(const RECT *target,
|
||||
uur_frame_monitor *items,
|
||||
uint32_t *count,
|
||||
uint32_t *primary_index,
|
||||
uint32_t *target_index)
|
||||
{
|
||||
return copy_frame_monitors(target, items, count, primary_index,
|
||||
target_index);
|
||||
}
|
||||
|
||||
static void remap_devmode(DEVMODEW *mode)
|
||||
{
|
||||
if (mode == NULL || (mode->dmFields & (DM_POSITION | DM_PELSWIDTH |
|
||||
DM_PELSHEIGHT)) !=
|
||||
(DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT) ||
|
||||
mode->dmPelsWidth == 0 || mode->dmPelsHeight == 0)
|
||||
return;
|
||||
RECT old_rect = {mode->dmPosition.x, mode->dmPosition.y,
|
||||
mode->dmPosition.x + (LONG)mode->dmPelsWidth,
|
||||
mode->dmPosition.y + (LONG)mode->dmPelsHeight};
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX;
|
||||
if (!copy_layout_for_monitor_rect(&old_rect, items, &count,
|
||||
&primary_index, &target_index) ||
|
||||
target_index >= count)
|
||||
return;
|
||||
RECT adjusted;
|
||||
if (!frame_monitor_rect(items, primary_index, target_index, &adjusted))
|
||||
return;
|
||||
mode->dmPosition.x = adjusted.left;
|
||||
mode->dmPosition.y = adjusted.top;
|
||||
mode->dmPelsWidth = items[target_index].frame_width;
|
||||
mode->dmPelsHeight = items[target_index].frame_height;
|
||||
mode->dmFields |= DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT;
|
||||
}
|
||||
|
||||
static int WINAPI hook_get_system_metrics(int index)
|
||||
{
|
||||
int fallback = original_get_system_metrics != NULL
|
||||
? original_get_system_metrics(index)
|
||||
: GetSystemMetrics(index);
|
||||
if (index != SM_CXSCREEN && index != SM_CYSCREEN &&
|
||||
index != SM_XVIRTUALSCREEN && index != SM_YVIRTUALSCREEN &&
|
||||
index != SM_CXVIRTUALSCREEN && index != SM_CYVIRTUALSCREEN)
|
||||
return fallback;
|
||||
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0;
|
||||
if (!copy_frame_monitors(NULL, items, &count, &primary_index, NULL))
|
||||
return fallback;
|
||||
if (index == SM_CXSCREEN)
|
||||
return (int)items[primary_index].frame_width;
|
||||
if (index == SM_CYSCREEN)
|
||||
return (int)items[primary_index].frame_height;
|
||||
|
||||
int64_t min_x = INT64_MAX, min_y = INT64_MAX;
|
||||
int64_t max_x = INT64_MIN, max_y = INT64_MIN;
|
||||
for (uint32_t i = 0; i < count; ++i) {
|
||||
RECT rect;
|
||||
if (!frame_monitor_rect(items, primary_index, i, &rect))
|
||||
continue;
|
||||
if (rect.left < min_x)
|
||||
min_x = rect.left;
|
||||
if (rect.top < min_y)
|
||||
min_y = rect.top;
|
||||
if (rect.right > max_x)
|
||||
max_x = rect.right;
|
||||
if (rect.bottom > max_y)
|
||||
max_y = rect.bottom;
|
||||
}
|
||||
if (min_x == INT64_MAX || min_y == INT64_MAX || max_x <= min_x ||
|
||||
max_y <= min_y || max_x - min_x > INT_MAX ||
|
||||
max_y - min_y > INT_MAX)
|
||||
return fallback;
|
||||
switch (index) {
|
||||
case SM_XVIRTUALSCREEN:
|
||||
return (int)min_x;
|
||||
case SM_YVIRTUALSCREEN:
|
||||
return (int)min_y;
|
||||
case SM_CXVIRTUALSCREEN:
|
||||
return (int)(max_x - min_x);
|
||||
case SM_CYVIRTUALSCREEN:
|
||||
return (int)(max_y - min_y);
|
||||
default:
|
||||
return fallback;
|
||||
}
|
||||
}
|
||||
|
||||
static BOOL WINAPI hook_get_monitor_info_a(HMONITOR monitor,
|
||||
LPMONITORINFO info)
|
||||
{
|
||||
BOOL result = original_get_monitor_info_a != NULL
|
||||
? original_get_monitor_info_a(monitor, info)
|
||||
: GetMonitorInfoA(monitor, info);
|
||||
if (!result || info == NULL || info->cbSize < sizeof(MONITORINFO))
|
||||
return result;
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX;
|
||||
if (copy_layout_for_monitor_rect(&info->rcMonitor, items, &count,
|
||||
&primary_index, &target_index) &&
|
||||
target_index < count)
|
||||
apply_monitor_layout(info, items, primary_index, target_index);
|
||||
return result;
|
||||
}
|
||||
|
||||
static BOOL WINAPI hook_get_monitor_info_w(HMONITOR monitor,
|
||||
LPMONITORINFO info)
|
||||
{
|
||||
BOOL result = original_get_monitor_info_w != NULL
|
||||
? original_get_monitor_info_w(monitor, info)
|
||||
: GetMonitorInfoW(monitor, info);
|
||||
if (!result || info == NULL || info->cbSize < sizeof(MONITORINFO))
|
||||
return result;
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX;
|
||||
if (copy_layout_for_monitor_rect(&info->rcMonitor, items, &count,
|
||||
&primary_index, &target_index) &&
|
||||
target_index < count)
|
||||
apply_monitor_layout(info, items, primary_index, target_index);
|
||||
return result;
|
||||
}
|
||||
|
||||
static BOOL WINAPI hook_enum_display_settings_w(LPCWSTR device, DWORD mode_num,
|
||||
LPDEVMODEW mode)
|
||||
{
|
||||
BOOL result = original_enum_display_settings_w != NULL
|
||||
? original_enum_display_settings_w(device, mode_num, mode)
|
||||
: FALSE;
|
||||
if (result && mode_num == ENUM_CURRENT_SETTINGS)
|
||||
remap_devmode(mode);
|
||||
return result;
|
||||
}
|
||||
|
||||
static BOOL WINAPI hook_enum_display_settings_ex_w(LPCWSTR device,
|
||||
DWORD mode_num,
|
||||
LPDEVMODEW mode,
|
||||
DWORD flags)
|
||||
{
|
||||
BOOL result = original_enum_display_settings_ex_w != NULL
|
||||
? original_enum_display_settings_ex_w(device, mode_num,
|
||||
mode, flags)
|
||||
: FALSE;
|
||||
if (result && mode_num == ENUM_CURRENT_SETTINGS)
|
||||
remap_devmode(mode);
|
||||
return result;
|
||||
}
|
||||
|
||||
static BOOL WINAPI hook_enum_display_settings_a(LPCSTR device, DWORD mode_num,
|
||||
LPDEVMODEA mode)
|
||||
{
|
||||
BOOL result = original_enum_display_settings_a != NULL
|
||||
? original_enum_display_settings_a(device, mode_num,
|
||||
mode)
|
||||
: FALSE;
|
||||
if (!result || mode_num != ENUM_CURRENT_SETTINGS || mode == NULL ||
|
||||
(mode->dmFields & (DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT)) !=
|
||||
(DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT) ||
|
||||
mode->dmPelsWidth == 0 || mode->dmPelsHeight == 0)
|
||||
return result;
|
||||
RECT old_rect = {mode->dmPosition.x, mode->dmPosition.y,
|
||||
mode->dmPosition.x + (LONG)mode->dmPelsWidth,
|
||||
mode->dmPosition.y + (LONG)mode->dmPelsHeight};
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX;
|
||||
if (!copy_layout_for_monitor_rect(&old_rect, items, &count,
|
||||
&primary_index, &target_index) ||
|
||||
target_index >= count)
|
||||
return result;
|
||||
RECT adjusted;
|
||||
if (!frame_monitor_rect(items, primary_index, target_index, &adjusted))
|
||||
return result;
|
||||
mode->dmPosition.x = adjusted.left;
|
||||
mode->dmPosition.y = adjusted.top;
|
||||
mode->dmPelsWidth = items[target_index].frame_width;
|
||||
mode->dmPelsHeight = items[target_index].frame_height;
|
||||
mode->dmFields |= DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT;
|
||||
return result;
|
||||
}
|
||||
|
||||
static int WINAPI hook_get_device_caps(HDC dc, int index)
|
||||
{
|
||||
int result = original_get_device_caps != NULL
|
||||
? original_get_device_caps(dc, index)
|
||||
: GetDeviceCaps(dc, index);
|
||||
if ((index != HORZRES && index != VERTRES) || dc == NULL ||
|
||||
original_get_device_caps == NULL ||
|
||||
original_get_device_caps(dc, TECHNOLOGY) != DT_RASDISPLAY)
|
||||
return result;
|
||||
|
||||
POINT origin;
|
||||
if (!GetDCOrgEx(dc, &origin))
|
||||
return result;
|
||||
int width = original_get_device_caps(dc, HORZRES);
|
||||
int height = original_get_device_caps(dc, VERTRES);
|
||||
if (width <= 0 || height <= 0)
|
||||
return result;
|
||||
RECT old_rect = {origin.x, origin.y, origin.x + width, origin.y + height};
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX;
|
||||
if (!copy_layout_for_monitor_rect(&old_rect, items, &count,
|
||||
&primary_index, &target_index) ||
|
||||
target_index >= count)
|
||||
return result;
|
||||
return index == HORZRES ? (int)items[target_index].frame_width
|
||||
: (int)items[target_index].frame_height;
|
||||
}
|
||||
|
||||
static LONG WINAPI hook_query_display_config(
|
||||
UINT flags, UINT *path_count, DISPLAYCONFIG_PATH_INFO *paths,
|
||||
UINT *mode_count, DISPLAYCONFIG_MODE_INFO *modes,
|
||||
DISPLAYCONFIG_TOPOLOGY_ID *topology)
|
||||
{
|
||||
LONG result = original_query_display_config != NULL
|
||||
? original_query_display_config(flags, path_count, paths,
|
||||
mode_count, modes,
|
||||
topology)
|
||||
: ERROR_NOT_SUPPORTED;
|
||||
if (result != ERROR_SUCCESS || path_count == NULL || mode_count == NULL ||
|
||||
paths == NULL || modes == NULL)
|
||||
return result;
|
||||
|
||||
for (UINT i = 0; i < *path_count; ++i) {
|
||||
UINT source_index = paths[i].sourceInfo.modeInfoIdx;
|
||||
if (source_index >= *mode_count ||
|
||||
modes[source_index].infoType != DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE)
|
||||
continue;
|
||||
DISPLAYCONFIG_SOURCE_MODE *source = &modes[source_index].sourceMode;
|
||||
RECT old_rect = {source->position.x, source->position.y,
|
||||
source->position.x + (LONG)source->width,
|
||||
source->position.y + (LONG)source->height};
|
||||
uur_frame_monitor items[UURF_MAX_MONITORS];
|
||||
uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX;
|
||||
if (!copy_layout_for_monitor_rect(&old_rect, items, &count,
|
||||
&primary_index, &target_index) ||
|
||||
target_index >= count)
|
||||
continue;
|
||||
RECT adjusted;
|
||||
if (!frame_monitor_rect(items, primary_index, target_index, &adjusted))
|
||||
continue;
|
||||
source->position.x = adjusted.left;
|
||||
source->position.y = adjusted.top;
|
||||
source->width = items[target_index].frame_width;
|
||||
source->height = items[target_index].frame_height;
|
||||
/* Hardware target timings retain their actual clock and scanout. */
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static BOOL source_is_screen_dc(HDC source)
|
||||
{
|
||||
return GetObjectType(source) == OBJ_DC &&
|
||||
@@ -492,13 +1035,10 @@ static BOOL feed_capture_frame_locked(HDC hdc_dest, int x, int y, int width,
|
||||
screen_width = (int)fw;
|
||||
if (screen_height < 1)
|
||||
screen_height = (int)fh;
|
||||
/* The frame holds exactly one monitor, but the client may ask
|
||||
* for that monitor's whole rectangle. Wine reports the
|
||||
* compositor's monitors in its own order, so the virtual desktop
|
||||
* is only the right basis for a partial request; a complete
|
||||
* monitor request must map onto the whole frame. Fractional
|
||||
* scaling can give Xwayland and the portal different pixel
|
||||
* sizes, so compare aspect ratios rather than resolutions. */
|
||||
/* A single-stream frame represents one selected monitor, so a
|
||||
* complete monitor request maps to the whole frame. Composite
|
||||
* frames already follow the virtual desktop layout and must be
|
||||
* cropped by the request's screen coordinates instead. */
|
||||
int sx = 0;
|
||||
int sy = 0;
|
||||
int sw = 0;
|
||||
@@ -512,9 +1052,13 @@ static BOOL feed_capture_frame_locked(HDC hdc_dest, int x, int y, int width,
|
||||
? MonitorFromRect(&requested, MONITOR_DEFAULTTONULL)
|
||||
: NULL;
|
||||
MONITORINFO info;
|
||||
ZeroMemory(&info, sizeof(info));
|
||||
info.cbSize = sizeof(info);
|
||||
BOOL whole_monitor = FALSE;
|
||||
if (monitor != NULL && GetMonitorInfoA(monitor, &info)) {
|
||||
BOOL have_monitor_info =
|
||||
monitor != NULL && GetMonitorInfoA(monitor, &info);
|
||||
if ((frame_flags & UURF_FLAG_COMPOSITE) == 0 &&
|
||||
have_monitor_info) {
|
||||
whole_monitor =
|
||||
info.rcMonitor.left == requested.left &&
|
||||
info.rcMonitor.top == requested.top &&
|
||||
@@ -523,23 +1067,241 @@ static BOOL feed_capture_frame_locked(HDC hdc_dest, int x, int y, int width,
|
||||
(int64_t)(info.rcMonitor.right - info.rcMonitor.left) * fh ==
|
||||
(int64_t)(info.rcMonitor.bottom - info.rcMonitor.top) * fw;
|
||||
}
|
||||
if (whole_monitor) {
|
||||
BOOL monitor_local_crop = FALSE;
|
||||
const unsigned char *selected_layout = NULL;
|
||||
const char *crop_mode = "screen";
|
||||
if ((frame_flags & UURF_FLAG_COMPOSITE) != 0 &&
|
||||
have_monitor_info && source_width > 0 && source_height > 0) {
|
||||
int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN);
|
||||
int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN);
|
||||
RECT crop_monitor = info.rcMonitor;
|
||||
const unsigned char *layout = NULL;
|
||||
/* Projected rectangles must be checked first: a projected
|
||||
* secondary monitor may lie inside Wine's old primary bounds. */
|
||||
if (capture_geometry_enabled) {
|
||||
POINT origin = {0, 0};
|
||||
HMONITOR primary = MonitorFromPoint(origin, MONITOR_DEFAULTTOPRIMARY);
|
||||
MONITORINFO primary_info = {0};
|
||||
primary_info.cbSize = sizeof(primary_info);
|
||||
const unsigned char *primary_layout = NULL;
|
||||
if (primary != NULL && GetMonitorInfoA(primary, &primary_info))
|
||||
primary_layout = find_frame_monitor(header, &primary_info.rcMonitor,
|
||||
screen_left, screen_top, screen_width, screen_height);
|
||||
for (uint32_t i = 0; primary_layout != NULL && i < frame_monitor_count; ++i) {
|
||||
const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES;
|
||||
LONG left = (LONG)load_u32(item + 16) - (LONG)load_u32(primary_layout + 16);
|
||||
LONG top = (LONG)load_u32(item + 20) - (LONG)load_u32(primary_layout + 20);
|
||||
RECT projected = {left, top, left + (LONG)load_u32(item + 24),
|
||||
top + (LONG)load_u32(item + 28)};
|
||||
if (requested.left >= projected.left && requested.top >= projected.top &&
|
||||
requested.right <= projected.right && requested.bottom <= projected.bottom) {
|
||||
layout = item;
|
||||
crop_monitor = projected;
|
||||
crop_mode = "stream-local";
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (layout == NULL)
|
||||
layout = find_frame_monitor(header, &info.rcMonitor, screen_left, screen_top,
|
||||
screen_width, screen_height);
|
||||
if (layout != NULL) {
|
||||
selected_layout = layout;
|
||||
uint32_t frame_x = load_u32(layout + 16);
|
||||
uint32_t frame_y = load_u32(layout + 20);
|
||||
uint32_t frame_w = load_u32(layout + 24);
|
||||
uint32_t frame_h = load_u32(layout + 28);
|
||||
int64_t monitor_width = (int64_t)crop_monitor.right - crop_monitor.left;
|
||||
int64_t monitor_height = (int64_t)crop_monitor.bottom - crop_monitor.top;
|
||||
if (!monitor_local_crop &&
|
||||
requested.left >= crop_monitor.left &&
|
||||
requested.top >= crop_monitor.top &&
|
||||
requested.right <= crop_monitor.right &&
|
||||
requested.bottom <= crop_monitor.bottom &&
|
||||
monitor_width > 0 && monitor_height > 0) {
|
||||
int64_t local_x0 =
|
||||
(int64_t)requested.left - crop_monitor.left;
|
||||
int64_t local_y0 =
|
||||
(int64_t)requested.top - crop_monitor.top;
|
||||
int64_t local_x1 = local_x0 + source_width;
|
||||
int64_t local_y1 = local_y0 + source_height;
|
||||
int64_t sx0 =
|
||||
frame_x + local_x0 * frame_w / monitor_width;
|
||||
int64_t sy0 =
|
||||
frame_y + local_y0 * frame_h / monitor_height;
|
||||
int64_t sx1 = frame_x +
|
||||
(local_x1 * frame_w + monitor_width - 1) /
|
||||
monitor_width;
|
||||
int64_t sy1 = frame_y +
|
||||
(local_y1 * frame_h + monitor_height - 1) /
|
||||
monitor_height;
|
||||
if (frame_w > 0 && frame_h > 0 &&
|
||||
frame_x <= fw && frame_y <= fh &&
|
||||
frame_w <= fw - frame_x && frame_h <= fh - frame_y) {
|
||||
if (sx0 < 0)
|
||||
sx0 = 0;
|
||||
if (sy0 < 0)
|
||||
sy0 = 0;
|
||||
if (sx1 > fw)
|
||||
sx1 = fw;
|
||||
if (sy1 > fh)
|
||||
sy1 = fh;
|
||||
if (sx1 > sx0 && sy1 > sy0) {
|
||||
sx = (int)sx0;
|
||||
sy = (int)sy0;
|
||||
sw = (int)(sx1 - sx0);
|
||||
sh = (int)(sy1 - sy0);
|
||||
monitor_local_crop = TRUE;
|
||||
if (crop_mode[0] == '\0' ||
|
||||
strcmp(crop_mode, "screen") == 0)
|
||||
crop_mode = "monitor-local";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((frame_flags & UURF_FLAG_COMPOSITE) != 0 &&
|
||||
!monitor_local_crop) {
|
||||
crop_mode = "composite";
|
||||
int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN);
|
||||
int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN);
|
||||
int64_t sx0 = ((int64_t)source_x - screen_left) * fw / screen_width;
|
||||
int64_t sy0 = ((int64_t)source_y - screen_top) * fh / screen_height;
|
||||
/* Keep a nonempty source rectangle nonempty after scaling. */
|
||||
int64_t sx1 = (((int64_t)source_x + source_width - screen_left) * fw + screen_width - 1) / screen_width;
|
||||
int64_t sy1 = (((int64_t)source_y + source_height - screen_top) * fh + screen_height - 1) / screen_height;
|
||||
if (sx0 < 0)
|
||||
sx0 = 0;
|
||||
if (sy0 < 0)
|
||||
sy0 = 0;
|
||||
if (sx1 > fw)
|
||||
sx1 = fw;
|
||||
if (sy1 > fh)
|
||||
sy1 = fh;
|
||||
if (sx1 <= sx0 || sy1 <= sy0)
|
||||
return FALSE;
|
||||
sx = (int)sx0;
|
||||
sy = (int)sy0;
|
||||
sw = (int)(sx1 - sx0);
|
||||
sh = (int)(sy1 - sy0);
|
||||
} else if ((frame_flags & UURF_FLAG_COMPOSITE) == 0 &&
|
||||
whole_monitor) {
|
||||
crop_mode = "whole-monitor";
|
||||
sx = 0;
|
||||
sy = 0;
|
||||
sw = (int)fw;
|
||||
sh = (int)fh;
|
||||
} else {
|
||||
sx = (int)((int64_t)source_x * fw / screen_width);
|
||||
sy = (int)((int64_t)source_y * fh / screen_height);
|
||||
sw = (int)((int64_t)source_width * fw / screen_width);
|
||||
sh = (int)((int64_t)source_height * fh / screen_height);
|
||||
} else if (!monitor_local_crop) {
|
||||
int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN);
|
||||
int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN);
|
||||
int64_t sx0 = ((int64_t)source_x - screen_left) * fw /
|
||||
screen_width;
|
||||
int64_t sy0 = ((int64_t)source_y - screen_top) * fh /
|
||||
screen_height;
|
||||
int64_t sx1 = ((int64_t)source_x + source_width - screen_left) *
|
||||
fw + screen_width - 1;
|
||||
int64_t sy1 = ((int64_t)source_y + source_height - screen_top) *
|
||||
fh + screen_height - 1;
|
||||
sx1 /= screen_width;
|
||||
sy1 /= screen_height;
|
||||
if (sx0 < 0)
|
||||
sx0 = 0;
|
||||
if (sy0 < 0)
|
||||
sy0 = 0;
|
||||
if (sx1 > fw)
|
||||
sx1 = fw;
|
||||
if (sy1 > fh)
|
||||
sy1 = fh;
|
||||
if (sx1 <= sx0 || sy1 <= sy0)
|
||||
return FALSE;
|
||||
sx = (int)sx0;
|
||||
sy = (int)sy0;
|
||||
sw = (int)(sx1 - sx0);
|
||||
sh = (int)(sy1 - sy0);
|
||||
}
|
||||
if (sw < 1)
|
||||
sw = (int)fw;
|
||||
if (sh < 1)
|
||||
sh = (int)fh;
|
||||
LONG debug_index = InterlockedIncrement(&frame_crop_debug_count);
|
||||
LONG offorigin_index = 0;
|
||||
if (have_monitor_info &&
|
||||
(info.rcMonitor.left != 0 || info.rcMonitor.top != 0))
|
||||
offorigin_index =
|
||||
InterlockedIncrement(&offorigin_crop_debug_count);
|
||||
if (debug_index <= 4 ||
|
||||
(offorigin_index > 0 && offorigin_index <= 8)) {
|
||||
char debug[768];
|
||||
LONG monitor_left = have_monitor_info ? info.rcMonitor.left : 0;
|
||||
LONG monitor_top = have_monitor_info ? info.rcMonitor.top : 0;
|
||||
LONG monitor_right = have_monitor_info ? info.rcMonitor.right : 0;
|
||||
LONG monitor_bottom = have_monitor_info ? info.rcMonitor.bottom : 0;
|
||||
LONG layout_x = selected_layout != NULL
|
||||
? (LONG)(int32_t)load_u32(selected_layout)
|
||||
: 0;
|
||||
LONG layout_y = selected_layout != NULL
|
||||
? (LONG)(int32_t)load_u32(selected_layout + 4)
|
||||
: 0;
|
||||
uint32_t layout_w = selected_layout != NULL
|
||||
? load_u32(selected_layout + 8)
|
||||
: 0;
|
||||
uint32_t layout_h = selected_layout != NULL
|
||||
? load_u32(selected_layout + 12)
|
||||
: 0;
|
||||
uint32_t layout_fx = selected_layout != NULL
|
||||
? load_u32(selected_layout + 16)
|
||||
: 0;
|
||||
uint32_t layout_fy = selected_layout != NULL
|
||||
? load_u32(selected_layout + 20)
|
||||
: 0;
|
||||
uint32_t layout_fw = selected_layout != NULL
|
||||
? load_u32(selected_layout + 24)
|
||||
: 0;
|
||||
uint32_t layout_fh = selected_layout != NULL
|
||||
? load_u32(selected_layout + 28)
|
||||
: 0;
|
||||
uint32_t capture_w = selected_layout != NULL
|
||||
? load_u32(selected_layout + 32)
|
||||
: 0;
|
||||
uint32_t capture_h = selected_layout != NULL
|
||||
? load_u32(selected_layout + 36)
|
||||
: 0;
|
||||
sprintf(debug,
|
||||
"crop #%ld offorigin-sample=%ld mode=%s flags=%lu frame=%lux%lu "
|
||||
"src=%d,%d %dx%d dest=%d,%d %dx%d virtual=%ld,%ld %dx%d "
|
||||
"monitor=%ld,%ld-%ld,%ld whole=%d layout=%ld,%ld "
|
||||
"%lux%lu frame-at=%lu,%lu %lux%lu capture=%lux%lu "
|
||||
"crop=%d,%d %dx%d",
|
||||
debug_index, offorigin_index, crop_mode,
|
||||
(unsigned long)frame_flags, (unsigned long)fw,
|
||||
(unsigned long)fh, source_x,
|
||||
source_y, source_width, source_height, x, y, width,
|
||||
height,
|
||||
(LONG)GetSystemMetrics(SM_XVIRTUALSCREEN),
|
||||
(LONG)GetSystemMetrics(SM_YVIRTUALSCREEN),
|
||||
screen_width, screen_height, monitor_left, monitor_top,
|
||||
monitor_right, monitor_bottom, whole_monitor, layout_x,
|
||||
layout_y, (unsigned long)layout_w,
|
||||
(unsigned long)layout_h, (unsigned long)layout_fx,
|
||||
(unsigned long)layout_fy, (unsigned long)layout_fw,
|
||||
(unsigned long)layout_fh, (unsigned long)capture_w,
|
||||
(unsigned long)capture_h, sx, sy, sw, sh);
|
||||
hook_log(debug);
|
||||
}
|
||||
/* Wine's top-down DIB subrectangle path can offset a short
|
||||
* monitor crop from the bottom of the composite. Compact the
|
||||
* chosen rows in-place and draw a whole DIB at source (0,0).
|
||||
* Destination rows precede source rows, so memmove also covers
|
||||
* overlapping crops without another frame-sized allocation. */
|
||||
for (int row = 0; row < sh; ++row)
|
||||
memmove(frame_snapshot + (size_t)row * sw * 4,
|
||||
frame_snapshot + (size_t)(sy + row) * fstride + (size_t)sx * 4,
|
||||
(size_t)sw * 4);
|
||||
bmp_header.biWidth = sw;
|
||||
bmp_header.biHeight = -sh;
|
||||
bmp_header.biSizeImage = (DWORD)((size_t)sw * sh * 4);
|
||||
int result = StretchDIBits(
|
||||
hdc_dest, x, y, width, height, sx, sy, sw, sh,
|
||||
hdc_dest, x, y, width, height, 0, 0, sw, sh,
|
||||
(const void *)frame_snapshot, (const BITMAPINFO *)&bmp_header,
|
||||
DIB_RGB_COLORS, SRCCOPY);
|
||||
ok = result != 0 && (DWORD)result != GDI_ERROR;
|
||||
@@ -686,6 +1448,17 @@ static FARPROC WINAPI hook_get_proc_address(HMODULE module, LPCSTR name)
|
||||
BOOL(WINAPI *stretch_blt)(HDC, int, int, int, int, HDC, int, int,
|
||||
int, int, DWORD);
|
||||
HRESULT(WINAPI *create_dxgi_factory1)(REFIID, void **);
|
||||
int(WINAPI *get_system_metrics)(int);
|
||||
int(WINAPI *get_device_caps)(HDC, int);
|
||||
BOOL(WINAPI *get_monitor_info)(HMONITOR, LPMONITORINFO);
|
||||
BOOL(WINAPI *enum_display_settings_a)(LPCSTR, DWORD, LPDEVMODEA);
|
||||
BOOL(WINAPI *enum_display_settings_w)(LPCWSTR, DWORD, LPDEVMODEW);
|
||||
BOOL(WINAPI *enum_display_settings_ex_w)(LPCWSTR, DWORD, LPDEVMODEW,
|
||||
DWORD);
|
||||
LONG(WINAPI *query_display_config)(UINT, UINT *,
|
||||
DISPLAYCONFIG_PATH_INFO *, UINT *,
|
||||
DISPLAYCONFIG_MODE_INFO *,
|
||||
DISPLAYCONFIG_TOPOLOGY_ID *);
|
||||
} replacement;
|
||||
FARPROC resolved = original_get_proc_address(module, name);
|
||||
if (name == NULL || ((uintptr_t)name >> 16) == 0)
|
||||
@@ -706,6 +1479,39 @@ static FARPROC WINAPI hook_get_proc_address(HMODULE module, LPCSTR name)
|
||||
replacement.create_dxgi_factory1 = hook_create_dxgi_factory1;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "GetSystemMetrics") == 0) {
|
||||
replacement.get_system_metrics = hook_get_system_metrics;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "GetDeviceCaps") == 0) {
|
||||
replacement.get_device_caps = hook_get_device_caps;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "GetMonitorInfoA") == 0) {
|
||||
replacement.get_monitor_info = hook_get_monitor_info_a;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "GetMonitorInfoW") == 0) {
|
||||
replacement.get_monitor_info = hook_get_monitor_info_w;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "EnumDisplaySettingsA") == 0) {
|
||||
replacement.enum_display_settings_a = hook_enum_display_settings_a;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "EnumDisplaySettingsW") == 0) {
|
||||
replacement.enum_display_settings_w = hook_enum_display_settings_w;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "EnumDisplaySettingsExW") == 0) {
|
||||
replacement.enum_display_settings_ex_w =
|
||||
hook_enum_display_settings_ex_w;
|
||||
return replacement.generic;
|
||||
}
|
||||
if (lstrcmpiA(name, "QueryDisplayConfig") == 0) {
|
||||
replacement.query_display_config = hook_query_display_config;
|
||||
return replacement.generic;
|
||||
}
|
||||
return resolved;
|
||||
}
|
||||
|
||||
@@ -916,7 +1722,7 @@ UINT WINAPI hook_send_input(UINT count, LPINPUT inputs, int size)
|
||||
|
||||
static int patch_module_iat(HMODULE base)
|
||||
{
|
||||
if (base == NULL)
|
||||
if (base == NULL || base == hook_module)
|
||||
return 0;
|
||||
|
||||
IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER *)base;
|
||||
@@ -973,6 +1779,30 @@ static int patch_module_iat(HMODULE base)
|
||||
} else if (lstrcmpiA(name->Name, "GetProcAddress") == 0) {
|
||||
hook_fn = (void *)hook_get_proc_address;
|
||||
original_slot = (void **)&original_get_proc_address;
|
||||
} else if (lstrcmpiA(name->Name, "GetSystemMetrics") == 0) {
|
||||
hook_fn = (void *)hook_get_system_metrics;
|
||||
original_slot = (void **)&original_get_system_metrics;
|
||||
} else if (lstrcmpiA(name->Name, "GetDeviceCaps") == 0) {
|
||||
hook_fn = (void *)hook_get_device_caps;
|
||||
original_slot = (void **)&original_get_device_caps;
|
||||
} else if (lstrcmpiA(name->Name, "GetMonitorInfoA") == 0) {
|
||||
hook_fn = (void *)hook_get_monitor_info_a;
|
||||
original_slot = (void **)&original_get_monitor_info_a;
|
||||
} else if (lstrcmpiA(name->Name, "GetMonitorInfoW") == 0) {
|
||||
hook_fn = (void *)hook_get_monitor_info_w;
|
||||
original_slot = (void **)&original_get_monitor_info_w;
|
||||
} else if (lstrcmpiA(name->Name, "EnumDisplaySettingsA") == 0) {
|
||||
hook_fn = (void *)hook_enum_display_settings_a;
|
||||
original_slot = (void **)&original_enum_display_settings_a;
|
||||
} else if (lstrcmpiA(name->Name, "EnumDisplaySettingsW") == 0) {
|
||||
hook_fn = (void *)hook_enum_display_settings_w;
|
||||
original_slot = (void **)&original_enum_display_settings_w;
|
||||
} else if (lstrcmpiA(name->Name, "EnumDisplaySettingsExW") == 0) {
|
||||
hook_fn = (void *)hook_enum_display_settings_ex_w;
|
||||
original_slot = (void **)&original_enum_display_settings_ex_w;
|
||||
} else if (lstrcmpiA(name->Name, "QueryDisplayConfig") == 0) {
|
||||
hook_fn = (void *)hook_query_display_config;
|
||||
original_slot = (void **)&original_query_display_config;
|
||||
}
|
||||
if (hook_fn == NULL)
|
||||
continue;
|
||||
@@ -1064,11 +1894,21 @@ void uur_hook_version(void) {}
|
||||
|
||||
BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
|
||||
{
|
||||
(void)instance;
|
||||
(void)reserved;
|
||||
if (reason != DLL_PROCESS_ATTACH)
|
||||
return TRUE;
|
||||
|
||||
hook_module = instance;
|
||||
WCHAR executable[MAX_PATH];
|
||||
if (GetModuleFileNameW(NULL, executable, MAX_PATH) > 0) {
|
||||
const WCHAR *name = wcsrchr(executable, L'\\');
|
||||
name = name != NULL ? name + 1 : executable;
|
||||
capture_geometry_enabled = lstrcmpiW(name, L"GameViewerServer.exe") == 0 ||
|
||||
lstrcmpiW(name, L"GameViewerService.exe") == 0;
|
||||
}
|
||||
WCHAR geometry_option[2];
|
||||
if (GetEnvironmentVariableW(L"UUR_CAPTURE_GEOMETRY", geometry_option, 2) == 1)
|
||||
capture_geometry_enabled = geometry_option[0] == L'1';
|
||||
DisableThreadLibraryCalls(instance);
|
||||
if (connect_bridge()) {
|
||||
hook_log("attach: bridge connected");
|
||||
|
||||
@@ -15,6 +15,13 @@ command -v makepkg >/dev/null 2>&1 || {
|
||||
exit 2
|
||||
}
|
||||
|
||||
cargo build --manifest-path "$project_root/Cargo.toml" --release --locked
|
||||
"$project_root/hook/build.sh"
|
||||
"$project_root/capture/build.sh"
|
||||
if [[ -f "$project_root/compat/build.sh" ]]; then
|
||||
"$project_root/compat/build.sh"
|
||||
fi
|
||||
|
||||
sed -e "s|@UUR_VERSION@|$version|g" \
|
||||
-e "s|@UUR_PROJECT_ROOT@|$project_root|g" \
|
||||
"$project_root/packaging/arch/PKGBUILD.in" >"$build_dir/PKGBUILD"
|
||||
|
||||
+27
-5
@@ -156,25 +156,48 @@ pub fn serve() -> Result<()> {
|
||||
let backend_handle = backend.clone();
|
||||
let addr = format!("127.0.0.1:{}", config.bridge_port);
|
||||
let listener = TcpListener::bind(&addr).with_context(|| format!("binding {addr}"))?;
|
||||
listener.set_nonblocking(true)?;
|
||||
println!("{}", t!("bridge.listening", port = config.bridge_port));
|
||||
|
||||
// The service process hooks itself too, so multiple authenticated
|
||||
// connections coexist; each gets its own thread. Injection is
|
||||
// serialized through the single backend.
|
||||
for stream in listener.incoming() {
|
||||
let stream = match stream {
|
||||
Ok(s) => s,
|
||||
Err(_) => continue,
|
||||
loop {
|
||||
backend.lock().unwrap().backend.check_health()?;
|
||||
let stream = match listener.accept() {
|
||||
Ok((stream, _)) => stream,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
|
||||
thread::sleep(std::time::Duration::from_millis(50));
|
||||
continue;
|
||||
}
|
||||
Err(error)
|
||||
if matches!(
|
||||
error.kind(),
|
||||
std::io::ErrorKind::Interrupted | std::io::ErrorKind::ConnectionAborted
|
||||
) =>
|
||||
{
|
||||
continue
|
||||
}
|
||||
Err(error) => return Err(error).context("accepting hook connection"),
|
||||
};
|
||||
let config = config.clone();
|
||||
let backend_handle = backend_handle.clone();
|
||||
thread::spawn(move || {
|
||||
let mut stream = stream;
|
||||
if stream
|
||||
.set_read_timeout(Some(std::time::Duration::from_secs(5)))
|
||||
.is_err()
|
||||
{
|
||||
return;
|
||||
}
|
||||
match authenticate(&mut stream, &config) {
|
||||
Ok(true) => {}
|
||||
Ok(false) => return,
|
||||
Err(_) => return,
|
||||
}
|
||||
if stream.set_read_timeout(None).is_err() {
|
||||
return;
|
||||
}
|
||||
use input::InputBackend;
|
||||
// Read sockets without holding the shared desktop input lock.
|
||||
let mut connection = ConnectionInput {
|
||||
@@ -199,7 +222,6 @@ pub fn serve() -> Result<()> {
|
||||
let _ = connection.release_all();
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn authenticate(stream: &mut TcpStream, config: &Config) -> Result<bool> {
|
||||
|
||||
+137
-28
@@ -1,9 +1,9 @@
|
||||
//! Portal side of the capture path.
|
||||
//!
|
||||
//! Negotiates an xdg-desktop-portal ScreenCast session, obtains a private
|
||||
//! PipeWire file descriptor and the video node id, then hands both to the
|
||||
//! C capture helper (`uur-pw-capture`) which runs the PipeWire stream and
|
||||
//! publishes frames into a private XDG runtime file (see
|
||||
//! PipeWire file descriptor and the consented video nodes, then hands them to
|
||||
//! the C capture helper (`uur-pw-capture`) which runs the PipeWire streams and
|
||||
//! composites their frames into a private XDG runtime file (see
|
||||
//! docs/capture-protocol.md).
|
||||
//!
|
||||
//! Consent: the first run shows the compositor's share dialog once. The
|
||||
@@ -25,17 +25,28 @@ use std::time::{Duration, Instant};
|
||||
|
||||
use crate::config::Config;
|
||||
|
||||
const FRAME_PROTOCOL_VERSION: u32 = 3;
|
||||
|
||||
type PortalSession =
|
||||
ashpd::desktop::Session<'static, ashpd::desktop::screencast::Screencast<'static>>;
|
||||
|
||||
struct PortalCapture {
|
||||
fd: OwnedFd,
|
||||
node: u32,
|
||||
streams: Vec<CaptureStream>,
|
||||
restore_token: Option<String>,
|
||||
session: PortalSession,
|
||||
closed: zbus::proxy::SignalStream<'static>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct CaptureStream {
|
||||
pub(crate) node: u32,
|
||||
pub(crate) x: i32,
|
||||
pub(crate) y: i32,
|
||||
pub(crate) width: u32,
|
||||
pub(crate) height: u32,
|
||||
}
|
||||
|
||||
/// Run the capture path until interrupted.
|
||||
pub fn run_standalone() -> Result<()> {
|
||||
// Public capture uses the same lifecycle lock as run/setup so stop and
|
||||
@@ -93,13 +104,13 @@ pub fn run() -> Result<()> {
|
||||
};
|
||||
let PortalCapture {
|
||||
fd: pw_fd,
|
||||
node,
|
||||
streams,
|
||||
session,
|
||||
mut closed,
|
||||
..
|
||||
} = match opened {
|
||||
Ok(opened) => opened,
|
||||
Err(error) if !initial_session && failures < 3 => {
|
||||
Err(error) if !initial_session && failures < 3 && !user_cancelled(&error) => {
|
||||
failures += 1;
|
||||
eprintln!("capture reconnect {failures}/3 failed: {error:#}");
|
||||
tokio::select! {
|
||||
@@ -110,13 +121,18 @@ pub fn run() -> Result<()> {
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
initial_session = false;
|
||||
println!("{}", t!("capture.session_ready", node = node));
|
||||
let nodes = streams
|
||||
.iter()
|
||||
.map(|stream| stream.node.to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join(",");
|
||||
println!("{}", t!("capture.session_ready", node = nodes));
|
||||
match std::fs::remove_file(&frames) {
|
||||
Ok(()) => {}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(error) => return Err(error).context("retiring the previous capture transport"),
|
||||
}
|
||||
let mut helper = CaptureHelper(spawn_helper(pw_fd, node)?);
|
||||
let mut helper = CaptureHelper(spawn_capture_helper(pw_fd, &streams)?);
|
||||
let mut healthy_since = None;
|
||||
let mut portal_closed = false;
|
||||
let mut reconfigure = false;
|
||||
@@ -143,6 +159,10 @@ pub fn run() -> Result<()> {
|
||||
if has_frame(&frames) && healthy_since.is_none() {
|
||||
healthy_since = Some(Instant::now());
|
||||
}
|
||||
if helper_stalled(&frames) {
|
||||
eprintln!("capture helper heartbeat expired; reconnecting");
|
||||
break None;
|
||||
}
|
||||
if let Some(status) = helper.0.try_wait()
|
||||
.context("waiting for capture helper")? {
|
||||
break Some(status);
|
||||
@@ -175,14 +195,16 @@ pub fn run() -> Result<()> {
|
||||
"capture recovery failed repeatedly; restart uur run to share again"
|
||||
);
|
||||
}
|
||||
let status = status.context("capture helper stopped without an exit status")?;
|
||||
if !matches!(status.code(), Some(0 | 75) | None) {
|
||||
if status
|
||||
.as_ref()
|
||||
.is_some_and(|status| !matches!(status.code(), Some(0 | 75) | None))
|
||||
{
|
||||
anyhow::bail!(
|
||||
"{} ({status}); capture recovery stopped",
|
||||
"{} ({status:?}); capture recovery stopped",
|
||||
t!("capture.helper_failed")
|
||||
);
|
||||
}
|
||||
eprintln!("capture stream interrupted ({status}); reconnecting {failures}/3");
|
||||
eprintln!("capture stream interrupted ({status:?}); reconnecting {failures}/3");
|
||||
}
|
||||
tokio::select! {
|
||||
_ = tokio::time::sleep(Duration::from_secs(1)) => {},
|
||||
@@ -206,7 +228,7 @@ pub fn run() -> Result<()> {
|
||||
})
|
||||
}
|
||||
|
||||
async fn watch_display_changes() -> Option<zbus::proxy::SignalStream<'static>> {
|
||||
pub(crate) async fn watch_display_changes() -> Option<zbus::proxy::SignalStream<'static>> {
|
||||
let connection = zbus::Connection::session().await.ok()?;
|
||||
let bus = zbus::fdo::DBusProxy::new(&connection).await.ok()?;
|
||||
let name = "org.gnome.Mutter.DisplayConfig".try_into().ok()?;
|
||||
@@ -225,7 +247,7 @@ async fn watch_display_changes() -> Option<zbus::proxy::SignalStream<'static>> {
|
||||
proxy.receive_signal("MonitorsChanged").await.ok()
|
||||
}
|
||||
|
||||
async fn next_display_change(changes: &mut Option<zbus::proxy::SignalStream<'static>>) {
|
||||
pub(crate) async fn next_display_change(changes: &mut Option<zbus::proxy::SignalStream<'static>>) {
|
||||
loop {
|
||||
match changes.as_mut() {
|
||||
Some(stream) => {
|
||||
@@ -245,7 +267,7 @@ async fn wait_for_stop(stopping: &AtomicBool) {
|
||||
}
|
||||
}
|
||||
|
||||
struct CaptureHelper(Child);
|
||||
pub(crate) struct CaptureHelper(pub(crate) Child);
|
||||
|
||||
impl Drop for CaptureHelper {
|
||||
fn drop(&mut self) {
|
||||
@@ -276,17 +298,48 @@ pub(crate) fn has_frame(path: &Path) -> bool {
|
||||
}
|
||||
let field = |offset| u32::from_le_bytes(header[offset..offset + 4].try_into().unwrap());
|
||||
field(0) == 0x4652_5555
|
||||
&& field(4) == 1
|
||||
&& field(4) == FRAME_PROTOCOL_VERSION
|
||||
&& field(8) > 0
|
||||
&& field(12) > 0
|
||||
&& field(16) >= field(8).saturating_mul(4)
|
||||
&& field(20) == 1
|
||||
&& (1..=16).contains(&field(36))
|
||||
&& u64::from_le_bytes(header[24..32].try_into().unwrap()) > 0
|
||||
}
|
||||
|
||||
/// The producer heartbeat advances even when the desktop is static. A zero
|
||||
/// value belongs to a producer without heartbeat support, never a stale frame.
|
||||
pub(crate) fn helper_stalled(path: &Path) -> bool {
|
||||
let mut header = [0u8; 48];
|
||||
let Ok(mut file) = std::fs::File::open(path) else {
|
||||
return false;
|
||||
};
|
||||
if file.read_exact(&mut header).is_err()
|
||||
|| u32::from_le_bytes(header[4..8].try_into().unwrap()) != FRAME_PROTOCOL_VERSION
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let heartbeat = u64::from_le_bytes(header[40..48].try_into().unwrap());
|
||||
let mut now: libc::timespec = unsafe { std::mem::zeroed() };
|
||||
if heartbeat == 0 || unsafe { libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut now) } != 0 {
|
||||
return false;
|
||||
}
|
||||
let milliseconds = (now.tv_sec as u64).saturating_mul(1000) + now.tv_nsec as u64 / 1_000_000;
|
||||
milliseconds.saturating_sub(heartbeat) > 10_000
|
||||
}
|
||||
|
||||
/// Start the native PipeWire consumer with a portal-owned descriptor. The
|
||||
/// descriptor remains private to the child and is never reopened by path.
|
||||
pub(crate) fn spawn_helper(pw_fd: OwnedFd, node: u32) -> Result<Child> {
|
||||
pub(crate) fn spawn_helper(pw_fd: OwnedFd, streams: &[CaptureStream]) -> Result<Child> {
|
||||
spawn_capture_helper(pw_fd, streams)
|
||||
}
|
||||
|
||||
fn spawn_capture_helper(pw_fd: OwnedFd, streams: &[CaptureStream]) -> Result<Child> {
|
||||
anyhow::ensure!(!streams.is_empty(), "ScreenCast returned no streams");
|
||||
anyhow::ensure!(
|
||||
streams.len() <= 16,
|
||||
"too many ScreenCast streams (maximum 16)"
|
||||
);
|
||||
// The helper inherits this descriptor: strip close-on-exec and keep the
|
||||
// OwnedFd alive across the spawn (closing it would invalidate the number
|
||||
// the child receives).
|
||||
@@ -303,9 +356,19 @@ pub(crate) fn spawn_helper(pw_fd: OwnedFd, node: u32) -> Result<Child> {
|
||||
|
||||
let helper = find_helper("uur-pw-capture")?;
|
||||
let mut command = Command::new(&helper);
|
||||
let stream_specs = streams
|
||||
.iter()
|
||||
.map(|stream| {
|
||||
format!(
|
||||
"{},{},{},{},{}",
|
||||
stream.node, stream.x, stream.y, stream.width, stream.height
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join(";");
|
||||
command
|
||||
.env("UUR_PW_FD", raw.to_string())
|
||||
.env("UUR_PW_NODE", node.to_string())
|
||||
.env("UUR_PW_STREAMS", stream_specs)
|
||||
.env("UUR_FRAME_PATH", frame_path()?);
|
||||
if let Ok(debug) = std::env::var("UUR_PW_DEBUG") {
|
||||
command.env("PIPEWIRE_DEBUG", debug);
|
||||
@@ -316,14 +379,14 @@ pub(crate) fn spawn_helper(pw_fd: OwnedFd, node: u32) -> Result<Child> {
|
||||
Ok(child)
|
||||
}
|
||||
|
||||
fn frame_path() -> Result<PathBuf> {
|
||||
pub(crate) fn frame_path() -> Result<PathBuf> {
|
||||
if let Some(path) = std::env::var_os("UUR_FRAME_PATH") {
|
||||
return Ok(PathBuf::from(path));
|
||||
}
|
||||
Ok(crate::config::runtime_dir()?.join("frames.v1"))
|
||||
Ok(crate::config::runtime_dir()?.join("frames.v3"))
|
||||
}
|
||||
|
||||
/// Open the portal session and return (inherited fd number, node id).
|
||||
/// Open the portal session and return its PipeWire streams and node ids.
|
||||
/// First attempt reuses the stored restore token; if that fails (stale
|
||||
/// token, monitor changed, compositor restart) fall back to one
|
||||
/// interactive attempt and store the fresh token.
|
||||
@@ -341,15 +404,33 @@ async fn portal_session(config: &mut Config, interactive: bool) -> Result<Portal
|
||||
.into_iter()
|
||||
.chain(interactive.then_some(None))
|
||||
{
|
||||
match negotiate(&screencast, source, token.as_deref()).await {
|
||||
match negotiate(
|
||||
&screencast,
|
||||
source,
|
||||
config.capture_multiple,
|
||||
token.as_deref(),
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(capture) => {
|
||||
if capture.restore_token != saved_token {
|
||||
config.capture_restore_token = capture.restore_token.clone();
|
||||
config.store().context("storing the new restore token")?;
|
||||
Config::update(|stored| {
|
||||
if stored.capture_source == config.capture_source
|
||||
&& stored.capture_multiple == config.capture_multiple
|
||||
&& stored.capture_backend == config.capture_backend
|
||||
{
|
||||
stored.capture_restore_token = capture.restore_token.clone();
|
||||
}
|
||||
})
|
||||
.context("storing the new restore token")?;
|
||||
}
|
||||
return Ok(capture);
|
||||
}
|
||||
Err(error) => {
|
||||
if user_cancelled(&error) {
|
||||
return Err(error);
|
||||
}
|
||||
last_error = Some(error);
|
||||
}
|
||||
}
|
||||
@@ -359,6 +440,20 @@ async fn portal_session(config: &mut Config, interactive: bool) -> Result<Portal
|
||||
}))
|
||||
}
|
||||
|
||||
pub(crate) fn user_cancelled(error: &anyhow::Error) -> bool {
|
||||
error.chain().any(|source| {
|
||||
matches!(
|
||||
source.downcast_ref::<ashpd::Error>(),
|
||||
Some(ashpd::Error::Response(
|
||||
ashpd::desktop::ResponseError::Cancelled
|
||||
))
|
||||
) || matches!(
|
||||
source.downcast_ref::<ashpd::desktop::ResponseError>(),
|
||||
Some(ashpd::desktop::ResponseError::Cancelled)
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Choose a cursor mode from the flags the portal advertises.
|
||||
///
|
||||
/// `Embedded` is what the capture path wants (the hook composites the cursor
|
||||
@@ -412,6 +507,7 @@ pub(crate) async fn preferred_cursor_mode(
|
||||
async fn negotiate(
|
||||
screencast: &ashpd::desktop::screencast::Screencast<'static>,
|
||||
source: ashpd::desktop::screencast::SourceType,
|
||||
multiple: bool,
|
||||
restore_token: Option<&str>,
|
||||
) -> Result<PortalCapture> {
|
||||
use ashpd::desktop::PersistMode;
|
||||
@@ -440,7 +536,7 @@ async fn negotiate(
|
||||
&session,
|
||||
cursor_mode,
|
||||
source.into(),
|
||||
false,
|
||||
multiple && matches!(source, ashpd::desktop::screencast::SourceType::Monitor),
|
||||
restore_token,
|
||||
PersistMode::ExplicitlyRevoked,
|
||||
)
|
||||
@@ -449,9 +545,22 @@ async fn negotiate(
|
||||
|
||||
let response = screencast.start(&session, None).await?;
|
||||
let streams_response = response.response()?;
|
||||
let streams = streams_response.streams();
|
||||
let stream = streams.first().context("no monitor selected")?;
|
||||
let node = stream.pipe_wire_node_id();
|
||||
let streams = streams_response
|
||||
.streams()
|
||||
.iter()
|
||||
.map(|stream| {
|
||||
let (x, y) = stream.position().unwrap_or((i32::MIN, i32::MIN));
|
||||
let (width, height) = stream.size().unwrap_or((0, 0));
|
||||
CaptureStream {
|
||||
node: stream.pipe_wire_node_id(),
|
||||
x,
|
||||
y,
|
||||
width: u32::try_from(width).unwrap_or(0),
|
||||
height: u32::try_from(height).unwrap_or(0),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
anyhow::ensure!(!streams.is_empty(), "no monitor selected");
|
||||
let fresh_token = streams_response.restore_token().map(String::from);
|
||||
|
||||
let fd = screencast
|
||||
@@ -460,7 +569,7 @@ async fn negotiate(
|
||||
.context("opening the PipeWire remote")?;
|
||||
Ok(PortalCapture {
|
||||
fd,
|
||||
node,
|
||||
streams,
|
||||
restore_token: fresh_token,
|
||||
session,
|
||||
closed,
|
||||
|
||||
+101
-13
@@ -1,6 +1,10 @@
|
||||
use anyhow::{Context, Result};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::io::Write;
|
||||
use std::os::fd::AsRawFd;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
/// Persistent user configuration. Everything lives under the XDG state and
|
||||
/// config directories; the managed Wine prefix lives under data.
|
||||
@@ -24,6 +28,8 @@ pub struct Config {
|
||||
pub remote_desktop_restore_token: Option<String>,
|
||||
/// Portal source type: monitor, window, or virtual.
|
||||
pub capture_source: String,
|
||||
/// Multiple consented monitors are opt-in; existing grants stay intact.
|
||||
pub capture_multiple: bool,
|
||||
/// "portal" uses system consent; "wayland" is explicitly enabled direct monitor capture.
|
||||
pub capture_backend: String,
|
||||
/// Named Wayland output for direct capture; a single-output session needs no name.
|
||||
@@ -49,6 +55,7 @@ impl Default for Config {
|
||||
capture_restore_token: None,
|
||||
remote_desktop_restore_token: None,
|
||||
capture_source: "monitor".into(),
|
||||
capture_multiple: false,
|
||||
capture_backend: "portal".into(),
|
||||
capture_output: None,
|
||||
strip_lock_mods: Some("auto".into()),
|
||||
@@ -125,24 +132,104 @@ pub fn runtime_dir() -> Result<PathBuf> {
|
||||
impl Config {
|
||||
pub fn load() -> Result<Self> {
|
||||
let path = config_path()?;
|
||||
if !path.exists() {
|
||||
let config = Self::default();
|
||||
config.store()?;
|
||||
return Ok(config);
|
||||
match std::fs::read_to_string(&path) {
|
||||
Ok(raw) => toml::from_str(&raw).context("parsing config.toml"),
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Self::update(|_| {}),
|
||||
Err(error) => Err(error).with_context(|| format!("reading {}", path.display())),
|
||||
}
|
||||
let raw = std::fs::read_to_string(&path)
|
||||
.with_context(|| format!("reading {}", path.display()))?;
|
||||
toml::from_str(&raw).context("parsing config.toml")
|
||||
}
|
||||
|
||||
pub fn store(&self) -> Result<()> {
|
||||
let path = config_path()?;
|
||||
if let Some(parent) = path.parent() {
|
||||
std::fs::create_dir_all(parent)
|
||||
.with_context(|| format!("creating {}", parent.display()))?;
|
||||
let (path, _lock) = Self::write_lock()?;
|
||||
self.store_locked(&path)
|
||||
}
|
||||
std::fs::write(&path, toml::to_string_pretty(self)?)
|
||||
.with_context(|| format!("writing {}", path.display()))
|
||||
|
||||
/// Serialize read/modify/write across the capture, input and frontend
|
||||
/// processes. Background token saves must not overwrite other fields.
|
||||
pub fn update(change: impl FnOnce(&mut Self)) -> Result<Self> {
|
||||
let (path, _lock) = Self::write_lock()?;
|
||||
let mut config = match std::fs::read_to_string(&path) {
|
||||
Ok(raw) => toml::from_str(&raw).context("parsing config.toml")?,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Self::default(),
|
||||
Err(error) => return Err(error).context("reading configuration for update"),
|
||||
};
|
||||
change(&mut config);
|
||||
config.store_locked(&path)?;
|
||||
Ok(config)
|
||||
}
|
||||
|
||||
fn write_lock() -> Result<(PathBuf, std::fs::File)> {
|
||||
let mut path = config_path()?;
|
||||
// Do not replace a user-created symlink to declarative configuration.
|
||||
if std::fs::symlink_metadata(&path).is_ok_and(|meta| meta.file_type().is_symlink()) {
|
||||
path = std::fs::canonicalize(&path).context("resolving configuration symlink")?;
|
||||
}
|
||||
let parent = path.parent().context("configuration has no parent")?;
|
||||
std::fs::create_dir_all(parent)?;
|
||||
let lock = std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.truncate(false)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(path.with_extension("toml.lock"))?;
|
||||
loop {
|
||||
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX) } == 0 {
|
||||
break;
|
||||
}
|
||||
let error = std::io::Error::last_os_error();
|
||||
if error.kind() != std::io::ErrorKind::Interrupted {
|
||||
return Err(error).context("locking configuration");
|
||||
}
|
||||
}
|
||||
Ok((path, lock))
|
||||
}
|
||||
|
||||
fn store_locked(&self, path: &std::path::Path) -> Result<()> {
|
||||
static NEXT: AtomicU64 = AtomicU64::new(0);
|
||||
let parent = path.parent().context("configuration has no parent")?;
|
||||
let mut document = match std::fs::read_to_string(path) {
|
||||
Ok(raw) => {
|
||||
toml::from_str::<toml::Table>(&raw).context("parsing existing configuration")?
|
||||
}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => toml::Table::new(),
|
||||
Err(error) => return Err(error).context("reading existing configuration"),
|
||||
};
|
||||
// Keep keys belonging to newer versions. JSON includes None fields,
|
||||
// allowing explicitly cleared optional fields to remove old values.
|
||||
for name in serde_json::to_value(self)?.as_object().unwrap().keys() {
|
||||
document.remove(name);
|
||||
}
|
||||
document.extend(toml::Value::try_from(self)?.as_table().unwrap().clone());
|
||||
let text = toml::to_string_pretty(&document)?;
|
||||
for _ in 0..32 {
|
||||
let temporary = parent.join(format!(
|
||||
".uur-config-{}-{}.tmp",
|
||||
std::process::id(),
|
||||
NEXT.fetch_add(1, Ordering::Relaxed)
|
||||
));
|
||||
let mut file = match std::fs::OpenOptions::new()
|
||||
.create_new(true)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(&temporary)
|
||||
{
|
||||
Ok(file) => file,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
|
||||
Err(error) => return Err(error).context("creating configuration temporary file"),
|
||||
};
|
||||
let result = (|| -> Result<()> {
|
||||
file.write_all(text.as_bytes())?;
|
||||
file.sync_all()?;
|
||||
std::fs::rename(&temporary, path)?;
|
||||
std::fs::File::open(parent)?.sync_all()?;
|
||||
Ok(())
|
||||
})();
|
||||
if result.is_err() {
|
||||
let _ = std::fs::remove_file(&temporary);
|
||||
}
|
||||
return result.with_context(|| format!("writing {}", path.display()));
|
||||
}
|
||||
anyhow::bail!("could not create a configuration temporary file")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -173,5 +260,6 @@ input_backend = "auto"
|
||||
assert!(config.remote_desktop_restore_token.is_none());
|
||||
assert!(config.capture_restore_token.is_none());
|
||||
assert_eq!(config.capture_source, "monitor");
|
||||
assert!(!config.capture_multiple);
|
||||
}
|
||||
}
|
||||
+3
-2
@@ -374,12 +374,13 @@ pub fn report() -> Result<()> {
|
||||
"info",
|
||||
"capture backend",
|
||||
&format!(
|
||||
"{} ({})",
|
||||
"{} ({}; multiple={})",
|
||||
configured.capture_backend,
|
||||
configured
|
||||
.capture_output
|
||||
.as_deref()
|
||||
.unwrap_or("selected/default output")
|
||||
.unwrap_or("selected/default output"),
|
||||
configured.capture_multiple
|
||||
),
|
||||
);
|
||||
let mut preferred = std::env::var("UUR_INPUT_BACKEND").unwrap_or(configured.input_backend);
|
||||
|
||||
@@ -7,6 +7,9 @@ use anyhow::Result;
|
||||
/// A desktop input sink. Records arrive already normalized by `protocol`.
|
||||
pub trait InputBackend: Send {
|
||||
fn name(&self) -> &'static str;
|
||||
fn check_health(&self) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn key(&mut self, vkey: u16, down: bool) -> Result<()>;
|
||||
fn button(&mut self, button: u16, down: bool) -> Result<()>;
|
||||
|
||||
+383
-40
@@ -2,11 +2,13 @@ use anyhow::{anyhow, Context, Result};
|
||||
use ashpd::desktop::remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop};
|
||||
use ashpd::desktop::screencast::Screencast;
|
||||
use ashpd::desktop::PersistMode;
|
||||
use futures::StreamExt;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::{self, SyncSender};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
use std::time::Instant;
|
||||
use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
|
||||
|
||||
use super::InputBackend;
|
||||
@@ -28,14 +30,102 @@ struct Motion {
|
||||
y: f64,
|
||||
}
|
||||
|
||||
struct CaptureGuard(std::process::Child);
|
||||
/// Select a consented stream in the same logical layout used by the compositor.
|
||||
/// A point in a monitor gap is clamped to the closest selected monitor.
|
||||
fn absolute_target(
|
||||
streams: &[crate::capture::CaptureStream],
|
||||
x: f64,
|
||||
y: f64,
|
||||
) -> Result<(u32, f64, f64)> {
|
||||
anyhow::ensure!(
|
||||
x.is_finite() && y.is_finite(),
|
||||
"invalid absolute pointer position"
|
||||
);
|
||||
anyhow::ensure!(
|
||||
!streams.is_empty() && streams.len() <= 16,
|
||||
"invalid input stream count"
|
||||
);
|
||||
let mut streams = streams.to_vec();
|
||||
if streams
|
||||
.iter()
|
||||
.any(|stream| stream.width == 0 || stream.height == 0)
|
||||
{
|
||||
use std::io::Read;
|
||||
let mut header = [0u8; 704];
|
||||
std::fs::File::open(crate::capture::frame_path()?)?.read_exact(&mut header)?;
|
||||
let field = |offset| u32::from_le_bytes(header[offset..offset + 4].try_into().unwrap());
|
||||
anyhow::ensure!(
|
||||
field(0) == 0x4652_5555
|
||||
&& field(4) == 3
|
||||
&& field(36) as usize == streams.len()
|
||||
&& u64::from_le_bytes(header[24..32].try_into().unwrap()) > 0,
|
||||
"capture layout is not ready for pointer routing"
|
||||
);
|
||||
for (index, stream) in streams.iter_mut().enumerate() {
|
||||
let offset = 64 + index * 40;
|
||||
stream.x = field(offset) as i32;
|
||||
stream.y = field(offset + 4) as i32;
|
||||
stream.width = field(offset + 8);
|
||||
stream.height = field(offset + 12);
|
||||
}
|
||||
}
|
||||
anyhow::ensure!(
|
||||
streams
|
||||
.iter()
|
||||
.all(|stream| stream.width > 0 && stream.height > 0),
|
||||
"missing pointer stream dimensions"
|
||||
);
|
||||
if streams
|
||||
.iter()
|
||||
.any(|stream| stream.x == i32::MIN || stream.y == i32::MIN)
|
||||
{
|
||||
let mut next_x = 0i64;
|
||||
for stream in &mut streams {
|
||||
stream.x = i32::try_from(next_x).context("input stream layout is too wide")?;
|
||||
stream.y = 0;
|
||||
next_x += i64::from(stream.width);
|
||||
}
|
||||
}
|
||||
let left = streams
|
||||
.iter()
|
||||
.map(|stream| i64::from(stream.x))
|
||||
.min()
|
||||
.unwrap();
|
||||
let top = streams
|
||||
.iter()
|
||||
.map(|stream| i64::from(stream.y))
|
||||
.min()
|
||||
.unwrap();
|
||||
let right = streams
|
||||
.iter()
|
||||
.map(|stream| i64::from(stream.x) + i64::from(stream.width))
|
||||
.max()
|
||||
.unwrap();
|
||||
let bottom = streams
|
||||
.iter()
|
||||
.map(|stream| i64::from(stream.y) + i64::from(stream.height))
|
||||
.max()
|
||||
.unwrap();
|
||||
let global_x = left as f64 + x.clamp(0.0, 65535.0) * (right - left - 1) as f64 / 65535.0;
|
||||
let global_y = top as f64 + y.clamp(0.0, 65535.0) * (bottom - top - 1) as f64 / 65535.0;
|
||||
let mut best = None;
|
||||
let mut distance = f64::INFINITY;
|
||||
for stream in &streams {
|
||||
let local_x = (global_x - f64::from(stream.x)).clamp(0.0, f64::from(stream.width - 1));
|
||||
let local_y = (global_y - f64::from(stream.y)).clamp(0.0, f64::from(stream.height - 1));
|
||||
let dx = global_x - f64::from(stream.x) - local_x;
|
||||
let dy = global_y - f64::from(stream.y) - local_y;
|
||||
let current = dx * dx + dy * dy;
|
||||
// The producer draws later streams last when rectangles overlap.
|
||||
if current <= distance {
|
||||
best = Some((stream.node, local_x, local_y));
|
||||
distance = current;
|
||||
}
|
||||
}
|
||||
best.context("no input stream matches the pointer position")
|
||||
}
|
||||
|
||||
impl Drop for CaptureGuard {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.0.kill();
|
||||
let _ = self.0.wait();
|
||||
}
|
||||
}
|
||||
use crate::capture::CaptureHelper as CaptureGuard;
|
||||
|
||||
/// Wayland input through the freedesktop RemoteDesktop portal. The actual
|
||||
/// backend can be GNOME, KDE, COSMIC, or any future implementation; uur never
|
||||
@@ -46,18 +136,21 @@ pub struct PortalBackend {
|
||||
motion_queued: Arc<AtomicBool>,
|
||||
held_keys: HashSet<i32>,
|
||||
held_buttons: HashSet<i32>,
|
||||
failure: Arc<Mutex<Option<String>>>,
|
||||
}
|
||||
|
||||
impl PortalBackend {
|
||||
pub fn connect() -> Result<Self> {
|
||||
let mut config = crate::config::Config::load()?;
|
||||
let restore_token = config.remote_desktop_restore_token.clone();
|
||||
let (sender, receiver) = unbounded_channel();
|
||||
let (ready_sender, ready_receiver) = mpsc::sync_channel(1);
|
||||
let pending_motion = Arc::new(Mutex::new(None));
|
||||
let motion_queued = Arc::new(AtomicBool::new(false));
|
||||
let worker_motion = pending_motion.clone();
|
||||
let worker_queued = motion_queued.clone();
|
||||
let failure = Arc::new(Mutex::new(None));
|
||||
let worker_failure = failure.clone();
|
||||
let worker_config = config.clone();
|
||||
|
||||
std::thread::Builder::new()
|
||||
.name("uur-portal-input".into())
|
||||
@@ -70,12 +163,15 @@ impl PortalBackend {
|
||||
runtime.block_on(portal_worker(
|
||||
receiver,
|
||||
ready_sender.clone(),
|
||||
restore_token,
|
||||
worker_config,
|
||||
worker_motion,
|
||||
worker_queued,
|
||||
worker_failure.clone(),
|
||||
))
|
||||
});
|
||||
if let Err(error) = result {
|
||||
*worker_failure.lock().unwrap() = Some(error.to_string());
|
||||
eprintln!("portal input worker stopped: {error:#}");
|
||||
let _ = ready_sender.send(Err(error.to_string()));
|
||||
}
|
||||
})
|
||||
@@ -87,7 +183,15 @@ impl PortalBackend {
|
||||
.map_err(|error| anyhow!(error))?;
|
||||
if fresh_token != config.remote_desktop_restore_token {
|
||||
config.remote_desktop_restore_token = fresh_token;
|
||||
config.store()?;
|
||||
crate::config::Config::update(|stored| {
|
||||
if stored.capture_source == config.capture_source
|
||||
&& stored.capture_multiple == config.capture_multiple
|
||||
&& stored.capture_backend == config.capture_backend
|
||||
{
|
||||
stored.remote_desktop_restore_token =
|
||||
config.remote_desktop_restore_token.clone();
|
||||
}
|
||||
})?;
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
@@ -96,6 +200,7 @@ impl PortalBackend {
|
||||
motion_queued,
|
||||
held_keys: HashSet::new(),
|
||||
held_buttons: HashSet::new(),
|
||||
failure,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -104,23 +209,125 @@ impl PortalBackend {
|
||||
self.sender
|
||||
.send(event(reply_sender))
|
||||
.map_err(|_| anyhow!("portal input session closed"))?;
|
||||
reply_receiver
|
||||
let result = reply_receiver
|
||||
.recv_timeout(Duration::from_secs(3))
|
||||
.context("portal input request timed out")?
|
||||
.map_err(|error| anyhow!(error))
|
||||
.context("portal input request timed out")
|
||||
.and_then(|result| result.map_err(|error| anyhow!(error)));
|
||||
if let Err(error) = &result {
|
||||
*self.failure.lock().unwrap() = Some(error.to_string());
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
async fn portal_worker(
|
||||
mut receiver: UnboundedReceiver<Event>,
|
||||
receiver: UnboundedReceiver<Event>,
|
||||
ready: SyncSender<std::result::Result<Option<String>, String>>,
|
||||
configured: crate::config::Config,
|
||||
pending_motion: Arc<Mutex<Option<Motion>>>,
|
||||
motion_queued: Arc<AtomicBool>,
|
||||
failure: Arc<Mutex<Option<String>>>,
|
||||
) -> Result<()> {
|
||||
let mut worker = PortalWorker {
|
||||
restore_token: configured.remote_desktop_restore_token.clone(),
|
||||
configured,
|
||||
receiver,
|
||||
ready,
|
||||
pending_motion,
|
||||
motion_queued,
|
||||
failure,
|
||||
initial: true,
|
||||
opened: false,
|
||||
held_keys: HashSet::new(),
|
||||
held_buttons: HashSet::new(),
|
||||
};
|
||||
let mut display_changes = crate::capture::watch_display_changes().await;
|
||||
let mut failures = 0u8;
|
||||
loop {
|
||||
worker.opened = false;
|
||||
match portal_session_worker(&mut worker, &mut display_changes).await {
|
||||
Ok(SessionExit::Shutdown) => return Ok(()),
|
||||
Ok(SessionExit::Reconnect { layout, healthy }) => {
|
||||
if healthy {
|
||||
failures = 0;
|
||||
}
|
||||
if !layout {
|
||||
failures += 1;
|
||||
}
|
||||
anyhow::ensure!(failures <= 3, "portal capture recovery exhausted");
|
||||
anyhow::ensure!(worker.restore_token.is_some(),
|
||||
"portal capture changed without a restorable grant; restart uur run to share again");
|
||||
eprintln!(
|
||||
"restoring the consented RemoteDesktop session after {}",
|
||||
if layout {
|
||||
"a display change"
|
||||
} else {
|
||||
"a capture failure"
|
||||
}
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(if layout { 250 } else { 1000 })).await;
|
||||
while tokio::time::timeout(
|
||||
Duration::from_millis(100),
|
||||
crate::capture::next_display_change(&mut display_changes),
|
||||
)
|
||||
.await
|
||||
.is_ok()
|
||||
{}
|
||||
}
|
||||
Err(error)
|
||||
if !worker.initial
|
||||
&& !worker.opened
|
||||
&& failures < 3
|
||||
&& worker.restore_token.is_some()
|
||||
&& !crate::capture::user_cancelled(&error) =>
|
||||
{
|
||||
failures += 1;
|
||||
eprintln!("portal restore {failures}/3 failed: {error:#}");
|
||||
tokio::time::sleep(Duration::from_secs(1)).await;
|
||||
}
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct PortalWorker {
|
||||
receiver: UnboundedReceiver<Event>,
|
||||
ready: SyncSender<std::result::Result<Option<String>, String>>,
|
||||
configured: crate::config::Config,
|
||||
restore_token: Option<String>,
|
||||
pending_motion: Arc<Mutex<Option<Motion>>>,
|
||||
motion_queued: Arc<AtomicBool>,
|
||||
) -> Result<()> {
|
||||
failure: Arc<Mutex<Option<String>>>,
|
||||
initial: bool,
|
||||
opened: bool,
|
||||
held_keys: HashSet<i32>,
|
||||
held_buttons: HashSet<i32>,
|
||||
}
|
||||
|
||||
enum SessionExit {
|
||||
Shutdown,
|
||||
Reconnect { layout: bool, healthy: bool },
|
||||
}
|
||||
|
||||
async fn portal_session_worker(
|
||||
worker: &mut PortalWorker,
|
||||
display_changes: &mut Option<zbus::proxy::SignalStream<'static>>,
|
||||
) -> Result<SessionExit> {
|
||||
let PortalWorker {
|
||||
receiver,
|
||||
ready,
|
||||
configured,
|
||||
restore_token,
|
||||
pending_motion,
|
||||
motion_queued,
|
||||
failure,
|
||||
initial,
|
||||
opened,
|
||||
held_keys,
|
||||
held_buttons,
|
||||
} = worker;
|
||||
let portal = RemoteDesktop::new().await?;
|
||||
let screencast = Screencast::new().await?;
|
||||
let configured = crate::config::Config::load()?;
|
||||
let source = crate::capture::source_type(&configured.capture_source);
|
||||
let available = portal.available_device_types().await?;
|
||||
if !available.contains(DeviceType::Keyboard) || !available.contains(DeviceType::Pointer) {
|
||||
@@ -128,6 +335,18 @@ async fn portal_worker(
|
||||
}
|
||||
|
||||
let session = portal.create_session().await?;
|
||||
let serialized = serde_json::to_value(&session)?;
|
||||
let session_proxy = zbus::Proxy::new_owned(
|
||||
portal.connection().clone(),
|
||||
"org.freedesktop.portal.Desktop",
|
||||
serialized
|
||||
.as_str()
|
||||
.context("invalid portal session path")?
|
||||
.to_owned(),
|
||||
"org.freedesktop.portal.Session",
|
||||
)
|
||||
.await?;
|
||||
let mut closed = session_proxy.receive_signal("Closed").await?;
|
||||
portal
|
||||
.select_devices(
|
||||
&session,
|
||||
@@ -142,27 +361,110 @@ async fn portal_worker(
|
||||
&session,
|
||||
crate::capture::preferred_cursor_mode(&screencast).await?,
|
||||
source.into(),
|
||||
false,
|
||||
configured.capture_multiple && configured.capture_source == "monitor",
|
||||
None,
|
||||
PersistMode::DoNot,
|
||||
)
|
||||
.await?
|
||||
.response()?;
|
||||
let selection = portal.start(&session, None).await?.response()?;
|
||||
let stream = selection
|
||||
*opened = true;
|
||||
anyhow::ensure!(
|
||||
selection.devices().contains(DeviceType::Keyboard)
|
||||
&& selection.devices().contains(DeviceType::Pointer),
|
||||
"RemoteDesktop grant did not include keyboard and pointer"
|
||||
);
|
||||
let selected_streams = selection
|
||||
.streams()
|
||||
.and_then(|streams| streams.first())
|
||||
.context("RemoteDesktop portal returned no screen stream")?;
|
||||
let stream_id = stream.pipe_wire_node_id();
|
||||
let (logical_width, logical_height) = stream.size().unwrap_or((65535, 65535));
|
||||
.context("RemoteDesktop portal returned no screen streams")?;
|
||||
anyhow::ensure!(
|
||||
!selected_streams.is_empty(),
|
||||
"RemoteDesktop portal returned no screen streams"
|
||||
);
|
||||
let streams = selected_streams
|
||||
.iter()
|
||||
.map(|stream| {
|
||||
let (x, y) = stream.position().unwrap_or((i32::MIN, i32::MIN));
|
||||
let (width, height) = stream.size().unwrap_or((0, 0));
|
||||
crate::capture::CaptureStream {
|
||||
node: stream.pipe_wire_node_id(),
|
||||
x,
|
||||
y,
|
||||
width: u32::try_from(width).unwrap_or(0),
|
||||
height: u32::try_from(height).unwrap_or(0),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let pipewire = screencast.open_pipe_wire_remote(&session).await?;
|
||||
let _capture = CaptureGuard(crate::capture::spawn_helper(pipewire, stream_id)?);
|
||||
let mut capture = CaptureGuard(crate::capture::spawn_helper(pipewire, &streams)?);
|
||||
let token = selection.restore_token().map(ToOwned::to_owned);
|
||||
*restore_token = token.clone();
|
||||
if *initial {
|
||||
ready
|
||||
.send(Ok(token))
|
||||
.map_err(|_| anyhow!("portal setup receiver closed"))?;
|
||||
|
||||
while let Some(event) = receiver.recv().await {
|
||||
*initial = false;
|
||||
} else {
|
||||
crate::config::Config::update(|stored| {
|
||||
if stored.capture_source == configured.capture_source
|
||||
&& stored.capture_multiple == configured.capture_multiple
|
||||
&& stored.capture_backend == configured.capture_backend
|
||||
{
|
||||
stored.remote_desktop_restore_token = token;
|
||||
}
|
||||
})?;
|
||||
for key in held_keys.iter().copied() {
|
||||
portal
|
||||
.notify_keyboard_keycode(&session, key, KeyState::Pressed)
|
||||
.await?;
|
||||
}
|
||||
for button in held_buttons.iter().copied() {
|
||||
portal
|
||||
.notify_pointer_button(&session, button, KeyState::Pressed)
|
||||
.await?;
|
||||
}
|
||||
}
|
||||
let mut healthy_since = None;
|
||||
let mut health_tick = tokio::time::interval(Duration::from_millis(50));
|
||||
let outcome: Result<SessionExit> = async {
|
||||
loop {
|
||||
if let Some(error) = failure.lock().unwrap().clone() {
|
||||
anyhow::bail!("portal input session failed: {error}");
|
||||
}
|
||||
let event = tokio::select! {
|
||||
biased;
|
||||
_ = closed.next() => {
|
||||
let layout = tokio::time::timeout(Duration::from_millis(250),
|
||||
crate::capture::next_display_change(display_changes)).await.is_ok();
|
||||
anyhow::ensure!(layout, "screen sharing was closed by the portal; restart uur run to share again");
|
||||
break Ok(SessionExit::Reconnect { layout: true,
|
||||
healthy: healthy_since.is_some_and(|since: Instant| since.elapsed() >= Duration::from_secs(30)) });
|
||||
},
|
||||
_ = crate::capture::next_display_change(display_changes) => {
|
||||
break Ok(SessionExit::Reconnect { layout: true,
|
||||
healthy: healthy_since.is_some_and(|since: Instant| since.elapsed() >= Duration::from_secs(30)) });
|
||||
},
|
||||
_ = health_tick.tick() => {
|
||||
if crate::capture::helper_stalled(&crate::capture::frame_path()?) {
|
||||
eprintln!("portal capture helper heartbeat expired; reconnecting");
|
||||
break Ok(SessionExit::Reconnect { layout: false,
|
||||
healthy: healthy_since.is_some_and(|since: Instant| since.elapsed() >= Duration::from_secs(30)) });
|
||||
}
|
||||
if crate::capture::has_frame(&crate::capture::frame_path()?) && healthy_since.is_none() {
|
||||
healthy_since = Some(Instant::now());
|
||||
}
|
||||
if let Some(status) = capture.0.try_wait()? {
|
||||
anyhow::ensure!(status.code() == Some(75), "portal capture helper exited ({status})");
|
||||
break Ok(SessionExit::Reconnect { layout: false,
|
||||
healthy: healthy_since.is_some_and(|since: Instant| since.elapsed() >= Duration::from_secs(30)) });
|
||||
}
|
||||
continue;
|
||||
},
|
||||
event = receiver.recv() => match event {
|
||||
Some(event) => event,
|
||||
None => break Ok(SessionExit::Shutdown),
|
||||
},
|
||||
};
|
||||
match event {
|
||||
Event::Key(code, down, reply) => {
|
||||
let result = portal
|
||||
@@ -176,6 +478,9 @@ async fn portal_worker(
|
||||
},
|
||||
)
|
||||
.await;
|
||||
if result.is_ok() {
|
||||
if down { held_keys.insert(code); } else { held_keys.remove(&code); }
|
||||
}
|
||||
answer(reply, result)?;
|
||||
}
|
||||
Event::Button(button, down, reply) => {
|
||||
@@ -190,25 +495,22 @@ async fn portal_worker(
|
||||
},
|
||||
)
|
||||
.await;
|
||||
if result.is_ok() {
|
||||
if down { held_buttons.insert(button); } else { held_buttons.remove(&button); }
|
||||
}
|
||||
answer(reply, result)?;
|
||||
}
|
||||
Event::FlushMotion => loop {
|
||||
Event::FlushMotion => {
|
||||
motion_queued.store(false, Ordering::Release);
|
||||
let motion = pending_motion.lock().unwrap().take();
|
||||
let Some(motion) = motion else {
|
||||
motion_queued.store(false, Ordering::Release);
|
||||
let has_new_motion = pending_motion.lock().unwrap().is_some();
|
||||
if has_new_motion
|
||||
&& motion_queued
|
||||
.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
|
||||
.is_ok()
|
||||
{
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
};
|
||||
let result = if motion.absolute {
|
||||
let logical_x = motion.x.clamp(0.0, 65535.0) * logical_width as f64 / 65535.0;
|
||||
let logical_y = motion.y.clamp(0.0, 65535.0) * logical_height as f64 / 65535.0;
|
||||
let (stream_id, logical_x, logical_y) = match absolute_target(&streams, motion.x, motion.y) {
|
||||
Ok(target) => target,
|
||||
Err(error) => { eprintln!("portal pointer layout not ready: {error}"); continue; }
|
||||
};
|
||||
portal
|
||||
.notify_pointer_motion_absolute(&session, stream_id, logical_x, logical_y)
|
||||
.await
|
||||
@@ -229,10 +531,14 @@ async fn portal_worker(
|
||||
.await,
|
||||
)?;
|
||||
}
|
||||
Event::Shutdown => break,
|
||||
Event::Shutdown => break Ok(SessionExit::Shutdown),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}.await;
|
||||
drop(closed);
|
||||
drop(capture);
|
||||
let _ = tokio::time::timeout(Duration::from_secs(2), session.close()).await;
|
||||
outcome
|
||||
}
|
||||
|
||||
fn answer<T>(reply: Reply, result: std::result::Result<T, ashpd::Error>) -> Result<()> {
|
||||
@@ -246,6 +552,14 @@ impl InputBackend for PortalBackend {
|
||||
"portal"
|
||||
}
|
||||
|
||||
fn check_health(&self) -> Result<()> {
|
||||
if let Some(error) = self.failure.lock().unwrap().clone() {
|
||||
anyhow::bail!("portal input worker failed: {error}");
|
||||
}
|
||||
anyhow::ensure!(!self.sender.is_closed(), "portal input worker stopped");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn key(&mut self, vkey: u16, down: bool) -> Result<()> {
|
||||
let code = super::uinput::vk_to_linux_key(vkey) as i32;
|
||||
if code == 0 {
|
||||
@@ -342,7 +656,7 @@ impl Drop for PortalBackend {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{merge_motion, Motion};
|
||||
use super::{absolute_target, merge_motion, Motion};
|
||||
|
||||
#[test]
|
||||
fn absolute_motion_keeps_only_the_latest_position() {
|
||||
@@ -358,6 +672,35 @@ mod tests {
|
||||
};
|
||||
merge_motion(&mut pending, latest);
|
||||
assert_eq!(pending, Some(latest));
|
||||
let streams = [
|
||||
crate::capture::CaptureStream {
|
||||
node: 41,
|
||||
x: -1280,
|
||||
y: 0,
|
||||
width: 1280,
|
||||
height: 720,
|
||||
},
|
||||
crate::capture::CaptureStream {
|
||||
node: 42,
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: 1920,
|
||||
height: 1080,
|
||||
},
|
||||
];
|
||||
assert_eq!(absolute_target(&streams, 0.0, 0.0).unwrap(), (41, 0.0, 0.0));
|
||||
assert_eq!(
|
||||
absolute_target(&streams, 65535.0, 65535.0).unwrap(),
|
||||
(42, 1919.0, 1079.0)
|
||||
);
|
||||
let target = absolute_target(&streams, 1280.0 * 65535.0 / 3199.0, 0.0).unwrap();
|
||||
assert_eq!(target.0, 42);
|
||||
assert!(target.1.abs() < 1e-6);
|
||||
assert!(absolute_target(&streams, f64::NAN, 0.0).is_err());
|
||||
let mut gap = streams;
|
||||
gap[1].x = 200;
|
||||
let target = absolute_target(&gap, 1280.0 * 65535.0 / 3399.0, 0.0).unwrap();
|
||||
assert_eq!(target, (41, 1279.0, 0.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
+37
-16
@@ -157,7 +157,12 @@ enum DisplayAction {
|
||||
/// Show the configured source type.
|
||||
Status,
|
||||
/// Use a monitor, one window, or a portal-provided virtual display.
|
||||
Source { source: DisplaySource },
|
||||
Source {
|
||||
source: DisplaySource,
|
||||
/// Allow selecting several monitors in the next portal consent dialog.
|
||||
#[arg(long)]
|
||||
multiple: bool,
|
||||
},
|
||||
/// Choose portal capture, or explicitly enable direct Wayland monitor capture.
|
||||
Backend {
|
||||
backend: CaptureBackend,
|
||||
@@ -228,29 +233,32 @@ fn main() -> Result<()> {
|
||||
if matches!(action, DisplayAction::Outputs) {
|
||||
return capture::list_wayland_outputs();
|
||||
}
|
||||
let mut config = config::Config::load()?;
|
||||
let config = config::Config::load()?;
|
||||
match action {
|
||||
DisplayAction::Status => {
|
||||
println!("{}", t!("display.status", source = config.capture_source));
|
||||
println!("capture backend: {}", config.capture_backend);
|
||||
println!("multiple monitors: {}", config.capture_multiple);
|
||||
if let Some(output) = &config.capture_output {
|
||||
println!("output: {output}");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
DisplayAction::Backend { backend, output } => {
|
||||
config.capture_backend = match backend {
|
||||
let backend = match backend {
|
||||
CaptureBackend::Portal => "portal",
|
||||
CaptureBackend::Wayland => "wayland",
|
||||
};
|
||||
let config = config::Config::update(|stored| {
|
||||
stored.capture_backend = backend.into();
|
||||
stored.capture_output = output;
|
||||
if backend == "wayland" {
|
||||
stored.capture_source = "monitor".into();
|
||||
stored.capture_multiple = false;
|
||||
}
|
||||
.into();
|
||||
config.capture_output = output;
|
||||
if config.capture_backend == "wayland" {
|
||||
config.capture_source = "monitor".into();
|
||||
}
|
||||
config.capture_restore_token = None;
|
||||
config.remote_desktop_restore_token = None;
|
||||
config.store()?;
|
||||
stored.capture_restore_token = None;
|
||||
stored.remote_desktop_restore_token = None;
|
||||
})?;
|
||||
println!(
|
||||
"{}",
|
||||
if config.capture_backend == "wayland" {
|
||||
@@ -262,12 +270,25 @@ fn main() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
DisplayAction::Outputs => unreachable!(),
|
||||
DisplayAction::Source { source } => {
|
||||
config.capture_source = source.as_str().to_string();
|
||||
config.capture_restore_token = None;
|
||||
config.remote_desktop_restore_token = None;
|
||||
config.store()?;
|
||||
DisplayAction::Source { source, multiple } => {
|
||||
anyhow::ensure!(
|
||||
!multiple || matches!(&source, DisplaySource::Monitor),
|
||||
"--multiple is supported only for monitor sources"
|
||||
);
|
||||
anyhow::ensure!(
|
||||
!multiple || config.capture_backend == "portal",
|
||||
"multi-monitor selection requires the portal capture backend"
|
||||
);
|
||||
config::Config::update(|stored| {
|
||||
stored.capture_source = source.as_str().to_string();
|
||||
stored.capture_multiple = multiple;
|
||||
stored.capture_restore_token = None;
|
||||
stored.remote_desktop_restore_token = None;
|
||||
})?;
|
||||
println!("{}", t!("display.changed", source = source.as_str()));
|
||||
println!(
|
||||
"multiple monitors: {multiple}; selection applies on the next session"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
+3
-3
@@ -973,7 +973,7 @@ fn process_start_time(pid: u32) -> Result<u64> {
|
||||
}
|
||||
|
||||
fn frame_path() -> Result<PathBuf> {
|
||||
Ok(crate::config::runtime_dir()?.join("frames.v1"))
|
||||
Ok(crate::config::runtime_dir()?.join("frames.v3"))
|
||||
}
|
||||
|
||||
fn unix_path_to_wine(path: &Path) -> String {
|
||||
@@ -1370,8 +1370,8 @@ mod tests {
|
||||
#[test]
|
||||
fn runtime_path_converts_to_a_wine_z_path() {
|
||||
assert_eq!(
|
||||
unix_path_to_wine(Path::new("/run/user/1000/uur/frames.v1")),
|
||||
r"Z:\run\user\1000\uur\frames.v1"
|
||||
unix_path_to_wine(Path::new("/run/user/1000/uur/frames.v3")),
|
||||
r"Z:\run\user\1000\uur\frames.v3"
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user