feat(capture): support consented multi-monitor desktops with recovery (#32)
This commit is contained in:
1 parent
6d0e733cd7
commit
98af6fce28
19 files changed
+2175
-271
No files matched your search
+514
-117
@@ -2,10 +2,10 @@
|
|||||||
/*
|
/*
|
||||||
* uur-pw-capture — PipeWire ScreenCast consumer.
|
* uur-pw-capture — PipeWire ScreenCast consumer.
|
||||||
*
|
*
|
||||||
* Receives an inherited portal PipeWire fd (UUR_PW_FD) and the authorized
|
* Receives an inherited portal PipeWire fd (UUR_PW_FD) and authorized monitor
|
||||||
* video node id (UUR_PW_NODE), streams the monitor as BGRx and publishes
|
* stream specifications (UUR_PW_STREAMS), composites their BGRx frames and
|
||||||
* frames into the private UUR_FRAME_PATH following the seqlock protocol in
|
* publishes the virtual desktop into UUR_FRAME_PATH using the seqlock protocol
|
||||||
* docs/capture-protocol.md.
|
* in docs/capture-protocol.md.
|
||||||
*
|
*
|
||||||
* The shared file is created only after the stream format is negotiated,
|
* 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
|
* 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 stride;
|
||||||
uint32_t format;
|
uint32_t format;
|
||||||
_Atomic uint64_t total_frames;
|
_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,
|
_Static_assert(sizeof(struct frame_header) == UURF_HEADER_BYTES,
|
||||||
"frame protocol header size changed");
|
"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 {
|
struct frame_slot {
|
||||||
_Atomic uint64_t seq;
|
_Atomic uint64_t seq;
|
||||||
/* frame bytes follow */
|
/* frame bytes follow */
|
||||||
};
|
};
|
||||||
|
|
||||||
struct capture {
|
struct capture;
|
||||||
struct pw_main_loop *loop;
|
|
||||||
|
struct capture_stream {
|
||||||
|
struct capture *capture;
|
||||||
struct pw_stream *stream;
|
struct pw_stream *stream;
|
||||||
struct spa_hook listener;
|
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 width;
|
||||||
uint32_t height;
|
uint32_t height;
|
||||||
uint32_t stride;
|
uint32_t stride;
|
||||||
enum spa_video_format format;
|
uint32_t flags;
|
||||||
uint64_t counter;
|
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;
|
int shm_fd;
|
||||||
uint8_t *shm;
|
uint8_t *shm;
|
||||||
size_t shm_size;
|
size_t shm_size;
|
||||||
int dmabuf_usable;
|
|
||||||
int exit_status;
|
int exit_status;
|
||||||
volatile sig_atomic_t stopping;
|
volatile sig_atomic_t stopping;
|
||||||
int was_streaming;
|
|
||||||
uint64_t started_ms;
|
uint64_t started_ms;
|
||||||
uint64_t paused_ms;
|
|
||||||
char frame_path[PATH_MAX];
|
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);
|
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
|
/* 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. */
|
* previous inode: never truncate or resize memory another process is reading. */
|
||||||
static int shm_setup(struct capture *c)
|
static int shm_setup(struct capture *c)
|
||||||
@@ -157,6 +226,12 @@ static int shm_setup(struct capture *c)
|
|||||||
header->stride = c->stride;
|
header->stride = c->stride;
|
||||||
header->format = FRAME_FORMAT_BGRX;
|
header->format = FRAME_FORMAT_BGRX;
|
||||||
atomic_init(&header->total_frames, 0);
|
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) {
|
for (uint32_t i = 0; i < UURF_SLOT_COUNT; ++i) {
|
||||||
struct frame_slot *slot = (struct frame_slot *)(mapping +
|
struct frame_slot *slot = (struct frame_slot *)(mapping +
|
||||||
UURF_HEADER_BYTES + i * slot_bytes);
|
UURF_HEADER_BYTES + i * slot_bytes);
|
||||||
@@ -184,10 +259,9 @@ static int shm_setup(struct capture *c)
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void publish_frame(struct capture *c, const uint8_t *pixels,
|
static void publish_frame(struct capture *c)
|
||||||
uint32_t src_stride, uint32_t src_height)
|
|
||||||
{
|
{
|
||||||
if (c->shm == NULL)
|
if (c->shm == NULL || c->composite == NULL)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
c->counter += 1;
|
c->counter += 1;
|
||||||
@@ -196,31 +270,7 @@ static void publish_frame(struct capture *c, const uint8_t *pixels,
|
|||||||
memory_order_release); /* writing */
|
memory_order_release); /* writing */
|
||||||
|
|
||||||
uint8_t *dst = slot_frame(slot);
|
uint8_t *dst = slot_frame(slot);
|
||||||
uint32_t rows = src_height < c->height ? src_height : c->height;
|
memcpy(dst, c->composite, c->composite_size);
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
atomic_store_explicit(&slot->seq, 2 * c->counter, memory_order_release);
|
atomic_store_explicit(&slot->seq, 2 * c->counter, memory_order_release);
|
||||||
struct frame_header *header = (struct frame_header *)c->shm;
|
struct frame_header *header = (struct frame_header *)c->shm;
|
||||||
@@ -238,15 +288,253 @@ static int sync_dmabuf(int fd, uint64_t flags)
|
|||||||
return result;
|
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)
|
static void on_process(void *userdata)
|
||||||
{
|
{
|
||||||
struct capture *c = userdata;
|
struct capture_stream *s = userdata;
|
||||||
struct pw_buffer *buffer = pw_stream_dequeue_buffer(c->stream);
|
struct capture *c = s->capture;
|
||||||
|
struct pw_buffer *buffer = pw_stream_dequeue_buffer(s->stream);
|
||||||
if (buffer == NULL)
|
if (buffer == NULL)
|
||||||
return;
|
return;
|
||||||
struct spa_buffer *buf = buffer->buffer;
|
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];
|
struct spa_data *plane = &buf->datas[0];
|
||||||
uint8_t *pixels = NULL;
|
uint8_t *pixels = NULL;
|
||||||
void *mapping = MAP_FAILED;
|
void *mapping = MAP_FAILED;
|
||||||
@@ -257,18 +545,17 @@ static void on_process(void *userdata)
|
|||||||
if (plane->chunk == NULL || plane->chunk->stride < 0 ||
|
if (plane->chunk == NULL || plane->chunk->stride < 0 ||
|
||||||
(plane->chunk->flags & (SPA_CHUNK_FLAG_CORRUPTED | SPA_CHUNK_FLAG_EMPTY)))
|
(plane->chunk->flags & (SPA_CHUNK_FLAG_CORRUPTED | SPA_CHUNK_FLAG_EMPTY)))
|
||||||
goto done;
|
goto done;
|
||||||
uint32_t row_bytes = c->width *
|
uint32_t source_bpp =
|
||||||
(c->format == SPA_VIDEO_FORMAT_BGR || c->format == SPA_VIDEO_FORMAT_RGB ? 3u : 4u);
|
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 stride = plane->chunk->stride > 0 ?
|
||||||
(uint32_t)plane->chunk->stride : row_bytes;
|
(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;
|
uint32_t data_offset = plane->chunk->offset;
|
||||||
if (stride < row_bytes || span > 256u * 1024 * 1024)
|
if (stride < row_bytes || span > 256u * 1024 * 1024)
|
||||||
goto done;
|
goto done;
|
||||||
if (dmabuf) {
|
if (dmabuf) {
|
||||||
// DMA-BUF maxsize/chunk size may be zero or placeholders. Query
|
if (!s->dmabuf_usable || plane->fd < 0)
|
||||||
// the fd and include BOTH the plane mapping and chunk offsets.
|
|
||||||
if (!c->dmabuf_usable || plane->fd < 0)
|
|
||||||
goto done;
|
goto done;
|
||||||
off_t extent = lseek((int)plane->fd, 0, SEEK_END);
|
off_t extent = lseek((int)plane->fd, 0, SEEK_END);
|
||||||
uint64_t end = (uint64_t)plane->mapoffset + data_offset + span;
|
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;
|
pixels = (uint8_t *)mapping + delta;
|
||||||
}
|
}
|
||||||
if (pixels != NULL) {
|
if (pixels != NULL) {
|
||||||
if (c->counter == 0)
|
if (s->counter == 0)
|
||||||
fprintf(stderr, "capture buffer: %s, source stride %u, chunk offset %u\n",
|
fprintf(stderr, "stream %u buffer: %s, source stride %u, chunk offset %u\n",
|
||||||
dmabuf ? "linear DMA-BUF" : "shared memory", stride, data_offset);
|
s->node_id, dmabuf ? "linear DMA-BUF" : "shared memory", stride, data_offset);
|
||||||
publish_frame(c, pixels, stride, c->height);
|
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:
|
done:
|
||||||
if (synchronized)
|
if (synchronized)
|
||||||
@@ -314,13 +607,14 @@ done:
|
|||||||
munmap(mapping, mapping_size);
|
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,
|
static void on_param_changed(void *userdata, uint32_t id,
|
||||||
const struct spa_pod *param)
|
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)
|
if (param == NULL || id != SPA_PARAM_Format)
|
||||||
return;
|
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_RGBA &&
|
||||||
info.format != SPA_VIDEO_FORMAT_BGR &&
|
info.format != SPA_VIDEO_FORMAT_BGR &&
|
||||||
info.format != SPA_VIDEO_FORMAT_RGB) {
|
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;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (info.size.width == 0 || info.size.height == 0 ||
|
if (info.size.width == 0 || info.size.height == 0 ||
|
||||||
info.size.width > 16384 || info.size.height > 16384 ||
|
info.size.width > 16384 || info.size.height > 16384 ||
|
||||||
(uint64_t)info.size.width * 4 * info.size.height > 256u * 1024 * 1024) {
|
(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;
|
c->exit_status = 1;
|
||||||
pw_main_loop_quit(c->loop);
|
pw_main_loop_quit(c->loop);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
c->width = (uint32_t)info.size.width;
|
int changed = !s->format_ready || s->width != info.size.width ||
|
||||||
c->height = (uint32_t)info.size.height;
|
s->height != info.size.height || s->format != info.format;
|
||||||
c->format = info.format;
|
s->width = (uint32_t)info.size.width;
|
||||||
c->stride = SPA_ROUND_UP_N(c->width * 4, 4);
|
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
|
/* 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
|
* linear layout. A tiled modifier needs a real importer (GBM/EGL), so
|
||||||
* refuse to publish garbage rather than emit a corrupt frame. */
|
* 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;
|
info.modifier == DRM_FORMAT_MOD_LINEAR;
|
||||||
fprintf(stderr, "negotiated: %ux%u stride %u modifier %#llx%s\n", c->width,
|
if (changed) {
|
||||||
c->height, c->stride, (unsigned long long)info.modifier,
|
size_t bytes = (size_t)s->width * s->height * 4;
|
||||||
c->dmabuf_usable ? "" : " (DMA-BUF CPU mapping disabled)");
|
size_t source_total = bytes;
|
||||||
|
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||||
const struct frame_header *header = (const struct frame_header *)c->shm;
|
if (&c->streams[i] != s)
|
||||||
if (header == NULL || header->width != c->width || header->height != c->height) {
|
source_total += c->streams[i].pixels_size;
|
||||||
if (shm_setup(c) < 0) {
|
}
|
||||||
|
if (source_total > 512u * 1024 * 1024) {
|
||||||
|
fprintf(stderr, "monitor source buffers exceed the memory limit\n");
|
||||||
c->exit_status = 1;
|
c->exit_status = 1;
|
||||||
pw_main_loop_quit(c->loop);
|
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,
|
static void on_state_changed(void *userdata, enum pw_stream_state old,
|
||||||
enum pw_stream_state state, const char *error)
|
enum pw_stream_state state, const char *error)
|
||||||
{
|
{
|
||||||
struct capture *c = userdata;
|
struct capture_stream *s = userdata;
|
||||||
fprintf(stderr, "stream state: %s%s%s\n",
|
struct capture *c = s->capture;
|
||||||
|
fprintf(stderr, "stream %u state: %s%s%s\n", s->node_id,
|
||||||
pw_stream_state_as_string(state),
|
pw_stream_state_as_string(state),
|
||||||
error != NULL && error[0] != '\0' ? " - " : "",
|
error != NULL && error[0] != '\0' ? " - " : "",
|
||||||
error != NULL ? error : "");
|
error != NULL ? error : "");
|
||||||
if (c->stopping)
|
if (c->stopping)
|
||||||
return;
|
return;
|
||||||
if (state == PW_STREAM_STATE_STREAMING) {
|
if (state == PW_STREAM_STATE_STREAMING) {
|
||||||
c->was_streaming = 1;
|
s->was_streaming = 1;
|
||||||
c->paused_ms = 0;
|
s->paused_ms = 0;
|
||||||
} else if (state == PW_STREAM_STATE_PAUSED && c->was_streaming) {
|
} else if (state == PW_STREAM_STATE_PAUSED && s->was_streaming) {
|
||||||
if (c->paused_ms == 0)
|
if (s->paused_ms == 0)
|
||||||
c->paused_ms = monotonic_ms();
|
s->paused_ms = monotonic_ms();
|
||||||
} else if (state == PW_STREAM_STATE_ERROR ||
|
} else if (state == PW_STREAM_STATE_ERROR ||
|
||||||
(state == PW_STREAM_STATE_UNCONNECTED && old != state)) {
|
(state == PW_STREAM_STATE_UNCONNECTED && old != state)) {
|
||||||
c->exit_status = 75;
|
c->exit_status = 75;
|
||||||
@@ -395,14 +722,20 @@ static void on_watchdog(void *userdata, uint64_t expirations)
|
|||||||
struct capture *c = userdata;
|
struct capture *c = userdata;
|
||||||
(void)expirations;
|
(void)expirations;
|
||||||
uint64_t now = monotonic_ms();
|
uint64_t now = monotonic_ms();
|
||||||
// A static desktop can legitimately produce no new frames while streaming.
|
if (c->shm != NULL)
|
||||||
// Only a prolonged PAUSED state or a stream with no FIRST frame is fatal.
|
atomic_store_explicit(&((struct frame_header *)c->shm)->heartbeat_ms,
|
||||||
if (!c->stopping &&
|
now, memory_order_release);
|
||||||
((c->paused_ms != 0 && now - c->paused_ms >= 10000) ||
|
for (uint32_t i = 0; i < c->stream_count; ++i) {
|
||||||
(c->counter == 0 && now - c->started_ms >= 30000))) {
|
struct capture_stream *s = &c->streams[i];
|
||||||
fprintf(stderr, "capture stream stopped producing usable frames; reconnecting\n");
|
if (!c->stopping &&
|
||||||
c->exit_status = 75;
|
((s->paused_ms != 0 && now - s->paused_ms >= 10000) ||
|
||||||
pw_main_loop_quit(c->loop);
|
(!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);
|
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)
|
int main(void)
|
||||||
{
|
{
|
||||||
const char *fd_text = getenv("UUR_PW_FD");
|
const char *fd_text = getenv("UUR_PW_FD");
|
||||||
const char *node_text = getenv("UUR_PW_NODE");
|
const char *spec_text = getenv("UUR_PW_STREAMS");
|
||||||
if (fd_text == NULL || node_text == NULL) {
|
const char *legacy_node = getenv("UUR_PW_NODE");
|
||||||
fprintf(stderr,
|
|
||||||
"UUR_PW_FD and UUR_PW_NODE must be set by 'uur capture'\n");
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
const char *frame_path = getenv("UUR_FRAME_PATH");
|
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) {
|
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;
|
return 2;
|
||||||
}
|
}
|
||||||
int pw_fd = atoi(fd_text);
|
int pw_fd = atoi(fd_text);
|
||||||
uint32_t node_id = (uint32_t)strtoul(node_text, NULL, 10);
|
|
||||||
|
|
||||||
pw_init(NULL, NULL);
|
|
||||||
|
|
||||||
struct capture c;
|
struct capture c;
|
||||||
memset(&c, 0, sizeof(c));
|
memset(&c, 0, sizeof(c));
|
||||||
c.shm_fd = -1;
|
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);
|
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;
|
active_capture = &c;
|
||||||
signal(SIGINT, stop_capture);
|
signal(SIGINT, stop_capture);
|
||||||
signal(SIGTERM, stop_capture);
|
signal(SIGTERM, stop_capture);
|
||||||
@@ -494,8 +872,7 @@ int main(void)
|
|||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Connect through the portal's private PipeWire instance: only the
|
/* The portal fd only exposes streams covered by this ScreenCast consent. */
|
||||||
* consented node is reachable on this descriptor. */
|
|
||||||
struct pw_core *core = pw_context_connect_fd(context, pw_fd, NULL, 0);
|
struct pw_core *core = pw_context_connect_fd(context, pw_fd, NULL, 0);
|
||||||
if (core == NULL) {
|
if (core == NULL) {
|
||||||
fprintf(stderr, "pw_context_connect_fd failed\n");
|
fprintf(stderr, "pw_context_connect_fd failed\n");
|
||||||
@@ -503,16 +880,7 @@ int main(void)
|
|||||||
}
|
}
|
||||||
struct spa_hook core_listener;
|
struct spa_hook core_listener;
|
||||||
pw_core_add_listener(core, &core_listener, &core_events, &c);
|
pw_core_add_listener(core, &core_listener, &core_events, &c);
|
||||||
|
struct spa_source *watchdog = NULL;
|
||||||
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);
|
|
||||||
|
|
||||||
uint8_t pod_buffer[1024];
|
uint8_t pod_buffer[1024];
|
||||||
struct spa_pod_builder pod_builder =
|
struct spa_pod_builder pod_builder =
|
||||||
@@ -522,28 +890,56 @@ int main(void)
|
|||||||
params[1] = capture_format(&pod_builder, 0);
|
params[1] = capture_format(&pod_builder, 0);
|
||||||
c.started_ms = monotonic_ms();
|
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) {
|
||||||
PW_STREAM_FLAG_MAP_BUFFERS |
|
struct capture_stream *s = &c.streams[i];
|
||||||
PW_STREAM_FLAG_AUTOCONNECT,
|
s->capture = &c;
|
||||||
params, 2) < 0) {
|
char name[64];
|
||||||
fprintf(stderr, "pw_stream_connect failed\n");
|
snprintf(name, sizeof(name), "uur-capture-%u", i + 1);
|
||||||
return 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 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),
|
watchdog = pw_loop_add_timer(pw_main_loop_get_loop(loop), on_watchdog, &c);
|
||||||
on_watchdog, &c);
|
|
||||||
struct timespec interval = {.tv_sec = 1};
|
struct timespec interval = {.tv_sec = 1};
|
||||||
if (watchdog == NULL || pw_loop_update_timer(pw_main_loop_get_loop(loop),
|
if (watchdog == NULL || pw_loop_update_timer(pw_main_loop_get_loop(loop),
|
||||||
watchdog, &interval, &interval, false) < 0) {
|
watchdog, &interval, &interval, false) < 0) {
|
||||||
fprintf(stderr, "could not start capture watchdog\n");
|
fprintf(stderr, "could not start capture watchdog\n");
|
||||||
return 1;
|
c.exit_status = 1;
|
||||||
|
goto cleanup;
|
||||||
}
|
}
|
||||||
pw_main_loop_run(loop);
|
pw_main_loop_run(loop);
|
||||||
|
|
||||||
c.stopping = 1;
|
c.stopping = 1;
|
||||||
active_capture = NULL;
|
active_capture = NULL;
|
||||||
pw_loop_destroy_source(pw_main_loop_get_loop(loop), watchdog);
|
cleanup:
|
||||||
pw_stream_destroy(c.stream);
|
c.stopping = 1;
|
||||||
|
active_capture = NULL;
|
||||||
|
if (watchdog != NULL)
|
||||||
|
pw_loop_destroy_source(pw_main_loop_get_loop(loop), watchdog);
|
||||||
|
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);
|
spa_hook_remove(&core_listener);
|
||||||
pw_core_disconnect(core);
|
pw_core_disconnect(core);
|
||||||
pw_context_destroy(context);
|
pw_context_destroy(context);
|
||||||
@@ -555,6 +951,7 @@ int main(void)
|
|||||||
}
|
}
|
||||||
if (c.shm_fd >= 0)
|
if (c.shm_fd >= 0)
|
||||||
close(c.shm_fd);
|
close(c.shm_fd);
|
||||||
|
free(c.composite);
|
||||||
unlink(c.frame_path);
|
unlink(c.frame_path);
|
||||||
pw_deinit();
|
pw_deinit();
|
||||||
return c.exit_status;
|
return c.exit_status;
|
||||||
|
|||||||
@@ -24,7 +24,9 @@
|
|||||||
struct frame_header {
|
struct frame_header {
|
||||||
uint32_t magic, version, width, height, stride, format;
|
uint32_t magic, version, width, height, stride, format;
|
||||||
_Atomic uint64_t total_frames;
|
_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");
|
_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->width = c->width; header->height = c->height;
|
||||||
header->stride = c->width * 4; header->format = 1;
|
header->stride = c->width * 4; header->format = 1;
|
||||||
atomic_init(&header->total_frames, 0);
|
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) {
|
for (uint32_t i = 0; i < UURF_SLOT_COUNT; ++i) {
|
||||||
_Atomic uint64_t *seq = (_Atomic uint64_t *)((uint8_t *)c->ring +
|
_Atomic uint64_t *seq = (_Atomic uint64_t *)((uint8_t *)c->ring +
|
||||||
UURF_HEADER_BYTES + i * (sizeof(uint64_t) + bytes));
|
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
|
prefix. There are no permanent daemons, global `pkill` calls, or required
|
||||||
systemd units.
|
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
|
passed through the adapter configuration, so users and concurrent sessions do
|
||||||
not share a global `/dev/shm` object.
|
not share a global `/dev/shm` object.
|
||||||
|
|
||||||
|
|||||||
+45
-15
@@ -1,16 +1,18 @@
|
|||||||
# Capture frame protocol
|
# Capture frame protocol
|
||||||
|
|
||||||
How frames travel from the compositor (via PipeWire) into the client's
|
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
|
```text
|
||||||
xdg-desktop-portal ScreenCast
|
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
|
│ 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
|
│ mapped read-only by the PE hook through its configured Wine Z: path
|
||||||
▼
|
▼
|
||||||
uur-hook.dll ── intercepts static/dynamic gdi32!BitBlt/StretchBlt calls;
|
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
|
## 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 |
|
| offset | type | field |
|
||||||
| --- | --- | --- |
|
| --- | --- | --- |
|
||||||
| 0 | u32 | magic `0x46525555` ("UURF") |
|
| 0 | u32 | magic `0x46525555` ("UURF") |
|
||||||
| 4 | u32 | protocol version = 1 |
|
| 4 | u32 | protocol version = 3 |
|
||||||
| 8 | u32 | frame width (px) |
|
| 8 | u32 | frame width (px) |
|
||||||
| 12 | u32 | frame height (px) |
|
| 12 | u32 | frame height (px) |
|
||||||
| 16 | u32 | stride (bytes per row) |
|
| 16 | u32 | stride (bytes per row) |
|
||||||
| 20 | u32 | format: 1 = BGRx (32 bits per pixel) |
|
| 20 | u32 | format: 1 = BGRx (32 bits per pixel) |
|
||||||
| 24 | u64 | total frames written (monotonic counter) |
|
| 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 |
|
| offset | type | field |
|
||||||
| --- | --- | --- |
|
| --- | --- | --- |
|
||||||
@@ -50,12 +63,27 @@ the managed prefix configuration. It is never a global shared-memory name.
|
|||||||
|
|
||||||
## Geometry and session changes
|
## Geometry and session changes
|
||||||
|
|
||||||
An exact Wine monitor rectangle maps onto the entire selected frame when their
|
For one selected stream, an exact Wine monitor rectangle maps onto the entire
|
||||||
aspect ratios match. Pixel dimensions may differ under fractional scaling, where
|
frame when their aspect ratios match. With multiple selected monitor streams,
|
||||||
Xwayland's render size can exceed the portal's native frame size. Partial regions
|
the producer uses portal position/size metadata to compose the streams into a
|
||||||
and whole-virtual-desktop requests retain the existing virtual-desktop mapping.
|
virtual desktop frame; Wine monitor rectangles then crop their matching region.
|
||||||
This does not establish monitor identity between Wine and the portal; selecting
|
If a portal omits layout metadata, streams are arranged left to right. Fractional
|
||||||
a non-primary monitor still requires consistent client/input coordinates.
|
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
|
Each transport inode has immutable geometry. A negotiated size change creates
|
||||||
a new mode-0600 file, initializes its header and slots, then atomically replaces
|
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.
|
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
|
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
|
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
|
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
|
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 |
|
| X11 multi-monitor | Wine integration | Native Wine/XRandR display topology |
|
||||||
| Wayland monitor/window selection | available | Persistent portal source selection |
|
| Wayland monitor/window selection | available | Persistent portal source selection |
|
||||||
| Wayland virtual source | available when advertised | `uur display source virtual` → ScreenCast Virtual source |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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
|
```bash
|
||||||
uur display status
|
uur display status
|
||||||
uur display source monitor
|
uur display source monitor
|
||||||
|
uur display source monitor --multiple
|
||||||
uur display source window
|
uur display source window
|
||||||
uur display source virtual
|
uur display source virtual
|
||||||
```
|
```
|
||||||
|
|
||||||
The command clears the old restore token so the next Portal session can create
|
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.
|
or select the requested source. With `monitor --multiple`, the chooser can select
|
||||||
Wayland currently carries one selected stream; independent multi-stream
|
multiple displays; uur composes those PipeWire streams into the virtual desktop
|
||||||
switching is the next display-topology adapter.
|
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
|
## First run and normal use
|
||||||
|
|
||||||
|
|||||||
@@ -3,11 +3,12 @@
|
|||||||
## Frame sources
|
## Frame sources
|
||||||
|
|
||||||
- X11 sessions expose the XRandR monitor topology directly to Wine.
|
- 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
|
- `uur display source virtual` requests the portal's Virtual source type and
|
||||||
stores its restore token.
|
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
|
## Codec capabilities
|
||||||
|
|
||||||
|
|||||||
+22
-2
@@ -5,9 +5,29 @@
|
|||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
|
|
||||||
#define UURF_MAGIC 0x46525555u
|
#define UURF_MAGIC 0x46525555u
|
||||||
#define UURF_VERSION 1u
|
#define UURF_VERSION 3u
|
||||||
#define UURF_SLOT_COUNT 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)
|
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 + 16, stride);
|
||||||
put_u32(transport + 20, 1);
|
put_u32(transport + 20, 1);
|
||||||
put_u64(transport + 24, 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);
|
unsigned char *slot = transport + uurf_slot_offset(1, slot_bytes);
|
||||||
put_u64(slot, 2);
|
put_u64(slot, 2);
|
||||||
for (size_t offset = 8; offset < slot_bytes; offset += 4) {
|
for (size_t offset = 8; offset < slot_bytes; offset += 4) {
|
||||||
|
|||||||
+857
-17
@@ -27,6 +27,7 @@
|
|||||||
#include <tlhelp32.h>
|
#include <tlhelp32.h>
|
||||||
#include <dxgi.h>
|
#include <dxgi.h>
|
||||||
|
|
||||||
|
#include <limits.h>
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
@@ -42,7 +43,35 @@
|
|||||||
static UINT(WINAPI *original_send_input)(UINT, LPINPUT, int);
|
static UINT(WINAPI *original_send_input)(UINT, LPINPUT, int);
|
||||||
static HRESULT(WINAPI *original_create_dxgi_factory1)(REFIID, void **);
|
static HRESULT(WINAPI *original_create_dxgi_factory1)(REFIID, void **);
|
||||||
static FARPROC(WINAPI *original_get_proc_address)(HMODULE, LPCSTR);
|
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);
|
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_factories_patched = 0;
|
||||||
static volatile LONG dxgi_adapters_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_duplicate_calls = 0;
|
||||||
static volatile LONG dxgi_dup_acquires = 0;
|
static volatile LONG dxgi_dup_acquires = 0;
|
||||||
static volatile LONG dxgi_dup_frames = 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)(
|
static HRESULT __attribute__((unused))(STDMETHODCALLTYPE *original_dxgi_acquire_next_frame)(
|
||||||
void *duplication, UINT timeout, void *frame_info, void **resource) = NULL;
|
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_width;
|
||||||
static uint32_t frame_height;
|
static uint32_t frame_height;
|
||||||
static uint32_t frame_stride;
|
static uint32_t frame_stride;
|
||||||
|
static uint32_t frame_flags;
|
||||||
|
static uint32_t frame_monitor_count;
|
||||||
static uint64_t frame_slot_bytes;
|
static uint64_t frame_slot_bytes;
|
||||||
static unsigned char *frame_snapshot;
|
static unsigned char *frame_snapshot;
|
||||||
static size_t frame_snapshot_capacity;
|
static size_t frame_snapshot_capacity;
|
||||||
@@ -241,6 +275,7 @@ static size_t frame_map_size;
|
|||||||
static BY_HANDLE_FILE_INFORMATION frame_identity;
|
static BY_HANDLE_FILE_INFORMATION frame_identity;
|
||||||
static ULONGLONG frame_checked_at;
|
static ULONGLONG frame_checked_at;
|
||||||
static SRWLOCK frame_lock = SRWLOCK_INIT;
|
static SRWLOCK frame_lock = SRWLOCK_INIT;
|
||||||
|
static int capture_geometry_enabled;
|
||||||
|
|
||||||
static char *read_ini_value(const char *path, const char *key);
|
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 = NULL;
|
||||||
frame_map_handle = NULL;
|
frame_map_handle = NULL;
|
||||||
frame_map_size = 0;
|
frame_map_size = 0;
|
||||||
|
frame_flags = 0;
|
||||||
|
frame_monitor_count = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Producers publish immutable geometry via atomic replacement. Re-check the
|
/* 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_width = load_u32(header + 8);
|
||||||
frame_height = load_u32(header + 12);
|
frame_height = load_u32(header + 12);
|
||||||
frame_stride = load_u32(header + 16);
|
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;
|
frame_slot_bytes = 8ull + (uint64_t)frame_stride * frame_height;
|
||||||
uint64_t expected = UURF_HEADER_BYTES + UURF_SLOT_COUNT * frame_slot_bytes;
|
uint64_t expected = UURF_HEADER_BYTES + UURF_SLOT_COUNT * frame_slot_bytes;
|
||||||
if (frame_width == 0 || frame_height == 0 ||
|
if (frame_width == 0 || frame_height == 0 ||
|
||||||
frame_width > 16384 || frame_height > 16384 ||
|
frame_width > 16384 || frame_height > 16384 ||
|
||||||
|
frame_monitor_count == 0 || frame_monitor_count > UURF_MAX_MONITORS ||
|
||||||
frame_stride != frame_width * 4 ||
|
frame_stride != frame_width * 4 ||
|
||||||
(uint64_t)frame_stride * frame_height > 256ull * 1024 * 1024 ||
|
(uint64_t)frame_stride * frame_height > 256ull * 1024 * 1024 ||
|
||||||
expected > (uint64_t)size.QuadPart) {
|
expected > (uint64_t)size.QuadPart) {
|
||||||
@@ -359,12 +399,515 @@ static int ensure_frame_map(void)
|
|||||||
frame_map_handle = NULL;
|
frame_map_handle = NULL;
|
||||||
return 0;
|
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_size = (size_t)size.QuadPart;
|
||||||
frame_map = view;
|
frame_map = view;
|
||||||
frame_identity = identity;
|
frame_identity = identity;
|
||||||
return 1;
|
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)
|
static BOOL source_is_screen_dc(HDC source)
|
||||||
{
|
{
|
||||||
return GetObjectType(source) == OBJ_DC &&
|
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;
|
screen_width = (int)fw;
|
||||||
if (screen_height < 1)
|
if (screen_height < 1)
|
||||||
screen_height = (int)fh;
|
screen_height = (int)fh;
|
||||||
/* The frame holds exactly one monitor, but the client may ask
|
/* A single-stream frame represents one selected monitor, so a
|
||||||
* for that monitor's whole rectangle. Wine reports the
|
* complete monitor request maps to the whole frame. Composite
|
||||||
* compositor's monitors in its own order, so the virtual desktop
|
* frames already follow the virtual desktop layout and must be
|
||||||
* is only the right basis for a partial request; a complete
|
* cropped by the request's screen coordinates instead. */
|
||||||
* 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. */
|
|
||||||
int sx = 0;
|
int sx = 0;
|
||||||
int sy = 0;
|
int sy = 0;
|
||||||
int sw = 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)
|
? MonitorFromRect(&requested, MONITOR_DEFAULTTONULL)
|
||||||
: NULL;
|
: NULL;
|
||||||
MONITORINFO info;
|
MONITORINFO info;
|
||||||
|
ZeroMemory(&info, sizeof(info));
|
||||||
info.cbSize = sizeof(info);
|
info.cbSize = sizeof(info);
|
||||||
BOOL whole_monitor = FALSE;
|
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 =
|
whole_monitor =
|
||||||
info.rcMonitor.left == requested.left &&
|
info.rcMonitor.left == requested.left &&
|
||||||
info.rcMonitor.top == requested.top &&
|
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.right - info.rcMonitor.left) * fh ==
|
||||||
(int64_t)(info.rcMonitor.bottom - info.rcMonitor.top) * fw;
|
(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;
|
sx = 0;
|
||||||
sy = 0;
|
sy = 0;
|
||||||
sw = (int)fw;
|
sw = (int)fw;
|
||||||
sh = (int)fh;
|
sh = (int)fh;
|
||||||
} else {
|
} else if (!monitor_local_crop) {
|
||||||
sx = (int)((int64_t)source_x * fw / screen_width);
|
int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN);
|
||||||
sy = (int)((int64_t)source_y * fh / screen_height);
|
int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN);
|
||||||
sw = (int)((int64_t)source_width * fw / screen_width);
|
int64_t sx0 = ((int64_t)source_x - screen_left) * fw /
|
||||||
sh = (int)((int64_t)source_height * fh / screen_height);
|
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)
|
if (sw < 1)
|
||||||
sw = (int)fw;
|
sw = (int)fw;
|
||||||
if (sh < 1)
|
if (sh < 1)
|
||||||
sh = (int)fh;
|
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(
|
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,
|
(const void *)frame_snapshot, (const BITMAPINFO *)&bmp_header,
|
||||||
DIB_RGB_COLORS, SRCCOPY);
|
DIB_RGB_COLORS, SRCCOPY);
|
||||||
ok = result != 0 && (DWORD)result != GDI_ERROR;
|
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,
|
BOOL(WINAPI *stretch_blt)(HDC, int, int, int, int, HDC, int, int,
|
||||||
int, int, DWORD);
|
int, int, DWORD);
|
||||||
HRESULT(WINAPI *create_dxgi_factory1)(REFIID, void **);
|
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;
|
} replacement;
|
||||||
FARPROC resolved = original_get_proc_address(module, name);
|
FARPROC resolved = original_get_proc_address(module, name);
|
||||||
if (name == NULL || ((uintptr_t)name >> 16) == 0)
|
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;
|
replacement.create_dxgi_factory1 = hook_create_dxgi_factory1;
|
||||||
return replacement.generic;
|
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;
|
return resolved;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -916,7 +1722,7 @@ UINT WINAPI hook_send_input(UINT count, LPINPUT inputs, int size)
|
|||||||
|
|
||||||
static int patch_module_iat(HMODULE base)
|
static int patch_module_iat(HMODULE base)
|
||||||
{
|
{
|
||||||
if (base == NULL)
|
if (base == NULL || base == hook_module)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER *)base;
|
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) {
|
} else if (lstrcmpiA(name->Name, "GetProcAddress") == 0) {
|
||||||
hook_fn = (void *)hook_get_proc_address;
|
hook_fn = (void *)hook_get_proc_address;
|
||||||
original_slot = (void **)&original_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)
|
if (hook_fn == NULL)
|
||||||
continue;
|
continue;
|
||||||
@@ -1064,11 +1894,21 @@ void uur_hook_version(void) {}
|
|||||||
|
|
||||||
BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
|
BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
|
||||||
{
|
{
|
||||||
(void)instance;
|
|
||||||
(void)reserved;
|
(void)reserved;
|
||||||
if (reason != DLL_PROCESS_ATTACH)
|
if (reason != DLL_PROCESS_ATTACH)
|
||||||
return TRUE;
|
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);
|
DisableThreadLibraryCalls(instance);
|
||||||
if (connect_bridge()) {
|
if (connect_bridge()) {
|
||||||
hook_log("attach: bridge connected");
|
hook_log("attach: bridge connected");
|
||||||
|
|||||||
@@ -15,6 +15,13 @@ command -v makepkg >/dev/null 2>&1 || {
|
|||||||
exit 2
|
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" \
|
sed -e "s|@UUR_VERSION@|$version|g" \
|
||||||
-e "s|@UUR_PROJECT_ROOT@|$project_root|g" \
|
-e "s|@UUR_PROJECT_ROOT@|$project_root|g" \
|
||||||
"$project_root/packaging/arch/PKGBUILD.in" >"$build_dir/PKGBUILD"
|
"$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 backend_handle = backend.clone();
|
||||||
let addr = format!("127.0.0.1:{}", config.bridge_port);
|
let addr = format!("127.0.0.1:{}", config.bridge_port);
|
||||||
let listener = TcpListener::bind(&addr).with_context(|| format!("binding {addr}"))?;
|
let listener = TcpListener::bind(&addr).with_context(|| format!("binding {addr}"))?;
|
||||||
|
listener.set_nonblocking(true)?;
|
||||||
println!("{}", t!("bridge.listening", port = config.bridge_port));
|
println!("{}", t!("bridge.listening", port = config.bridge_port));
|
||||||
|
|
||||||
// The service process hooks itself too, so multiple authenticated
|
// The service process hooks itself too, so multiple authenticated
|
||||||
// connections coexist; each gets its own thread. Injection is
|
// connections coexist; each gets its own thread. Injection is
|
||||||
// serialized through the single backend.
|
// serialized through the single backend.
|
||||||
for stream in listener.incoming() {
|
loop {
|
||||||
let stream = match stream {
|
backend.lock().unwrap().backend.check_health()?;
|
||||||
Ok(s) => s,
|
let stream = match listener.accept() {
|
||||||
Err(_) => continue,
|
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 config = config.clone();
|
||||||
let backend_handle = backend_handle.clone();
|
let backend_handle = backend_handle.clone();
|
||||||
thread::spawn(move || {
|
thread::spawn(move || {
|
||||||
let mut stream = stream;
|
let mut stream = stream;
|
||||||
|
if stream
|
||||||
|
.set_read_timeout(Some(std::time::Duration::from_secs(5)))
|
||||||
|
.is_err()
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
match authenticate(&mut stream, &config) {
|
match authenticate(&mut stream, &config) {
|
||||||
Ok(true) => {}
|
Ok(true) => {}
|
||||||
Ok(false) => return,
|
Ok(false) => return,
|
||||||
Err(_) => return,
|
Err(_) => return,
|
||||||
}
|
}
|
||||||
|
if stream.set_read_timeout(None).is_err() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
use input::InputBackend;
|
use input::InputBackend;
|
||||||
// Read sockets without holding the shared desktop input lock.
|
// Read sockets without holding the shared desktop input lock.
|
||||||
let mut connection = ConnectionInput {
|
let mut connection = ConnectionInput {
|
||||||
@@ -199,7 +222,6 @@ pub fn serve() -> Result<()> {
|
|||||||
let _ = connection.release_all();
|
let _ = connection.release_all();
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
Ok(())
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn authenticate(stream: &mut TcpStream, config: &Config) -> Result<bool> {
|
fn authenticate(stream: &mut TcpStream, config: &Config) -> Result<bool> {
|
||||||
|
|||||||
+137
-28
@@ -1,9 +1,9 @@
|
|||||||
//! Portal side of the capture path.
|
//! Portal side of the capture path.
|
||||||
//!
|
//!
|
||||||
//! Negotiates an xdg-desktop-portal ScreenCast session, obtains a private
|
//! Negotiates an xdg-desktop-portal ScreenCast session, obtains a private
|
||||||
//! PipeWire file descriptor and the video node id, then hands both to the
|
//! PipeWire file descriptor and the consented video nodes, then hands them to
|
||||||
//! C capture helper (`uur-pw-capture`) which runs the PipeWire stream and
|
//! the C capture helper (`uur-pw-capture`) which runs the PipeWire streams and
|
||||||
//! publishes frames into a private XDG runtime file (see
|
//! composites their frames into a private XDG runtime file (see
|
||||||
//! docs/capture-protocol.md).
|
//! docs/capture-protocol.md).
|
||||||
//!
|
//!
|
||||||
//! Consent: the first run shows the compositor's share dialog once. The
|
//! 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;
|
use crate::config::Config;
|
||||||
|
|
||||||
|
const FRAME_PROTOCOL_VERSION: u32 = 3;
|
||||||
|
|
||||||
type PortalSession =
|
type PortalSession =
|
||||||
ashpd::desktop::Session<'static, ashpd::desktop::screencast::Screencast<'static>>;
|
ashpd::desktop::Session<'static, ashpd::desktop::screencast::Screencast<'static>>;
|
||||||
|
|
||||||
struct PortalCapture {
|
struct PortalCapture {
|
||||||
fd: OwnedFd,
|
fd: OwnedFd,
|
||||||
node: u32,
|
streams: Vec<CaptureStream>,
|
||||||
restore_token: Option<String>,
|
restore_token: Option<String>,
|
||||||
session: PortalSession,
|
session: PortalSession,
|
||||||
closed: zbus::proxy::SignalStream<'static>,
|
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.
|
/// Run the capture path until interrupted.
|
||||||
pub fn run_standalone() -> Result<()> {
|
pub fn run_standalone() -> Result<()> {
|
||||||
// Public capture uses the same lifecycle lock as run/setup so stop and
|
// Public capture uses the same lifecycle lock as run/setup so stop and
|
||||||
@@ -93,13 +104,13 @@ pub fn run() -> Result<()> {
|
|||||||
};
|
};
|
||||||
let PortalCapture {
|
let PortalCapture {
|
||||||
fd: pw_fd,
|
fd: pw_fd,
|
||||||
node,
|
streams,
|
||||||
session,
|
session,
|
||||||
mut closed,
|
mut closed,
|
||||||
..
|
..
|
||||||
} = match opened {
|
} = match opened {
|
||||||
Ok(opened) => opened,
|
Ok(opened) => opened,
|
||||||
Err(error) if !initial_session && failures < 3 => {
|
Err(error) if !initial_session && failures < 3 && !user_cancelled(&error) => {
|
||||||
failures += 1;
|
failures += 1;
|
||||||
eprintln!("capture reconnect {failures}/3 failed: {error:#}");
|
eprintln!("capture reconnect {failures}/3 failed: {error:#}");
|
||||||
tokio::select! {
|
tokio::select! {
|
||||||
@@ -110,13 +121,18 @@ pub fn run() -> Result<()> {
|
|||||||
Err(error) => return Err(error),
|
Err(error) => return Err(error),
|
||||||
};
|
};
|
||||||
initial_session = false;
|
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) {
|
match std::fs::remove_file(&frames) {
|
||||||
Ok(()) => {}
|
Ok(()) => {}
|
||||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
|
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
|
||||||
Err(error) => return Err(error).context("retiring the previous capture transport"),
|
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 healthy_since = None;
|
||||||
let mut portal_closed = false;
|
let mut portal_closed = false;
|
||||||
let mut reconfigure = false;
|
let mut reconfigure = false;
|
||||||
@@ -143,6 +159,10 @@ pub fn run() -> Result<()> {
|
|||||||
if has_frame(&frames) && healthy_since.is_none() {
|
if has_frame(&frames) && healthy_since.is_none() {
|
||||||
healthy_since = Some(Instant::now());
|
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()
|
if let Some(status) = helper.0.try_wait()
|
||||||
.context("waiting for capture helper")? {
|
.context("waiting for capture helper")? {
|
||||||
break Some(status);
|
break Some(status);
|
||||||
@@ -175,14 +195,16 @@ pub fn run() -> Result<()> {
|
|||||||
"capture recovery failed repeatedly; restart uur run to share again"
|
"capture recovery failed repeatedly; restart uur run to share again"
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
let status = status.context("capture helper stopped without an exit status")?;
|
if status
|
||||||
if !matches!(status.code(), Some(0 | 75) | None) {
|
.as_ref()
|
||||||
|
.is_some_and(|status| !matches!(status.code(), Some(0 | 75) | None))
|
||||||
|
{
|
||||||
anyhow::bail!(
|
anyhow::bail!(
|
||||||
"{} ({status}); capture recovery stopped",
|
"{} ({status:?}); capture recovery stopped",
|
||||||
t!("capture.helper_failed")
|
t!("capture.helper_failed")
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
eprintln!("capture stream interrupted ({status}); reconnecting {failures}/3");
|
eprintln!("capture stream interrupted ({status:?}); reconnecting {failures}/3");
|
||||||
}
|
}
|
||||||
tokio::select! {
|
tokio::select! {
|
||||||
_ = tokio::time::sleep(Duration::from_secs(1)) => {},
|
_ = 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 connection = zbus::Connection::session().await.ok()?;
|
||||||
let bus = zbus::fdo::DBusProxy::new(&connection).await.ok()?;
|
let bus = zbus::fdo::DBusProxy::new(&connection).await.ok()?;
|
||||||
let name = "org.gnome.Mutter.DisplayConfig".try_into().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()
|
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 {
|
loop {
|
||||||
match changes.as_mut() {
|
match changes.as_mut() {
|
||||||
Some(stream) => {
|
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 {
|
impl Drop for CaptureHelper {
|
||||||
fn drop(&mut self) {
|
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());
|
let field = |offset| u32::from_le_bytes(header[offset..offset + 4].try_into().unwrap());
|
||||||
field(0) == 0x4652_5555
|
field(0) == 0x4652_5555
|
||||||
&& field(4) == 1
|
&& field(4) == FRAME_PROTOCOL_VERSION
|
||||||
&& field(8) > 0
|
&& field(8) > 0
|
||||||
&& field(12) > 0
|
&& field(12) > 0
|
||||||
&& field(16) >= field(8).saturating_mul(4)
|
&& field(16) >= field(8).saturating_mul(4)
|
||||||
&& field(20) == 1
|
&& field(20) == 1
|
||||||
|
&& (1..=16).contains(&field(36))
|
||||||
&& u64::from_le_bytes(header[24..32].try_into().unwrap()) > 0
|
&& 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
|
/// Start the native PipeWire consumer with a portal-owned descriptor. The
|
||||||
/// descriptor remains private to the child and is never reopened by path.
|
/// 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
|
// The helper inherits this descriptor: strip close-on-exec and keep the
|
||||||
// OwnedFd alive across the spawn (closing it would invalidate the number
|
// OwnedFd alive across the spawn (closing it would invalidate the number
|
||||||
// the child receives).
|
// 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 helper = find_helper("uur-pw-capture")?;
|
||||||
let mut command = Command::new(&helper);
|
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
|
command
|
||||||
.env("UUR_PW_FD", raw.to_string())
|
.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()?);
|
.env("UUR_FRAME_PATH", frame_path()?);
|
||||||
if let Ok(debug) = std::env::var("UUR_PW_DEBUG") {
|
if let Ok(debug) = std::env::var("UUR_PW_DEBUG") {
|
||||||
command.env("PIPEWIRE_DEBUG", debug);
|
command.env("PIPEWIRE_DEBUG", debug);
|
||||||
@@ -316,14 +379,14 @@ pub(crate) fn spawn_helper(pw_fd: OwnedFd, node: u32) -> Result<Child> {
|
|||||||
Ok(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") {
|
if let Some(path) = std::env::var_os("UUR_FRAME_PATH") {
|
||||||
return Ok(PathBuf::from(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
|
/// First attempt reuses the stored restore token; if that fails (stale
|
||||||
/// token, monitor changed, compositor restart) fall back to one
|
/// token, monitor changed, compositor restart) fall back to one
|
||||||
/// interactive attempt and store the fresh token.
|
/// interactive attempt and store the fresh token.
|
||||||
@@ -341,15 +404,33 @@ async fn portal_session(config: &mut Config, interactive: bool) -> Result<Portal
|
|||||||
.into_iter()
|
.into_iter()
|
||||||
.chain(interactive.then_some(None))
|
.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) => {
|
Ok(capture) => {
|
||||||
if capture.restore_token != saved_token {
|
if capture.restore_token != saved_token {
|
||||||
config.capture_restore_token = capture.restore_token.clone();
|
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);
|
return Ok(capture);
|
||||||
}
|
}
|
||||||
Err(error) => {
|
Err(error) => {
|
||||||
|
if user_cancelled(&error) {
|
||||||
|
return Err(error);
|
||||||
|
}
|
||||||
last_error = Some(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.
|
/// Choose a cursor mode from the flags the portal advertises.
|
||||||
///
|
///
|
||||||
/// `Embedded` is what the capture path wants (the hook composites the cursor
|
/// `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(
|
async fn negotiate(
|
||||||
screencast: &ashpd::desktop::screencast::Screencast<'static>,
|
screencast: &ashpd::desktop::screencast::Screencast<'static>,
|
||||||
source: ashpd::desktop::screencast::SourceType,
|
source: ashpd::desktop::screencast::SourceType,
|
||||||
|
multiple: bool,
|
||||||
restore_token: Option<&str>,
|
restore_token: Option<&str>,
|
||||||
) -> Result<PortalCapture> {
|
) -> Result<PortalCapture> {
|
||||||
use ashpd::desktop::PersistMode;
|
use ashpd::desktop::PersistMode;
|
||||||
@@ -440,7 +536,7 @@ async fn negotiate(
|
|||||||
&session,
|
&session,
|
||||||
cursor_mode,
|
cursor_mode,
|
||||||
source.into(),
|
source.into(),
|
||||||
false,
|
multiple && matches!(source, ashpd::desktop::screencast::SourceType::Monitor),
|
||||||
restore_token,
|
restore_token,
|
||||||
PersistMode::ExplicitlyRevoked,
|
PersistMode::ExplicitlyRevoked,
|
||||||
)
|
)
|
||||||
@@ -449,9 +545,22 @@ async fn negotiate(
|
|||||||
|
|
||||||
let response = screencast.start(&session, None).await?;
|
let response = screencast.start(&session, None).await?;
|
||||||
let streams_response = response.response()?;
|
let streams_response = response.response()?;
|
||||||
let streams = streams_response.streams();
|
let streams = streams_response
|
||||||
let stream = streams.first().context("no monitor selected")?;
|
.streams()
|
||||||
let node = stream.pipe_wire_node_id();
|
.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 fresh_token = streams_response.restore_token().map(String::from);
|
||||||
|
|
||||||
let fd = screencast
|
let fd = screencast
|
||||||
@@ -460,7 +569,7 @@ async fn negotiate(
|
|||||||
.context("opening the PipeWire remote")?;
|
.context("opening the PipeWire remote")?;
|
||||||
Ok(PortalCapture {
|
Ok(PortalCapture {
|
||||||
fd,
|
fd,
|
||||||
node,
|
streams,
|
||||||
restore_token: fresh_token,
|
restore_token: fresh_token,
|
||||||
session,
|
session,
|
||||||
closed,
|
closed,
|
||||||
|
|||||||
+101
-13
@@ -1,6 +1,10 @@
|
|||||||
use anyhow::{Context, Result};
|
use anyhow::{Context, Result};
|
||||||
use serde::{Deserialize, Serialize};
|
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::path::PathBuf;
|
||||||
|
use std::sync::atomic::{AtomicU64, Ordering};
|
||||||
|
|
||||||
/// Persistent user configuration. Everything lives under the XDG state and
|
/// Persistent user configuration. Everything lives under the XDG state and
|
||||||
/// config directories; the managed Wine prefix lives under data.
|
/// config directories; the managed Wine prefix lives under data.
|
||||||
@@ -24,6 +28,8 @@ pub struct Config {
|
|||||||
pub remote_desktop_restore_token: Option<String>,
|
pub remote_desktop_restore_token: Option<String>,
|
||||||
/// Portal source type: monitor, window, or virtual.
|
/// Portal source type: monitor, window, or virtual.
|
||||||
pub capture_source: String,
|
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.
|
/// "portal" uses system consent; "wayland" is explicitly enabled direct monitor capture.
|
||||||
pub capture_backend: String,
|
pub capture_backend: String,
|
||||||
/// Named Wayland output for direct capture; a single-output session needs no name.
|
/// 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,
|
capture_restore_token: None,
|
||||||
remote_desktop_restore_token: None,
|
remote_desktop_restore_token: None,
|
||||||
capture_source: "monitor".into(),
|
capture_source: "monitor".into(),
|
||||||
|
capture_multiple: false,
|
||||||
capture_backend: "portal".into(),
|
capture_backend: "portal".into(),
|
||||||
capture_output: None,
|
capture_output: None,
|
||||||
strip_lock_mods: Some("auto".into()),
|
strip_lock_mods: Some("auto".into()),
|
||||||
@@ -125,24 +132,104 @@ pub fn runtime_dir() -> Result<PathBuf> {
|
|||||||
impl Config {
|
impl Config {
|
||||||
pub fn load() -> Result<Self> {
|
pub fn load() -> Result<Self> {
|
||||||
let path = config_path()?;
|
let path = config_path()?;
|
||||||
if !path.exists() {
|
match std::fs::read_to_string(&path) {
|
||||||
let config = Self::default();
|
Ok(raw) => toml::from_str(&raw).context("parsing config.toml"),
|
||||||
config.store()?;
|
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Self::update(|_| {}),
|
||||||
return Ok(config);
|
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<()> {
|
pub fn store(&self) -> Result<()> {
|
||||||
let path = config_path()?;
|
let (path, _lock) = Self::write_lock()?;
|
||||||
if let Some(parent) = path.parent() {
|
self.store_locked(&path)
|
||||||
std::fs::create_dir_all(parent)
|
}
|
||||||
.with_context(|| format!("creating {}", parent.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")?;
|
||||||
}
|
}
|
||||||
std::fs::write(&path, toml::to_string_pretty(self)?)
|
let parent = path.parent().context("configuration has no parent")?;
|
||||||
.with_context(|| format!("writing {}", path.display()))
|
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.remote_desktop_restore_token.is_none());
|
||||||
assert!(config.capture_restore_token.is_none());
|
assert!(config.capture_restore_token.is_none());
|
||||||
assert_eq!(config.capture_source, "monitor");
|
assert_eq!(config.capture_source, "monitor");
|
||||||
|
assert!(!config.capture_multiple);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
+3
-2
@@ -374,12 +374,13 @@ pub fn report() -> Result<()> {
|
|||||||
"info",
|
"info",
|
||||||
"capture backend",
|
"capture backend",
|
||||||
&format!(
|
&format!(
|
||||||
"{} ({})",
|
"{} ({}; multiple={})",
|
||||||
configured.capture_backend,
|
configured.capture_backend,
|
||||||
configured
|
configured
|
||||||
.capture_output
|
.capture_output
|
||||||
.as_deref()
|
.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);
|
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`.
|
/// A desktop input sink. Records arrive already normalized by `protocol`.
|
||||||
pub trait InputBackend: Send {
|
pub trait InputBackend: Send {
|
||||||
fn name(&self) -> &'static str;
|
fn name(&self) -> &'static str;
|
||||||
|
fn check_health(&self) -> Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
fn key(&mut self, vkey: u16, down: bool) -> Result<()>;
|
fn key(&mut self, vkey: u16, down: bool) -> Result<()>;
|
||||||
fn button(&mut self, button: u16, down: bool) -> Result<()>;
|
fn button(&mut self, button: u16, down: bool) -> Result<()>;
|
||||||
|
|||||||
+386
-43
@@ -2,11 +2,13 @@ use anyhow::{anyhow, Context, Result};
|
|||||||
use ashpd::desktop::remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop};
|
use ashpd::desktop::remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop};
|
||||||
use ashpd::desktop::screencast::Screencast;
|
use ashpd::desktop::screencast::Screencast;
|
||||||
use ashpd::desktop::PersistMode;
|
use ashpd::desktop::PersistMode;
|
||||||
|
use futures::StreamExt;
|
||||||
use std::collections::HashSet;
|
use std::collections::HashSet;
|
||||||
use std::sync::atomic::{AtomicBool, Ordering};
|
use std::sync::atomic::{AtomicBool, Ordering};
|
||||||
use std::sync::mpsc::{self, SyncSender};
|
use std::sync::mpsc::{self, SyncSender};
|
||||||
use std::sync::{Arc, Mutex};
|
use std::sync::{Arc, Mutex};
|
||||||
use std::time::Duration;
|
use std::time::Duration;
|
||||||
|
use std::time::Instant;
|
||||||
use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
|
use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
|
||||||
|
|
||||||
use super::InputBackend;
|
use super::InputBackend;
|
||||||
@@ -28,15 +30,103 @@ struct Motion {
|
|||||||
y: f64,
|
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.
|
||||||
impl Drop for CaptureGuard {
|
fn absolute_target(
|
||||||
fn drop(&mut self) {
|
streams: &[crate::capture::CaptureStream],
|
||||||
let _ = self.0.kill();
|
x: f64,
|
||||||
let _ = self.0.wait();
|
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")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
use crate::capture::CaptureHelper as CaptureGuard;
|
||||||
|
|
||||||
/// Wayland input through the freedesktop RemoteDesktop portal. The actual
|
/// Wayland input through the freedesktop RemoteDesktop portal. The actual
|
||||||
/// backend can be GNOME, KDE, COSMIC, or any future implementation; uur never
|
/// backend can be GNOME, KDE, COSMIC, or any future implementation; uur never
|
||||||
/// branches on a desktop name.
|
/// branches on a desktop name.
|
||||||
@@ -46,18 +136,21 @@ pub struct PortalBackend {
|
|||||||
motion_queued: Arc<AtomicBool>,
|
motion_queued: Arc<AtomicBool>,
|
||||||
held_keys: HashSet<i32>,
|
held_keys: HashSet<i32>,
|
||||||
held_buttons: HashSet<i32>,
|
held_buttons: HashSet<i32>,
|
||||||
|
failure: Arc<Mutex<Option<String>>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl PortalBackend {
|
impl PortalBackend {
|
||||||
pub fn connect() -> Result<Self> {
|
pub fn connect() -> Result<Self> {
|
||||||
let mut config = crate::config::Config::load()?;
|
let mut config = crate::config::Config::load()?;
|
||||||
let restore_token = config.remote_desktop_restore_token.clone();
|
|
||||||
let (sender, receiver) = unbounded_channel();
|
let (sender, receiver) = unbounded_channel();
|
||||||
let (ready_sender, ready_receiver) = mpsc::sync_channel(1);
|
let (ready_sender, ready_receiver) = mpsc::sync_channel(1);
|
||||||
let pending_motion = Arc::new(Mutex::new(None));
|
let pending_motion = Arc::new(Mutex::new(None));
|
||||||
let motion_queued = Arc::new(AtomicBool::new(false));
|
let motion_queued = Arc::new(AtomicBool::new(false));
|
||||||
let worker_motion = pending_motion.clone();
|
let worker_motion = pending_motion.clone();
|
||||||
let worker_queued = motion_queued.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()
|
std::thread::Builder::new()
|
||||||
.name("uur-portal-input".into())
|
.name("uur-portal-input".into())
|
||||||
@@ -70,12 +163,15 @@ impl PortalBackend {
|
|||||||
runtime.block_on(portal_worker(
|
runtime.block_on(portal_worker(
|
||||||
receiver,
|
receiver,
|
||||||
ready_sender.clone(),
|
ready_sender.clone(),
|
||||||
restore_token,
|
worker_config,
|
||||||
worker_motion,
|
worker_motion,
|
||||||
worker_queued,
|
worker_queued,
|
||||||
|
worker_failure.clone(),
|
||||||
))
|
))
|
||||||
});
|
});
|
||||||
if let Err(error) = result {
|
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()));
|
let _ = ready_sender.send(Err(error.to_string()));
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
@@ -87,7 +183,15 @@ impl PortalBackend {
|
|||||||
.map_err(|error| anyhow!(error))?;
|
.map_err(|error| anyhow!(error))?;
|
||||||
if fresh_token != config.remote_desktop_restore_token {
|
if fresh_token != config.remote_desktop_restore_token {
|
||||||
config.remote_desktop_restore_token = fresh_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 {
|
Ok(Self {
|
||||||
@@ -96,6 +200,7 @@ impl PortalBackend {
|
|||||||
motion_queued,
|
motion_queued,
|
||||||
held_keys: HashSet::new(),
|
held_keys: HashSet::new(),
|
||||||
held_buttons: HashSet::new(),
|
held_buttons: HashSet::new(),
|
||||||
|
failure,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -104,23 +209,125 @@ impl PortalBackend {
|
|||||||
self.sender
|
self.sender
|
||||||
.send(event(reply_sender))
|
.send(event(reply_sender))
|
||||||
.map_err(|_| anyhow!("portal input session closed"))?;
|
.map_err(|_| anyhow!("portal input session closed"))?;
|
||||||
reply_receiver
|
let result = reply_receiver
|
||||||
.recv_timeout(Duration::from_secs(3))
|
.recv_timeout(Duration::from_secs(3))
|
||||||
.context("portal input request timed out")?
|
.context("portal input request timed out")
|
||||||
.map_err(|error| anyhow!(error))
|
.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(
|
async fn portal_worker(
|
||||||
mut receiver: UnboundedReceiver<Event>,
|
receiver: UnboundedReceiver<Event>,
|
||||||
ready: SyncSender<std::result::Result<Option<String>, String>>,
|
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>,
|
restore_token: Option<String>,
|
||||||
pending_motion: Arc<Mutex<Option<Motion>>>,
|
pending_motion: Arc<Mutex<Option<Motion>>>,
|
||||||
motion_queued: Arc<AtomicBool>,
|
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 portal = RemoteDesktop::new().await?;
|
||||||
let screencast = Screencast::new().await?;
|
let screencast = Screencast::new().await?;
|
||||||
let configured = crate::config::Config::load()?;
|
|
||||||
let source = crate::capture::source_type(&configured.capture_source);
|
let source = crate::capture::source_type(&configured.capture_source);
|
||||||
let available = portal.available_device_types().await?;
|
let available = portal.available_device_types().await?;
|
||||||
if !available.contains(DeviceType::Keyboard) || !available.contains(DeviceType::Pointer) {
|
if !available.contains(DeviceType::Keyboard) || !available.contains(DeviceType::Pointer) {
|
||||||
@@ -128,6 +335,18 @@ async fn portal_worker(
|
|||||||
}
|
}
|
||||||
|
|
||||||
let session = portal.create_session().await?;
|
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
|
portal
|
||||||
.select_devices(
|
.select_devices(
|
||||||
&session,
|
&session,
|
||||||
@@ -142,27 +361,110 @@ async fn portal_worker(
|
|||||||
&session,
|
&session,
|
||||||
crate::capture::preferred_cursor_mode(&screencast).await?,
|
crate::capture::preferred_cursor_mode(&screencast).await?,
|
||||||
source.into(),
|
source.into(),
|
||||||
false,
|
configured.capture_multiple && configured.capture_source == "monitor",
|
||||||
None,
|
None,
|
||||||
PersistMode::DoNot,
|
PersistMode::DoNot,
|
||||||
)
|
)
|
||||||
.await?
|
.await?
|
||||||
.response()?;
|
.response()?;
|
||||||
let selection = portal.start(&session, None).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()
|
.streams()
|
||||||
.and_then(|streams| streams.first())
|
.context("RemoteDesktop portal returned no screen streams")?;
|
||||||
.context("RemoteDesktop portal returned no screen stream")?;
|
anyhow::ensure!(
|
||||||
let stream_id = stream.pipe_wire_node_id();
|
!selected_streams.is_empty(),
|
||||||
let (logical_width, logical_height) = stream.size().unwrap_or((65535, 65535));
|
"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 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);
|
let token = selection.restore_token().map(ToOwned::to_owned);
|
||||||
ready
|
*restore_token = token.clone();
|
||||||
.send(Ok(token))
|
if *initial {
|
||||||
.map_err(|_| anyhow!("portal setup receiver closed"))?;
|
ready
|
||||||
|
.send(Ok(token))
|
||||||
while let Some(event) = receiver.recv().await {
|
.map_err(|_| anyhow!("portal setup receiver closed"))?;
|
||||||
|
*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 {
|
match event {
|
||||||
Event::Key(code, down, reply) => {
|
Event::Key(code, down, reply) => {
|
||||||
let result = portal
|
let result = portal
|
||||||
@@ -176,6 +478,9 @@ async fn portal_worker(
|
|||||||
},
|
},
|
||||||
)
|
)
|
||||||
.await;
|
.await;
|
||||||
|
if result.is_ok() {
|
||||||
|
if down { held_keys.insert(code); } else { held_keys.remove(&code); }
|
||||||
|
}
|
||||||
answer(reply, result)?;
|
answer(reply, result)?;
|
||||||
}
|
}
|
||||||
Event::Button(button, down, reply) => {
|
Event::Button(button, down, reply) => {
|
||||||
@@ -190,25 +495,22 @@ async fn portal_worker(
|
|||||||
},
|
},
|
||||||
)
|
)
|
||||||
.await;
|
.await;
|
||||||
|
if result.is_ok() {
|
||||||
|
if down { held_buttons.insert(button); } else { held_buttons.remove(&button); }
|
||||||
|
}
|
||||||
answer(reply, result)?;
|
answer(reply, result)?;
|
||||||
}
|
}
|
||||||
Event::FlushMotion => loop {
|
Event::FlushMotion => {
|
||||||
|
motion_queued.store(false, Ordering::Release);
|
||||||
let motion = pending_motion.lock().unwrap().take();
|
let motion = pending_motion.lock().unwrap().take();
|
||||||
let Some(motion) = motion else {
|
let Some(motion) = motion else {
|
||||||
motion_queued.store(false, Ordering::Release);
|
continue;
|
||||||
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 result = if motion.absolute {
|
||||||
let logical_x = motion.x.clamp(0.0, 65535.0) * logical_width as f64 / 65535.0;
|
let (stream_id, logical_x, logical_y) = match absolute_target(&streams, motion.x, motion.y) {
|
||||||
let logical_y = motion.y.clamp(0.0, 65535.0) * logical_height as f64 / 65535.0;
|
Ok(target) => target,
|
||||||
|
Err(error) => { eprintln!("portal pointer layout not ready: {error}"); continue; }
|
||||||
|
};
|
||||||
portal
|
portal
|
||||||
.notify_pointer_motion_absolute(&session, stream_id, logical_x, logical_y)
|
.notify_pointer_motion_absolute(&session, stream_id, logical_x, logical_y)
|
||||||
.await
|
.await
|
||||||
@@ -229,10 +531,14 @@ async fn portal_worker(
|
|||||||
.await,
|
.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<()> {
|
fn answer<T>(reply: Reply, result: std::result::Result<T, ashpd::Error>) -> Result<()> {
|
||||||
@@ -246,6 +552,14 @@ impl InputBackend for PortalBackend {
|
|||||||
"portal"
|
"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<()> {
|
fn key(&mut self, vkey: u16, down: bool) -> Result<()> {
|
||||||
let code = super::uinput::vk_to_linux_key(vkey) as i32;
|
let code = super::uinput::vk_to_linux_key(vkey) as i32;
|
||||||
if code == 0 {
|
if code == 0 {
|
||||||
@@ -342,7 +656,7 @@ impl Drop for PortalBackend {
|
|||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::{merge_motion, Motion};
|
use super::{absolute_target, merge_motion, Motion};
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn absolute_motion_keeps_only_the_latest_position() {
|
fn absolute_motion_keeps_only_the_latest_position() {
|
||||||
@@ -358,6 +672,35 @@ mod tests {
|
|||||||
};
|
};
|
||||||
merge_motion(&mut pending, latest);
|
merge_motion(&mut pending, latest);
|
||||||
assert_eq!(pending, Some(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]
|
#[test]
|
||||||
|
|||||||
+38
-17
@@ -157,7 +157,12 @@ enum DisplayAction {
|
|||||||
/// Show the configured source type.
|
/// Show the configured source type.
|
||||||
Status,
|
Status,
|
||||||
/// Use a monitor, one window, or a portal-provided virtual display.
|
/// 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.
|
/// Choose portal capture, or explicitly enable direct Wayland monitor capture.
|
||||||
Backend {
|
Backend {
|
||||||
backend: CaptureBackend,
|
backend: CaptureBackend,
|
||||||
@@ -228,29 +233,32 @@ fn main() -> Result<()> {
|
|||||||
if matches!(action, DisplayAction::Outputs) {
|
if matches!(action, DisplayAction::Outputs) {
|
||||||
return capture::list_wayland_outputs();
|
return capture::list_wayland_outputs();
|
||||||
}
|
}
|
||||||
let mut config = config::Config::load()?;
|
let config = config::Config::load()?;
|
||||||
match action {
|
match action {
|
||||||
DisplayAction::Status => {
|
DisplayAction::Status => {
|
||||||
println!("{}", t!("display.status", source = config.capture_source));
|
println!("{}", t!("display.status", source = config.capture_source));
|
||||||
println!("capture backend: {}", config.capture_backend);
|
println!("capture backend: {}", config.capture_backend);
|
||||||
|
println!("multiple monitors: {}", config.capture_multiple);
|
||||||
if let Some(output) = &config.capture_output {
|
if let Some(output) = &config.capture_output {
|
||||||
println!("output: {output}");
|
println!("output: {output}");
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
DisplayAction::Backend { backend, output } => {
|
DisplayAction::Backend { backend, output } => {
|
||||||
config.capture_backend = match backend {
|
let backend = match backend {
|
||||||
CaptureBackend::Portal => "portal",
|
CaptureBackend::Portal => "portal",
|
||||||
CaptureBackend::Wayland => "wayland",
|
CaptureBackend::Wayland => "wayland",
|
||||||
}
|
};
|
||||||
.into();
|
let config = config::Config::update(|stored| {
|
||||||
config.capture_output = output;
|
stored.capture_backend = backend.into();
|
||||||
if config.capture_backend == "wayland" {
|
stored.capture_output = output;
|
||||||
config.capture_source = "monitor".into();
|
if backend == "wayland" {
|
||||||
}
|
stored.capture_source = "monitor".into();
|
||||||
config.capture_restore_token = None;
|
stored.capture_multiple = false;
|
||||||
config.remote_desktop_restore_token = None;
|
}
|
||||||
config.store()?;
|
stored.capture_restore_token = None;
|
||||||
|
stored.remote_desktop_restore_token = None;
|
||||||
|
})?;
|
||||||
println!(
|
println!(
|
||||||
"{}",
|
"{}",
|
||||||
if config.capture_backend == "wayland" {
|
if config.capture_backend == "wayland" {
|
||||||
@@ -262,12 +270,25 @@ fn main() -> Result<()> {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
DisplayAction::Outputs => unreachable!(),
|
DisplayAction::Outputs => unreachable!(),
|
||||||
DisplayAction::Source { source } => {
|
DisplayAction::Source { source, multiple } => {
|
||||||
config.capture_source = source.as_str().to_string();
|
anyhow::ensure!(
|
||||||
config.capture_restore_token = None;
|
!multiple || matches!(&source, DisplaySource::Monitor),
|
||||||
config.remote_desktop_restore_token = None;
|
"--multiple is supported only for monitor sources"
|
||||||
config.store()?;
|
);
|
||||||
|
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!("{}", t!("display.changed", source = source.as_str()));
|
||||||
|
println!(
|
||||||
|
"multiple monitors: {multiple}; selection applies on the next session"
|
||||||
|
);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
+3
-3
@@ -973,7 +973,7 @@ fn process_start_time(pid: u32) -> Result<u64> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn frame_path() -> Result<PathBuf> {
|
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 {
|
fn unix_path_to_wine(path: &Path) -> String {
|
||||||
@@ -1370,8 +1370,8 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn runtime_path_converts_to_a_wine_z_path() {
|
fn runtime_path_converts_to_a_wine_z_path() {
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
unix_path_to_wine(Path::new("/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.v1"
|
r"Z:\run\user\1000\uur\frames.v3"
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Reference in new issue
Block a user