#define _GNU_SOURCE /* * uur-pw-capture — PipeWire ScreenCast consumer. * * Receives an inherited portal PipeWire fd (UUR_PW_FD) and authorized monitor * stream specifications (UUR_PW_STREAMS), composites their BGRx frames and * publishes the virtual desktop into UUR_FRAME_PATH using the seqlock protocol * in docs/capture-protocol.md. * * The shared file is created only after the stream format is negotiated, * because its size depends on the negotiated stride. The uur PE hook maps * it read-only through Wine's Z: drive whenever the client captures. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../hook/frame-protocol.h" #define FRAME_FORMAT_BGRX 1 #ifndef SPA_CHUNK_FLAG_EMPTY #define SPA_CHUNK_FLAG_EMPTY (1u << 1) #endif struct frame_header { uint32_t magic; uint32_t version; uint32_t width; uint32_t height; uint32_t stride; uint32_t format; _Atomic uint64_t total_frames; uint32_t flags; uint32_t monitor_count; _Atomic uint64_t heartbeat_ms; uint8_t reserved[16]; struct uurf_monitor_layout monitors[UURF_MAX_MONITORS]; }; _Static_assert(sizeof(struct frame_header) == UURF_HEADER_BYTES, "frame protocol header size changed"); static uint32_t scale_floor(uint64_t value, uint32_t numerator, uint32_t denominator); static uint64_t scale_ceil(uint64_t value, uint32_t numerator, uint32_t denominator); struct frame_slot { _Atomic uint64_t seq; /* frame bytes follow */ }; struct capture; struct capture_stream { struct capture *capture; struct pw_stream *stream; struct spa_hook listener; uint32_t node_id; int32_t x; int32_t y; int32_t layout_x; int32_t layout_y; uint32_t logical_width; uint32_t logical_height; int provided_logical_size; uint32_t width; uint32_t height; enum spa_video_format format; uint8_t *pixels; size_t pixels_size; int dmabuf_usable; int format_ready; int has_frame; int was_streaming; uint64_t paused_ms; uint64_t counter; }; struct capture { struct pw_main_loop *loop; struct capture_stream streams[16]; uint32_t stream_count; uint32_t width; uint32_t height; uint32_t stride; uint32_t flags; uint64_t counter; uint8_t *composite; size_t composite_size; int32_t layout_x; int32_t layout_y; uint32_t layout_width; uint32_t layout_height; uint32_t scale_num; uint32_t scale_den; int shm_fd; uint8_t *shm; size_t shm_size; int exit_status; volatile sig_atomic_t stopping; uint64_t started_ms; char frame_path[PATH_MAX]; }; static struct capture *active_capture; static uint64_t monotonic_ms(void) { struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); return (uint64_t)now.tv_sec * 1000 + (uint64_t)now.tv_nsec / 1000000; } static void stop_capture(int signal_number) { (void)signal_number; if (active_capture != NULL && active_capture->loop != NULL) { active_capture->stopping = 1; pw_main_loop_quit(active_capture->loop); } } static struct frame_slot *slot_at(struct capture *c, uint64_t n) { size_t slot_bytes = sizeof(struct frame_slot) + (size_t)c->stride * c->height; uint8_t *base = c->shm + uurf_slot_offset(n, slot_bytes); return (struct frame_slot *)base; } static uint8_t *slot_frame(struct frame_slot *slot) { return (uint8_t *)slot + sizeof(struct frame_slot); } static struct uurf_monitor_layout monitor_layout(const struct capture *c, const struct capture_stream *s) { struct uurf_monitor_layout monitor = {0}; monitor.logical_x = s->layout_x; monitor.logical_y = s->layout_y; monitor.logical_width = s->logical_width; monitor.logical_height = s->logical_height; monitor.capture_width = s->width; monitor.capture_height = s->height; if (c->flags == 0) { monitor.frame_width = c->width; monitor.frame_height = c->height; } else { uint64_t left = (uint64_t)((int64_t)s->layout_x - c->layout_x); uint64_t top = (uint64_t)((int64_t)s->layout_y - c->layout_y); uint32_t x0 = scale_floor(left, c->scale_num, c->scale_den); uint32_t y0 = scale_floor(top, c->scale_num, c->scale_den); uint64_t x1 = scale_ceil(left + s->logical_width, c->scale_num, c->scale_den); uint64_t y1 = scale_ceil(top + s->logical_height, c->scale_num, c->scale_den); monitor.frame_x = x0; monitor.frame_y = y0; monitor.frame_width = x1 > x0 ? (uint32_t)(x1 - x0) : 1; monitor.frame_height = y1 > y0 ? (uint32_t)(y1 - y0) : 1; } return monitor; } /* Publish a new inode for every geometry. A Wine reader may still map the * previous inode: never truncate or resize memory another process is reading. */ static int shm_setup(struct capture *c) { size_t slot_bytes = sizeof(struct frame_slot) + (size_t)c->stride * c->height; size_t total = UURF_HEADER_BYTES + UURF_SLOT_COUNT * slot_bytes; if (c->stride == 0 || c->height == 0 || (size_t)c->stride > (SIZE_MAX - UURF_HEADER_BYTES) / c->height / UURF_SLOT_COUNT) { fprintf(stderr, "invalid capture geometry\n"); return -1; } char temporary[PATH_MAX]; if (snprintf(temporary, sizeof(temporary), "%s.XXXXXX", c->frame_path) >= (int)sizeof(temporary)) return -1; int fd = mkostemp(temporary, O_CLOEXEC); if (fd < 0) { perror("open frame transport"); return -1; } if (fchmod(fd, 0600) < 0 || ftruncate(fd, (off_t)total) < 0) { perror("ftruncate"); close(fd); unlink(temporary); return -1; } uint8_t *mapping = mmap(NULL, total, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (mapping == MAP_FAILED) { perror("mmap"); close(fd); unlink(temporary); return -1; } struct frame_header *header = (struct frame_header *)mapping; header->magic = 0x46525555u; /* "UURF" */ header->version = UURF_VERSION; header->width = c->width; header->height = c->height; header->stride = c->stride; header->format = FRAME_FORMAT_BGRX; atomic_init(&header->total_frames, 0); atomic_init(&header->heartbeat_ms, monotonic_ms()); header->flags = c->flags; header->monitor_count = c->stream_count; for (uint32_t i = 0; i < c->stream_count; ++i) { header->monitors[i] = monitor_layout(c, &c->streams[i]); } for (uint32_t i = 0; i < UURF_SLOT_COUNT; ++i) { struct frame_slot *slot = (struct frame_slot *)(mapping + UURF_HEADER_BYTES + i * slot_bytes); atomic_init(&slot->seq, 0); } if (rename(temporary, c->frame_path) < 0) { perror("publish frame transport"); munmap(mapping, total); close(fd); unlink(temporary); return -1; } if (c->shm != NULL) { struct frame_header *previous = (struct frame_header *)c->shm; atomic_store_explicit(&previous->total_frames, 0, memory_order_release); munmap(c->shm, c->shm_size); } if (c->shm_fd >= 0) close(c->shm_fd); c->shm = mapping; c->shm_fd = fd; c->shm_size = total; c->counter = 0; c->started_ms = monotonic_ms(); return 0; } static void publish_frame(struct capture *c) { if (c->shm == NULL || c->composite == NULL) return; c->counter += 1; struct frame_slot *slot = slot_at(c, c->counter); atomic_store_explicit(&slot->seq, 2 * c->counter - 1, memory_order_release); /* writing */ uint8_t *dst = slot_frame(slot); memcpy(dst, c->composite, c->composite_size); atomic_store_explicit(&slot->seq, 2 * c->counter, memory_order_release); struct frame_header *header = (struct frame_header *)c->shm; atomic_store_explicit(&header->total_frames, c->counter, memory_order_release); } static int sync_dmabuf(int fd, uint64_t flags) { struct dma_buf_sync sync = {.flags = flags}; int result; do { result = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); } while (result < 0 && errno == EINTR); return result; } static int all_streams_ready(const struct capture *c) { for (uint32_t i = 0; i < c->stream_count; ++i) { if (!c->streams[i].format_ready) return 0; } return c->stream_count != 0; } static int all_streams_have_frames(const struct capture *c) { for (uint32_t i = 0; i < c->stream_count; ++i) { if (!c->streams[i].has_frame) return 0; } return c->stream_count != 0; } static int ratio_less(uint64_t left_num, uint64_t left_den, uint64_t right_num, uint64_t right_den) { return left_num * right_den < right_num * left_den; } static uint32_t scale_floor(uint64_t value, uint32_t numerator, uint32_t denominator) { return denominator == 0 ? 0 : (uint32_t)(value * numerator / denominator); } static uint64_t scale_ceil(uint64_t value, uint32_t numerator, uint32_t denominator) { return denominator == 0 ? 0 : (value * numerator + denominator - 1) / denominator; } static int configure_layout(struct capture *c) { uint32_t width, height, flags; uint64_t width64, height64; int missing_position = 0; int64_t min_x = INT64_MAX, min_y = INT64_MAX; int64_t max_x = INT64_MIN, max_y = INT64_MIN; uint32_t scale_num = 0, scale_den = 1; if (!all_streams_ready(c)) return 0; for (uint32_t i = 0; i < c->stream_count; ++i) { struct capture_stream *s = &c->streams[i]; if (s->logical_width == 0) s->logical_width = s->width; if (s->logical_height == 0) s->logical_height = s->height; if (s->x == INT32_MIN || s->y == INT32_MIN) missing_position = 1; } if (c->stream_count == 1) { struct capture_stream *s = &c->streams[0]; width64 = s->width; height64 = s->height; flags = 0; s->layout_x = 0; s->layout_y = 0; c->layout_x = 0; c->layout_y = 0; c->layout_width = s->width; c->layout_height = s->height; scale_num = 1; scale_den = 1; } else { int64_t next_x = 0; for (uint32_t i = 0; i < c->stream_count; ++i) { struct capture_stream *s = &c->streams[i]; if (missing_position && (next_x < INT32_MIN || next_x > INT32_MAX)) { fprintf(stderr, "monitor layout position is out of range\n"); return -1; } s->layout_x = missing_position ? (int32_t)next_x : s->x; s->layout_y = missing_position ? 0 : s->y; next_x = (int64_t)s->layout_x + s->logical_width; int64_t right = (int64_t)s->layout_x + s->logical_width; int64_t bottom = (int64_t)s->layout_y + s->logical_height; if (s->layout_x < min_x) min_x = s->layout_x; if (s->layout_y < min_y) min_y = s->layout_y; if (right > max_x) max_x = right; if (bottom > max_y) max_y = bottom; uint64_t ratio_num = s->width; uint64_t ratio_den = s->logical_width; if (ratio_less(s->height, s->logical_height, ratio_num, ratio_den)) { ratio_num = s->height; ratio_den = s->logical_height; } if (scale_num == 0 || ratio_less(ratio_num, ratio_den, scale_num, scale_den)) { scale_num = (uint32_t)ratio_num; scale_den = (uint32_t)ratio_den; } } if (min_x == INT64_MAX || min_y == INT64_MAX || max_x <= min_x || max_y <= min_y || scale_num == 0 || scale_den == 0 || min_x < INT32_MIN || min_x > INT32_MAX || min_y < INT32_MIN || min_y > INT32_MAX || max_x - min_x > UINT32_MAX || max_y - min_y > UINT32_MAX) { fprintf(stderr, "invalid monitor stream layout\n"); return -1; } c->layout_x = (int32_t)min_x; c->layout_y = (int32_t)min_y; c->layout_width = (uint32_t)(max_x - min_x); c->layout_height = (uint32_t)(max_y - min_y); width64 = scale_ceil(c->layout_width, scale_num, scale_den); height64 = scale_ceil(c->layout_height, scale_num, scale_den); flags = UURF_FLAG_COMPOSITE; } if (width64 == 0 || height64 == 0 || width64 > 16384 || height64 > 16384 || width64 * 4 * height64 > 256u * 1024 * 1024) { fprintf(stderr, "composited capture geometry is unsupported\n"); return -1; } width = (uint32_t)width64; height = (uint32_t)height64; int changed = c->width != width || c->height != height || c->flags != flags; c->width = width; c->height = height; c->stride = width * 4; c->flags = flags; c->scale_num = scale_num; c->scale_den = scale_den; if (!changed && c->shm != NULL) { const struct frame_header *previous = (const struct frame_header *)c->shm; for (uint32_t i = 0; i < c->stream_count; ++i) { struct uurf_monitor_layout current = monitor_layout(c, &c->streams[i]); if (memcmp(¤t, &previous->monitors[i], sizeof(current))) { changed = 1; break; } } } if (changed || c->composite == NULL || c->shm == NULL) { size_t bytes = (size_t)c->stride * height; uint8_t *fresh = realloc(c->composite, bytes); if (fresh == NULL) { fprintf(stderr, "could not allocate composited capture frame\n"); return -1; } c->composite = fresh; c->composite_size = bytes; memset(c->composite, 0, bytes); if (shm_setup(c) < 0) return -1; } return 1; } static void compose_frame(struct capture *c) { if (c->composite == NULL || c->width == 0 || c->height == 0) return; if (c->stream_count == 1) { memcpy(c->composite, c->streams[0].pixels, c->composite_size); return; } memset(c->composite, 0, c->composite_size); for (uint32_t i = 0; i < c->stream_count; ++i) { struct capture_stream *s = &c->streams[i]; uint64_t left_logical = (uint64_t)((int64_t)s->layout_x - c->layout_x); uint64_t top_logical = (uint64_t)((int64_t)s->layout_y - c->layout_y); uint32_t left = scale_floor(left_logical, c->scale_num, c->scale_den); uint32_t top = scale_floor(top_logical, c->scale_num, c->scale_den); uint32_t right = scale_ceil(left_logical + s->logical_width, c->scale_num, c->scale_den); uint32_t bottom = scale_ceil(top_logical + s->logical_height, c->scale_num, c->scale_den); uint32_t target_width = right > left ? right - left : 1; uint32_t target_height = bottom > top ? bottom - top : 1; if (left >= c->width || top >= c->height) continue; if (target_width > c->width - left) target_width = c->width - left; if (target_height > c->height - top) target_height = c->height - top; if (target_width == s->width && target_height == s->height) { for (uint32_t row = 0; row < target_height; ++row) { memcpy(c->composite + (size_t)(top + row) * c->stride + (size_t)left * 4, s->pixels + (size_t)row * s->width * 4, (size_t)target_width * 4); } continue; } for (uint32_t row = 0; row < target_height; ++row) { uint32_t source_y = (uint32_t)((uint64_t)row * s->height / target_height); uint8_t *target = c->composite + (size_t)(top + row) * c->stride + (size_t)left * 4; const uint8_t *source = s->pixels + (size_t)source_y * s->width * 4; for (uint32_t column = 0; column < target_width; ++column) { uint32_t source_x = (uint32_t)((uint64_t)column * s->width / target_width); memcpy(target + (size_t)column * 4, source + (size_t)source_x * 4, 4); } } } } static void normalize_pixels(struct capture_stream *s, const uint8_t *pixels, uint32_t source_stride) { uint32_t source_bpp = s->format == SPA_VIDEO_FORMAT_BGR || s->format == SPA_VIDEO_FORMAT_RGB ? 3u : 4u; if (s->format == SPA_VIDEO_FORMAT_BGRx || s->format == SPA_VIDEO_FORMAT_BGRA) { for (uint32_t row = 0; row < s->height; ++row) { memcpy(s->pixels + (size_t)row * s->width * 4, pixels + (size_t)row * source_stride, (size_t)s->width * 4); } return; } for (uint32_t row = 0; row < s->height; ++row) { const uint8_t *source = pixels + (size_t)row * source_stride; uint8_t *target = s->pixels + (size_t)row * s->width * 4; for (uint32_t column = 0; column < s->width; ++column) { int rgb = s->format == SPA_VIDEO_FORMAT_RGBx || s->format == SPA_VIDEO_FORMAT_RGBA || s->format == SPA_VIDEO_FORMAT_RGB; target[column * 4] = source[column * source_bpp + (rgb ? 2 : 0)]; target[column * 4 + 1] = source[column * source_bpp + 1]; target[column * 4 + 2] = source[column * source_bpp + (rgb ? 0 : 2)]; target[column * 4 + 3] = 0; } } } static void on_process(void *userdata) { struct capture_stream *s = userdata; struct capture *c = s->capture; struct pw_buffer *buffer = pw_stream_dequeue_buffer(s->stream); if (buffer == NULL) return; struct spa_buffer *buf = buffer->buffer; if (buf->n_datas >= 1 && s->format_ready && s->pixels != NULL) { struct spa_data *plane = &buf->datas[0]; uint8_t *pixels = NULL; void *mapping = MAP_FAILED; size_t mapping_size = 0; int synchronized = 0; int dmabuf = plane->type == SPA_DATA_DmaBuf; if (plane->chunk == NULL || plane->chunk->stride < 0 || (plane->chunk->flags & (SPA_CHUNK_FLAG_CORRUPTED | SPA_CHUNK_FLAG_EMPTY))) goto done; uint32_t source_bpp = s->format == SPA_VIDEO_FORMAT_BGR || s->format == SPA_VIDEO_FORMAT_RGB ? 3u : 4u; uint32_t row_bytes = s->width * source_bpp; uint32_t stride = plane->chunk->stride > 0 ? (uint32_t)plane->chunk->stride : row_bytes; uint64_t span = (uint64_t)stride * (s->height - 1) + row_bytes; uint32_t data_offset = plane->chunk->offset; if (stride < row_bytes || span > 256u * 1024 * 1024) goto done; if (dmabuf) { if (!s->dmabuf_usable || plane->fd < 0) goto done; off_t extent = lseek((int)plane->fd, 0, SEEK_END); uint64_t end = (uint64_t)plane->mapoffset + data_offset + span; if (extent < 0 || end > (uint64_t)extent) goto done; struct pollfd ready = {.fd = (int)plane->fd, .events = POLLIN}; if (poll(&ready, 1, 100) <= 0 || !(ready.revents & POLLIN) || sync_dmabuf((int)plane->fd, DMA_BUF_SYNC_START | DMA_BUF_SYNC_READ) < 0) goto done; synchronized = 1; } else { if (plane->maxsize == 0) goto done; data_offset %= plane->maxsize; if ((uint64_t)data_offset + span > plane->maxsize || span > plane->chunk->size) goto done; } if (plane->data != NULL) { pixels = (uint8_t *)plane->data + data_offset; } else if ((dmabuf || plane->type == SPA_DATA_MemFd) && plane->fd >= 0) { long page_size = sysconf(_SC_PAGESIZE); uint64_t offset = (uint64_t)plane->mapoffset + data_offset; uint64_t page_mask = (uint64_t)(page_size > 0 ? page_size : 4096) - 1; off_t aligned = (off_t)(offset & ~page_mask); size_t delta = (size_t)(offset - (uint64_t)aligned); mapping_size = delta + (size_t)span; mapping = mmap(NULL, mapping_size, PROT_READ, MAP_SHARED, plane->fd, aligned); if (mapping != MAP_FAILED) pixels = (uint8_t *)mapping + delta; } if (pixels != NULL) { if (s->counter == 0) fprintf(stderr, "stream %u buffer: %s, source stride %u, chunk offset %u\n", s->node_id, dmabuf ? "linear DMA-BUF" : "shared memory", stride, data_offset); normalize_pixels(s, pixels, stride); s->counter++; s->has_frame = 1; if (c->shm != NULL && all_streams_have_frames(c)) { compose_frame(c); publish_frame(c); } } done: if (synchronized) (void)sync_dmabuf((int)plane->fd, DMA_BUF_SYNC_END | DMA_BUF_SYNC_READ); if (mapping != MAP_FAILED) munmap(mapping, mapping_size); } pw_stream_queue_buffer(s->stream, buffer); } static void on_param_changed(void *userdata, uint32_t id, const struct spa_pod *param) { struct capture_stream *s = userdata; struct capture *c = s->capture; if (param == NULL || id != SPA_PARAM_Format) return; struct spa_video_info_raw info = {0}; if (spa_format_video_raw_parse(param, &info) < 0) return; if (info.format != SPA_VIDEO_FORMAT_BGRx && info.format != SPA_VIDEO_FORMAT_BGRA && info.format != SPA_VIDEO_FORMAT_RGBx && info.format != SPA_VIDEO_FORMAT_RGBA && info.format != SPA_VIDEO_FORMAT_BGR && info.format != SPA_VIDEO_FORMAT_RGB) { fprintf(stderr, "stream %u negotiated unexpected format %d\n", s->node_id, info.format); return; } if (info.size.width == 0 || info.size.height == 0 || info.size.width > 16384 || info.size.height > 16384 || (uint64_t)info.size.width * 4 * info.size.height > 256u * 1024 * 1024) { fprintf(stderr, "stream %u has unsupported capture geometry\n", s->node_id); c->exit_status = 1; pw_main_loop_quit(c->loop); return; } int changed = !s->format_ready || s->width != info.size.width || s->height != info.size.height || s->format != info.format; s->width = (uint32_t)info.size.width; s->height = (uint32_t)info.size.height; if (!s->provided_logical_size) { s->logical_width = s->width; s->logical_height = s->height; } s->format = info.format; /* The DMA-BUF path mmaps the fd directly, which is only correct for a * linear layout. A tiled modifier needs a real importer (GBM/EGL), so * refuse to publish garbage rather than emit a corrupt frame. */ s->dmabuf_usable = spa_pod_find_prop(param, NULL, SPA_FORMAT_VIDEO_modifier) != NULL && info.modifier == DRM_FORMAT_MOD_LINEAR; if (changed) { size_t bytes = (size_t)s->width * s->height * 4; size_t source_total = bytes; for (uint32_t i = 0; i < c->stream_count; ++i) { if (&c->streams[i] != s) source_total += c->streams[i].pixels_size; } if (source_total > 512u * 1024 * 1024) { fprintf(stderr, "monitor source buffers exceed the memory limit\n"); c->exit_status = 1; pw_main_loop_quit(c->loop); return; } uint8_t *fresh = realloc(s->pixels, bytes); if (fresh == NULL) { fprintf(stderr, "could not allocate stream %u frame buffer\n", s->node_id); c->exit_status = 1; pw_main_loop_quit(c->loop); return; } s->pixels = fresh; s->pixels_size = bytes; memset(s->pixels, 0, bytes); s->has_frame = 0; } s->format_ready = 1; fprintf(stderr, "stream %u negotiated: %ux%u modifier %#llx%s\n", s->node_id, s->width, s->height, (unsigned long long)info.modifier, s->dmabuf_usable ? "" : " (DMA-BUF CPU mapping disabled)"); int layout = configure_layout(c); if (layout < 0) { c->exit_status = 1; pw_main_loop_quit(c->loop); } else if (layout > 0 && all_streams_have_frames(c)) { compose_frame(c); publish_frame(c); } } static void on_state_changed(void *userdata, enum pw_stream_state old, enum pw_stream_state state, const char *error) { struct capture_stream *s = userdata; struct capture *c = s->capture; fprintf(stderr, "stream %u state: %s%s%s\n", s->node_id, pw_stream_state_as_string(state), error != NULL && error[0] != '\0' ? " - " : "", error != NULL ? error : ""); if (c->stopping) return; if (state == PW_STREAM_STATE_STREAMING) { s->was_streaming = 1; s->paused_ms = 0; } else if (state == PW_STREAM_STATE_PAUSED && s->was_streaming) { if (s->paused_ms == 0) s->paused_ms = monotonic_ms(); } else if (state == PW_STREAM_STATE_ERROR || (state == PW_STREAM_STATE_UNCONNECTED && old != state)) { c->exit_status = 75; pw_main_loop_quit(c->loop); } } static void on_watchdog(void *userdata, uint64_t expirations) { struct capture *c = userdata; (void)expirations; uint64_t now = monotonic_ms(); if (c->shm != NULL) atomic_store_explicit(&((struct frame_header *)c->shm)->heartbeat_ms, now, memory_order_release); for (uint32_t i = 0; i < c->stream_count; ++i) { struct capture_stream *s = &c->streams[i]; if (!c->stopping && ((s->paused_ms != 0 && now - s->paused_ms >= 10000) || (!s->has_frame && now - c->started_ms >= 30000))) { fprintf(stderr, "stream %u stopped producing usable frames; reconnecting\n", s->node_id); c->exit_status = 75; pw_main_loop_quit(c->loop); return; } } } static void on_core_error(void *userdata, uint32_t id, int sequence, int result, const char *message) { struct capture *c = userdata; (void)sequence; if (!c->stopping && id == PW_ID_CORE && result < 0) { fprintf(stderr, "PipeWire connection failed: %s\n", message); c->exit_status = 75; pw_main_loop_quit(c->loop); } } static const struct pw_core_events core_events = { PW_VERSION_CORE_EVENTS, .error = on_core_error, }; static const struct pw_stream_events stream_events = { .version = PW_VERSION_STREAM_EVENTS, .process = on_process, .param_changed = on_param_changed, .state_changed = on_state_changed, }; static const struct spa_pod *capture_format(struct spa_pod_builder *builder, int dmabuf) { struct spa_pod_frame frame; spa_pod_builder_push_object(builder, &frame, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat); spa_pod_builder_add(builder, SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video), SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw), SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(6, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_BGRA, SPA_VIDEO_FORMAT_RGBx, SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_BGR, SPA_VIDEO_FORMAT_RGB), 0); if (dmabuf) { spa_pod_builder_prop(builder, SPA_FORMAT_VIDEO_modifier, SPA_POD_PROP_FLAG_MANDATORY); spa_pod_builder_long(builder, DRM_FORMAT_MOD_LINEAR); } return spa_pod_builder_pop(builder, &frame); } static int parse_stream_specs(struct capture *c, const char *text) { char *copy = strdup(text); if (copy == NULL) return -1; char *save = NULL; char *item = strtok_r(copy, ";", &save); while (item != NULL) { unsigned node, width, height; int x, y; if (c->stream_count >= sizeof(c->streams) / sizeof(c->streams[0]) || sscanf(item, "%u,%d,%d,%u,%u", &node, &x, &y, &width, &height) != 5) { free(copy); return -1; } struct capture_stream *s = &c->streams[c->stream_count++]; s->node_id = node; s->x = x; s->y = y; s->logical_width = width; s->logical_height = height; s->provided_logical_size = width != 0 && height != 0; item = strtok_r(NULL, ";", &save); } free(copy); return c->stream_count == 0 ? -1 : 0; } int main(void) { const char *fd_text = getenv("UUR_PW_FD"); const char *spec_text = getenv("UUR_PW_STREAMS"); const char *legacy_node = getenv("UUR_PW_NODE"); const char *frame_path = getenv("UUR_FRAME_PATH"); if (fd_text == NULL || frame_path == NULL || frame_path[0] != '/' || strlen(frame_path) >= PATH_MAX) { fprintf(stderr, "UUR_PW_FD and an absolute UUR_FRAME_PATH are required\n"); return 2; } int pw_fd = atoi(fd_text); struct capture c; memset(&c, 0, sizeof(c)); c.shm_fd = -1; if (spec_text != NULL) { if (parse_stream_specs(&c, spec_text) < 0) { fprintf(stderr, "invalid UUR_PW_STREAMS specification\n"); return 2; } } else if (legacy_node != NULL) { char *end = NULL; errno = 0; unsigned long node = strtoul(legacy_node, &end, 10); if (errno != 0 || end == legacy_node || *end != '\0' || node > UINT32_MAX) { fprintf(stderr, "invalid UUR_PW_NODE\n"); return 2; } c.stream_count = 1; c.streams[0].node_id = (uint32_t)node; c.streams[0].x = INT32_MIN; c.streams[0].y = INT32_MIN; } else { fprintf(stderr, "UUR_PW_STREAMS must be set by uur\n"); return 2; } memcpy(c.frame_path, frame_path, strlen(frame_path) + 1); fprintf(stderr, "capturing %u ScreenCast stream(s)\n", c.stream_count); pw_init(NULL, NULL); active_capture = &c; signal(SIGINT, stop_capture); signal(SIGTERM, stop_capture); signal(SIGHUP, stop_capture); struct pw_main_loop *loop = pw_main_loop_new(NULL); if (loop == NULL) { fprintf(stderr, "pw_main_loop_new failed\n"); return 1; } c.loop = loop; struct pw_context *context = pw_context_new(pw_main_loop_get_loop(loop), NULL, 0); if (context == NULL) { fprintf(stderr, "pw_context_new failed\n"); return 1; } /* The portal fd only exposes streams covered by this ScreenCast consent. */ struct pw_core *core = pw_context_connect_fd(context, pw_fd, NULL, 0); if (core == NULL) { fprintf(stderr, "pw_context_connect_fd failed\n"); return 1; } struct spa_hook core_listener; pw_core_add_listener(core, &core_listener, &core_events, &c); struct spa_source *watchdog = NULL; uint8_t pod_buffer[1024]; struct spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(pod_buffer, sizeof(pod_buffer)); const struct spa_pod *params[2]; params[0] = capture_format(&pod_builder, 1); params[1] = capture_format(&pod_builder, 0); c.started_ms = monotonic_ms(); for (uint32_t i = 0; i < c.stream_count; ++i) { struct capture_stream *s = &c.streams[i]; s->capture = &c; char name[64]; snprintf(name, sizeof(name), "uur-capture-%u", i + 1); struct pw_properties *props = pw_properties_new( PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Screen", NULL); s->stream = pw_stream_new(core, name, props); if (s->stream == NULL) { fprintf(stderr, "pw_stream_new failed for node %u\n", s->node_id); c.exit_status = 1; goto cleanup; } pw_stream_add_listener(s->stream, &s->listener, &stream_events, s); if (pw_stream_connect(s->stream, PW_DIRECTION_INPUT, s->node_id, PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_AUTOCONNECT, params, 2) < 0) { fprintf(stderr, "pw_stream_connect failed for node %u\n", s->node_id); c.exit_status = 1; goto cleanup; } } watchdog = pw_loop_add_timer(pw_main_loop_get_loop(loop), on_watchdog, &c); struct timespec interval = {.tv_sec = 1}; if (watchdog == NULL || pw_loop_update_timer(pw_main_loop_get_loop(loop), watchdog, &interval, &interval, false) < 0) { fprintf(stderr, "could not start capture watchdog\n"); c.exit_status = 1; goto cleanup; } pw_main_loop_run(loop); c.stopping = 1; active_capture = NULL; cleanup: c.stopping = 1; active_capture = NULL; if (watchdog != NULL) pw_loop_destroy_source(pw_main_loop_get_loop(loop), watchdog); for (uint32_t i = 0; i < c.stream_count; ++i) { struct capture_stream *s = &c.streams[i]; if (s->stream != NULL) { pw_stream_destroy(s->stream); spa_hook_remove(&s->listener); } free(s->pixels); } spa_hook_remove(&core_listener); pw_core_disconnect(core); pw_context_destroy(context); pw_main_loop_destroy(loop); if (c.shm != NULL) { struct frame_header *header = (struct frame_header *)c.shm; atomic_store_explicit(&header->total_frames, 0, memory_order_release); munmap(c.shm, c.shm_size); } if (c.shm_fd >= 0) close(c.shm_fd); free(c.composite); unlink(c.frame_path); pw_deinit(); return c.exit_status; }