WIP: src/mirror/target: add generic target system (still partially hacked)

Author: Ferdi265

include/wlm/mirror.h

@@ -8,6 +8,7 @@
 #include <EGL/egl.h>
 #include <wlm/transform.h>
 #include <wlm/mirror/backends.h>
+#include <wlm/mirror/target.h>
 
 struct ctx;
 struct output_list_node;
@@ -19,7 +20,7 @@ struct fallback_backend {
 };
 
 typedef struct ctx_mirror {
-    struct output_list_node * current_target;
+    wlm_mirror_target_t * current_target;
     struct wl_callback * frame_callback;
     region_t current_region;
     bool invert_y;

include/wlm/mirror/extcopy.h

@@ -19,7 +19,6 @@ typedef struct {
     mirror_backend_t header;
     bool use_dmabuf;
 
-    struct ext_image_capture_source_v1 * capture_source;
     struct ext_image_copy_capture_session_v1 * capture_session;
     struct ext_image_copy_capture_frame_v1 * capture_frame;
 

include/wlm/mirror/target.h

@@ -0,0 +1,44 @@
+#ifndef WLM_MIRROR_TARGET_H_
+#define WLM_MIRROR_TARGET_H_
+
+#include <wayland-client-protocol.h>
+#include <wlm/wayland.h>
+
+typedef struct ctx ctx_t;
+
+typedef enum {
+    WLM_MIRROR_TARGET_TYPE_NULL = 0,
+    WLM_MIRROR_TARGET_TYPE_OUTPUT,
+    WLM_MIRROR_TARGET_TYPE_TOPLEVEL,
+} wlm_mirror_target_type_t;
+
+typedef struct {
+    wlm_mirror_target_type_t type;
+    struct ext_image_capture_source_v1 * source;
+    enum wl_output_transform transform;
+} wlm_mirror_target_t;
+
+typedef struct {
+    wlm_mirror_target_t header;
+    output_list_node_t * output;
+} wlm_mirror_target_output_t;
+
+typedef struct {
+    wlm_mirror_target_t header;
+    struct ext_foreign_toplevel_handle_v1 * toplevel;
+} wlm_mirror_target_toplevel_t;
+
+wlm_mirror_target_t * wlm_mirror_target_parse(ctx_t * ctx, const char * target);
+wlm_mirror_target_t * wlm_mirror_target_find_output(ctx_t * ctx, const char * name);
+wlm_mirror_target_t * wlm_mirror_target_find_toplevel(ctx_t * ctx, const char * identifier);
+
+// TODO: remove this
+wlm_mirror_target_t * wlm_mirror_target_create_output(ctx_t * ctx, output_list_node_t * output_node);
+
+output_list_node_t * wlm_mirror_target_get_output_node(wlm_mirror_target_t * target);
+struct ext_image_capture_source_v1 * wlm_mirror_target_get_capture_source(wlm_mirror_target_t * target);
+enum wl_output_transform wlm_mirror_target_get_transform(wlm_mirror_target_t * target);
+
+void wlm_mirror_target_destroy(wlm_mirror_target_t * target);
+
+#endif

include/wlm/wayland.h

@@ -12,6 +12,7 @@
 #include <wlm/proto/wlr-screencopy-unstable-v1.h>
 #include <wlm/proto/ext-image-copy-capture-v1.h>
 #include <wlm/proto/ext-image-capture-source-v1.h>
+#include <wlm/proto/ext-foreign-toplevel-list-v1.h>
 #include <wlm/proto/linux-dmabuf-unstable-v1.h>
 #include <wlm/wayland/shm.h>
 #include <wlm/wayland/dmabuf.h>
@@ -26,6 +27,9 @@ typedef struct output_list_node {
     struct output_list_node * next;
     struct ctx * ctx;
     char * name;
+    char * make;
+    char * model;
+    char * description;
     struct wl_output * output;
     struct zxdg_output_v1 * xdg_output;
     uint32_t output_id;
@@ -129,6 +133,7 @@ void wlm_wayland_window_set_title(struct ctx * ctx, const char * title);
 void wlm_wayland_window_set_fullscreen(struct ctx * ctx);
 void wlm_wayland_window_unset_fullscreen(struct ctx * ctx);
 void wlm_wayland_window_update_scale(struct ctx * ctx, double scale, bool is_fractional);
+bool wlm_wayland_find_output(ctx_t * ctx, const char * output_name, output_list_node_t ** output);
 void wlm_wayland_cleanup(struct ctx * ctx);
 
 #endif

src/egl.c

@@ -1,3 +1,4 @@
+#include "wlm/mirror/target.h"
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <EGL/egl.h>
@@ -422,13 +423,17 @@ void wlm_egl_resize_viewport(ctx_t * ctx) {
 
     // rotate texture dimensions by output transform
     if (ctx->egl.texture_initialized) {
-        wlm_util_viewport_apply_output_transform(&tex_width, &tex_height, ctx->mirror.current_target->transform);
+        enum wl_output_transform transform = wlm_mirror_target_get_transform(ctx->mirror.current_target);
+        wlm_util_viewport_apply_output_transform(&tex_width, &tex_height, transform);
     }
 
     // clamp texture dimensions to specified region
     region_t output_region;
     region_t clamp_region;
     if (ctx->egl.texture_initialized && ctx->opt.has_region && !ctx->egl.texture_region_aware) {
+        // TODO: handle output regions differently
+        // TODO: allow specifying regions relative to recording target
+
         output_region = (region_t){
             .x = 0, .y = 0,
             .width = tex_width, .height = tex_height
@@ -437,7 +442,12 @@ void wlm_egl_resize_viewport(ctx_t * ctx) {
 
         // HACK: calculate effective output fractional scale
         // wayland doesn't provide this information
-        double output_scale = (double)tex_width / ctx->mirror.current_target->width;
+        // TODO: figure out how to deal with this without hardcoding output targets
+        double output_scale = 1;
+        output_list_node_t * output_node = wlm_mirror_target_get_output_node(ctx->mirror.current_target);
+        if (output_node != NULL) {
+            output_scale = (double)tex_width / output_node->width;
+        }
         wlm_util_region_scale(&clamp_region, output_scale);
         wlm_util_region_clamp(&clamp_region, &output_region);
 
@@ -510,7 +520,8 @@ void wlm_egl_resize_viewport(ctx_t * ctx) {
             wlm_util_mat3_apply_region_transform(&texture_transform, &clamp_region, &output_region);
         }
 
-        wlm_util_mat3_apply_output_transform(&texture_transform, ctx->mirror.current_target->transform);
+        enum wl_output_transform transform = wlm_mirror_target_get_transform(ctx->mirror.current_target);
+        wlm_util_mat3_apply_output_transform(&texture_transform, transform);
         wlm_util_mat3_apply_invert_y(&texture_transform, ctx->mirror.invert_y);
     }
 

src/mirror.c

@@ -74,11 +74,16 @@ void wlm_mirror_init(ctx_t * ctx) {
 
     ctx->mirror.initialized = true;
 
+    // TODO: use wlm_mirror_target_parse
+    // TODO: make wlm_mirror_target_parse implement finding output (or toplevel?) by region
+    // TODO: only find and create target in a single place! (other place is opt parse)
     // finding target output
-    if (!wlm_opt_find_output(ctx, &ctx->mirror.current_target, &ctx->mirror.current_region)) {
+    output_list_node_t * target_output = NULL;
+    if (!wlm_opt_find_output(ctx, &target_output, &ctx->mirror.current_region)) {
         wlm_log_error("mirror::init(): failed to find output\n");
         wlm_exit_fail(ctx);
     }
+    ctx->mirror.current_target = wlm_mirror_target_create_output(ctx, target_output);
 
     // update window title
     wlm_mirror_update_title(ctx);
@@ -201,7 +206,7 @@ void wlm_mirror_backend_init(ctx_t * ctx) {
 void wlm_mirror_output_removed(ctx_t * ctx, output_list_node_t * node) {
     if (!ctx->mirror.initialized) return;
     if (ctx->mirror.current_target == NULL) return;
-    if (ctx->mirror.current_target != node) return;
+    if (wlm_mirror_target_get_output_node(ctx->mirror.current_target) != node) return;
 
     wlm_log_error("mirror::output_removed(): output disappeared, closing\n");
     wlm_exit_fail(ctx);
@@ -228,14 +233,26 @@ static size_t specifier_str(ctx_t * ctx, char *dst, int n, specifier_t specifier
 }
 
 static int format_title(ctx_t * ctx, char ** dst, char * fmt) {
+    uint32_t target_width = 0;
+    uint32_t target_height = 0;
+    const char * target_name = "";
+
+    // TODO: support for other target types
+    output_list_node_t * output_node = wlm_mirror_target_get_output_node(ctx->mirror.current_target);
+    if (output_node != NULL) {
+        target_width = output_node->width;
+        target_height = output_node->height;
+        target_name = output_node->name;
+    }
+
     specifier_t replacements[] = {
         {"{x}", 'd', {.d = ctx->mirror.current_region.x}},
         {"{y}", 'd', {.d = ctx->mirror.current_region.y}},
         {"{width}", 'd', {.d = ctx->mirror.current_region.width}},
         {"{height}", 'd', {.d = ctx->mirror.current_region.height}},
-        {"{target_width}", 'd', {.d = ctx->mirror.current_target->width}},
-        {"{target_height}", 'd', {.d = ctx->mirror.current_target->height}},
-        {"{target_output}", 's', {.s = ctx->mirror.current_target->name}}
+        {"{target_width}", 'd', {.d = target_width}},
+        {"{target_height}", 'd', {.d = target_height}},
+        {"{target_output}", 's', {.s = target_name}}
     };
 
     size_t length = strlen(fmt);
@@ -321,6 +338,7 @@ void wlm_mirror_cleanup(ctx_t * ctx) {
 
     wlm_log_debug(ctx, "mirror::cleanup(): destroying mirror objects\n");
 
+    if (ctx->mirror.current_target != NULL) wlm_mirror_target_destroy(ctx->mirror.current_target);
     if (ctx->mirror.backend != NULL) ctx->mirror.backend->do_cleanup(ctx);
     if (ctx->mirror.frame_callback != NULL) wl_callback_destroy(ctx->mirror.frame_callback);
 

src/mirror/export-dmabuf.c

@@ -248,9 +248,17 @@ static void do_capture(ctx_t * ctx) {
         backend->state = STATE_WAIT_FRAME;
         backend->processed_objects = 0;
 
+        // check if target is supported
+        output_list_node_t * output_node = wlm_mirror_target_get_output_node(ctx->mirror.current_target);
+        if (output_node == NULL) {
+            wlm_log_error("mirror-export-dmabuf::do_capture(): capture target not supported by this backend\n");
+            wlm_mirror_backend_fail(ctx);
+            return;
+        }
+
         // create wlr_dmabuf_export_frame
         backend->dmabuf_frame = zwlr_export_dmabuf_manager_v1_capture_output(
-            ctx->wl.dmabuf_manager, ctx->opt.show_cursor, ctx->mirror.current_target->output
+            ctx->wl.dmabuf_manager, ctx->opt.show_cursor, output_node->output
         );
         if (backend->dmabuf_frame == NULL) {
             wlm_log_error("mirror-export-dmabuf::do_capture(): failed to create wlr_dmabuf_export_frame\n");

src/mirror/extcopy.c

@@ -1,3 +1,4 @@
+#include "wlm/mirror/target.h"
 #include <wlm/mirror/extcopy.h>
 #include <wlm/context.h>
 #include <wlm/wayland/shm.h>
@@ -28,12 +29,10 @@ static void extcopy_session_cleanup(ctx_t * ctx, extcopy_mirror_backend_t * back
     extcopy_frame_cleanup(backend);
 
     if (backend->capture_session != NULL) ext_image_copy_capture_session_v1_destroy(backend->capture_session);
-    if (backend->capture_source != NULL) ext_image_capture_source_v1_destroy(backend->capture_source);
     if (wlm_wayland_dmabuf_get_buffer(ctx) != NULL) wlm_wayland_dmabuf_dealloc(ctx);
     if (wlm_wayland_shm_get_buffer(ctx) != NULL) wlm_wayland_shm_dealloc(ctx);
 
     backend->capture_session = NULL;
-    backend->capture_source = NULL;
 }
 
 static void backend_cancel(ctx_t * ctx, extcopy_mirror_backend_t * backend) {
@@ -354,11 +353,17 @@ static void do_capture(ctx_t * ctx) {
     extcopy_mirror_backend_t * backend = (extcopy_mirror_backend_t *)ctx->mirror.backend;
 
     if (backend->state == STATE_INIT || backend->state == STATE_CANCELED) {
-        backend->capture_source = ext_output_image_capture_source_manager_v1_create_source(ctx->wl.output_capture_source_manager, ctx->mirror.current_target->output);
+        // check if target is supported
+        struct ext_image_capture_source_v1 * capture_source = wlm_mirror_target_get_capture_source(ctx->mirror.current_target);
+        if (capture_source == NULL) {
+            wlm_log_error("mirror-extcopy::do_capture(): capture target not supported by this backend\n");
+            wlm_mirror_backend_fail(ctx);
+            return;
+        }
 
         wlm_log_debug(ctx, "mirror-extcopy::do_capture(): creating capture session\n");
         backend->state = STATE_WAIT_BUFFER_INFO;
-        backend->capture_session = ext_image_copy_capture_manager_v1_create_session(ctx->wl.copy_capture_manager, backend->capture_source, ctx->opt.show_cursor ? EXT_IMAGE_COPY_CAPTURE_MANAGER_V1_OPTIONS_PAINT_CURSORS : 0);
+        backend->capture_session = ext_image_copy_capture_manager_v1_create_session(ctx->wl.copy_capture_manager, capture_source, ctx->opt.show_cursor ? EXT_IMAGE_COPY_CAPTURE_MANAGER_V1_OPTIONS_PAINT_CURSORS : 0);
         ext_image_copy_capture_session_v1_add_listener(backend->capture_session, &capture_session_listener, (void *)ctx);
     } else if (backend->state == STATE_READY) {
         if (backend->capture_frame != NULL) {
@@ -438,7 +443,6 @@ static void wlm_mirror_extcopy_init(ctx_t * ctx, bool use_dmabuf) {
     backend->header.fail_count = 0;
     backend->use_dmabuf = use_dmabuf;
 
-    backend->capture_source = NULL;
     backend->capture_session = NULL;
     backend->capture_frame = NULL;
 

src/mirror/screencopy.c

@@ -281,18 +281,26 @@ static void do_capture(ctx_t * ctx) {
         backend->frame_flags = 0;
         backend->state = STATE_WAIT_BUFFER;
 
+        // check if target is supported
+        output_list_node_t * output_node = wlm_mirror_target_get_output_node(ctx->mirror.current_target);
+        if (output_node == NULL) {
+            wlm_log_error("mirror-screencopy::do_capture(): capture target not supported by this backend\n");
+            wlm_mirror_backend_fail(ctx);
+            return;
+        }
+
         // create screencopy_frame
         if (ctx->opt.has_region) {
             backend->screencopy_frame = zwlr_screencopy_manager_v1_capture_output_region(
-                ctx->wl.screencopy_manager, ctx->opt.show_cursor, ctx->mirror.current_target->output,
-                ctx->mirror.current_target->x + ctx->mirror.current_region.x,
-                ctx->mirror.current_target->y + ctx->mirror.current_region.y,
+                ctx->wl.screencopy_manager, ctx->opt.show_cursor, output_node->output,
+                output_node->x + ctx->mirror.current_region.x,
+                output_node->y + ctx->mirror.current_region.y,
                 ctx->mirror.current_region.width,
                 ctx->mirror.current_region.height
             );
         } else {
             backend->screencopy_frame = zwlr_screencopy_manager_v1_capture_output(
-                ctx->wl.screencopy_manager, ctx->opt.show_cursor, ctx->mirror.current_target->output
+                ctx->wl.screencopy_manager, ctx->opt.show_cursor, output_node->output
             );
         }
         if (backend->screencopy_frame == NULL) {