Fix region capture on hyprland with multiple monitors

.gitignore

@@ -4,8 +4,8 @@ compile_commands.json
 tests/sibs-build/
 tests/compile_commands.json
 
-external/wlr-export-dmabuf-unstable-v1-client-protocol.h
+**/xdg-output-unstable-v1-client-protocol.h
-external/wlr-export-dmabuf-unstable-v1-protocol.c
+**/xdg-output-unstable-v1-protocol.c
 
 .clangd/
 .cache/

README.md

@@ -87,6 +87,7 @@ These are the dependencies needed to build GPU Screen Recorder:
 * libcap
 * wayland-client
 * wayland-egl
+* wayland-scanner
 
 ## Runtime dependencies
 There are also additional dependencies needed at runtime depending on your GPU vendor:

TODO

@@ -260,4 +260,4 @@ External texture doesn't work on nvidia x11, probably because of glx context (re
 
 Add option to save replay buffer on disk instead of ram.
 
-nvfbc capture cursor with cursor.h instead and composite that on top. This allows us to also always get a cursor in direct capture mode. This could possible give better performance as well.
+nvfbc capture cursor with cursor.h instead and composite that on top. This allows us to also always get a cursor in direct capture mode. This could possible give better performance as well.

meson.build

@@ -41,6 +41,9 @@ src = [
     'src/main.cpp',
 ]
 
+subdir('protocol')
+src += protocol_src
+
 dep = [
     dependency('threads'),
     dependency('libavcodec'),

protocol/meson.build

@@ -0,0 +1,25 @@
+wayland_scanner = dependency('wayland-scanner', native: true)
+wayland_scanner_path = wayland_scanner.get_variable(pkgconfig: 'wayland_scanner')
+wayland_scanner_prog = find_program(wayland_scanner_path, native: true)
+
+wayland_scanner_code = generator(
+	wayland_scanner_prog,
+	output: '@BASENAME@-protocol.c',
+	arguments: ['private-code', '@INPUT@', '@OUTPUT@'],
+)
+
+wayland_scanner_client = generator(
+	wayland_scanner_prog,
+	output: '@BASENAME@-client-protocol.h',
+	arguments: ['client-header', '@INPUT@', '@OUTPUT@'],
+)
+
+protocols = [
+	'xdg-output-unstable-v1.xml',
+]
+
+protocol_src = []
+foreach xml : protocols
+	protocol_src += wayland_scanner_code.process(xml)
+	protocol_src += wayland_scanner_client.process(xml)
+endforeach

protocol/xdg-output-unstable-v1.xml

@@ -0,0 +1,222 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="xdg_output_unstable_v1">
+
+  <copyright>
+    Copyright © 2017 Red Hat Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol to describe output regions">
+    This protocol aims at describing outputs in a way which is more in line
+    with the concept of an output on desktop oriented systems.
+
+    Some information are more specific to the concept of an output for
+    a desktop oriented system and may not make sense in other applications,
+    such as IVI systems for example.
+
+    Typically, the global compositor space on a desktop system is made of
+    a contiguous or overlapping set of rectangular regions.
+
+    The logical_position and logical_size events defined in this protocol
+    might provide information identical to their counterparts already
+    available from wl_output, in which case the information provided by this
+    protocol should be preferred to their equivalent in wl_output. The goal is
+    to move the desktop specific concepts (such as output location within the
+    global compositor space, etc.) out of the core wl_output protocol.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible
+    changes may be added together with the corresponding interface
+    version bump.
+    Backward incompatible changes are done by bumping the version
+    number in the protocol and interface names and resetting the
+    interface version. Once the protocol is to be declared stable,
+    the 'z' prefix and the version number in the protocol and
+    interface names are removed and the interface version number is
+    reset.
+  </description>
+
+  <interface name="zxdg_output_manager_v1" version="3">
+    <description summary="manage xdg_output objects">
+      A global factory interface for xdg_output objects.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_output_manager object">
+	Using this request a client can tell the server that it is not
+	going to use the xdg_output_manager object anymore.
+
+	Any objects already created through this instance are not affected.
+      </description>
+    </request>
+
+    <request name="get_xdg_output">
+      <description summary="create an xdg output from a wl_output">
+	This creates a new xdg_output object for the given wl_output.
+      </description>
+      <arg name="id" type="new_id" interface="zxdg_output_v1"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+  </interface>
+
+  <interface name="zxdg_output_v1" version="3">
+    <description summary="compositor logical output region">
+      An xdg_output describes part of the compositor geometry.
+
+      This typically corresponds to a monitor that displays part of the
+      compositor space.
+
+      For objects version 3 onwards, after all xdg_output properties have been
+      sent (when the object is created and when properties are updated), a
+      wl_output.done event is sent. This allows changes to the output
+      properties to be seen as atomic, even if they happen via multiple events.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the xdg_output object">
+	Using this request a client can tell the server that it is not
+	going to use the xdg_output object anymore.
+      </description>
+    </request>
+
+    <event name="logical_position">
+      <description summary="position of the output within the global compositor space">
+	The position event describes the location of the wl_output within
+	the global compositor space.
+
+	The logical_position event is sent after creating an xdg_output
+	(see xdg_output_manager.get_xdg_output) and whenever the location
+	of the output changes within the global compositor space.
+      </description>
+      <arg name="x" type="int"
+	   summary="x position within the global compositor space"/>
+      <arg name="y" type="int"
+	   summary="y position within the global compositor space"/>
+    </event>
+
+    <event name="logical_size">
+      <description summary="size of the output in the global compositor space">
+	The logical_size event describes the size of the output in the
+	global compositor space.
+
+	Most regular Wayland clients should not pay attention to the
+	logical size and would rather rely on xdg_shell interfaces.
+
+	Some clients such as Xwayland, however, need this to configure
+	their surfaces in the global compositor space as the compositor
+	may apply a different scale from what is advertised by the output
+	scaling property (to achieve fractional scaling, for example).
+
+	For example, for a wl_output mode 3840×2160 and a scale factor 2:
+
+	- A compositor not scaling the monitor viewport in its compositing space
+	  will advertise a logical size of 3840×2160,
+
+	- A compositor scaling the monitor viewport with scale factor 2 will
+	  advertise a logical size of 1920×1080,
+
+	- A compositor scaling the monitor viewport using a fractional scale of
+	  1.5 will advertise a logical size of 2560×1440.
+
+	For example, for a wl_output mode 1920×1080 and a 90 degree rotation,
+	the compositor will advertise a logical size of 1080x1920.
+
+	The logical_size event is sent after creating an xdg_output
+	(see xdg_output_manager.get_xdg_output) and whenever the logical
+	size of the output changes, either as a result of a change in the
+	applied scale or because of a change in the corresponding output
+	mode(see wl_output.mode) or transform (see wl_output.transform).
+      </description>
+      <arg name="width" type="int"
+	   summary="width in global compositor space"/>
+      <arg name="height" type="int"
+	   summary="height in global compositor space"/>
+    </event>
+
+    <event name="done" deprecated-since="3">
+      <description summary="all information about the output have been sent">
+	This event is sent after all other properties of an xdg_output
+	have been sent.
+
+	This allows changes to the xdg_output properties to be seen as
+	atomic, even if they happen via multiple events.
+
+	For objects version 3 onwards, this event is deprecated. Compositors
+	are not required to send it anymore and must send wl_output.done
+	instead.
+      </description>
+    </event>
+
+    <!-- Version 2 additions -->
+
+    <event name="name" since="2">
+      <description summary="name of this output">
+	Many compositors will assign names to their outputs, show them to the
+	user, allow them to be configured by name, etc. The client may wish to
+	know this name as well to offer the user similar behaviors.
+
+	The naming convention is compositor defined, but limited to
+	alphanumeric characters and dashes (-). Each name is unique among all
+	wl_output globals, but if a wl_output global is destroyed the same name
+	may be reused later. The names will also remain consistent across
+	sessions with the same hardware and software configuration.
+
+	Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do
+	not assume that the name is a reflection of an underlying DRM
+	connector, X11 connection, etc.
+
+	The name event is sent after creating an xdg_output (see
+	xdg_output_manager.get_xdg_output). This event is only sent once per
+	xdg_output, and the name does not change over the lifetime of the
+	wl_output global.
+
+        This event is deprecated, instead clients should use wl_output.name.
+        Compositors must still support this event.
+      </description>
+      <arg name="name" type="string" summary="output name"/>
+    </event>
+
+    <event name="description" since="2">
+      <description summary="human-readable description of this output">
+	Many compositors can produce human-readable descriptions of their
+	outputs.  The client may wish to know this description as well, to
+	communicate the user for various purposes.
+
+	The description is a UTF-8 string with no convention defined for its
+	contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11
+	output via :1'.
+
+	The description event is sent after creating an xdg_output (see
+	xdg_output_manager.get_xdg_output) and whenever the description
+	changes. The description is optional, and may not be sent at all.
+
+	For objects of version 2 and lower, this event is only sent once per
+	xdg_output, and the description does not change over the lifetime of
+	the wl_output global.
+
+	This event is deprecated, instead clients should use
+	wl_output.description. Compositors must still support this event.
+      </description>
+      <arg name="description" type="string" summary="output description"/>
+    </event>
+
+  </interface>
+</protocol>

src/window/wayland.c

@@ -7,14 +7,18 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
+#include <assert.h>
 #include <wayland-client.h>
 #include <wayland-egl.h>
+#include "xdg-output-unstable-v1-client-protocol.h"
 
 #define GSR_MAX_OUTPUTS 32
 
+typedef struct gsr_window_wayland gsr_window_wayland;
+
 typedef struct {
     uint32_t wl_name;
-    void *output;
+    struct wl_output *output;
     vec2i pos;
     vec2i size;
     int32_t transform;
@@ -22,6 +26,11 @@ typedef struct {
 } gsr_wayland_output;
 
 typedef struct {
+    gsr_wayland_output *gsr_output;
+    struct zxdg_output_v1 *output;
+} gsr_wayland_xdg_output;
+
+struct gsr_window_wayland {
     void *display;
     void *window;
     void *registry;
@@ -29,7 +38,10 @@ typedef struct {
     void *compositor;
     gsr_wayland_output outputs[GSR_MAX_OUTPUTS];
     int num_outputs;
-} gsr_window_wayland;
+    gsr_wayland_xdg_output xdg_outputs[GSR_MAX_OUTPUTS];
+    int num_xdg_outputs;
+    struct zxdg_output_manager_v1 *xdg_output_manager;
+};
 
 static void output_handle_geometry(void *data, struct wl_output *wl_output,
         int32_t x, int32_t y, int32_t phys_width, int32_t phys_height,
@@ -95,7 +107,7 @@ static const struct wl_output_listener output_listener = {
 static void registry_add_object(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
     (void)version;
     gsr_window_wayland *window_wayland = data;
-    if (strcmp(interface, "wl_compositor") == 0) {
+    if(strcmp(interface, "wl_compositor") == 0) {
         if(window_wayland->compositor) {
             wl_compositor_destroy(window_wayland->compositor);
             window_wayland->compositor = NULL;
@@ -103,7 +115,7 @@ static void registry_add_object(void *data, struct wl_registry *registry, uint32
         window_wayland->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 1);
     } else if(strcmp(interface, wl_output_interface.name) == 0) {
         if(version < 4) {
-            fprintf(stderr, "gsr warning: wl output interface version is < 4, expected >= 4 to capture a monitor. Using KMS capture instead\n");
+            fprintf(stderr, "gsr warning: wl output interface version is < 4, expected >= 4 to capture a monitor\n");
             return;
         }
 
@@ -123,6 +135,17 @@ static void registry_add_object(void *data, struct wl_registry *registry, uint32
             .name = NULL,
         };
         wl_output_add_listener(gsr_output->output, &output_listener, gsr_output);
+    } else if(strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) {
+        if(version < 1) {
+            fprintf(stderr, "gsr warning: xdg output interface version is < 1, expected >= 1 to capture a monitor\n");
+            return;
+        }
+
+        if(window_wayland->xdg_output_manager) {
+            zxdg_output_manager_v1_destroy(window_wayland->xdg_output_manager);
+            window_wayland->xdg_output_manager = NULL;
+        }
+        window_wayland->xdg_output_manager = wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, 1);
     }
 }
 
@@ -138,6 +161,66 @@ static struct wl_registry_listener registry_listener = {
     .global_remove = registry_remove_object,
 };
 
+static void xdg_output_logical_position(void *data, struct zxdg_output_v1 *zxdg_output_v1, int32_t x, int32_t y) {
+    (void)zxdg_output_v1;
+    gsr_wayland_xdg_output *gsr_xdg_output = data;
+    gsr_xdg_output->gsr_output->pos.x = x;
+    gsr_xdg_output->gsr_output->pos.y = y;
+}
+
+static void xdg_output_handle_logical_size(void *data, struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) {
+    (void)data;
+    (void)xdg_output;
+    (void)width;
+    (void)height;
+}
+
+static void xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output) {
+    (void)data;
+    (void)xdg_output;
+}
+
+static void xdg_output_handle_name(void *data, struct zxdg_output_v1 *xdg_output, const char *name) {
+    (void)data;
+    (void)xdg_output;
+    (void)name;
+}
+
+static void xdg_output_handle_description(void *data, struct zxdg_output_v1 *xdg_output, const char *description)
+{
+    (void)data;
+    (void)xdg_output;
+    (void)description;
+}
+
+static const struct zxdg_output_v1_listener xdg_output_listener = {
+    .logical_position = xdg_output_logical_position,
+    .logical_size = xdg_output_handle_logical_size,
+    .done = xdg_output_handle_done,
+    .name = xdg_output_handle_name,
+    .description = xdg_output_handle_description,
+};
+
+static void gsr_window_wayland_set_monitor_outputs_from_xdg_output(gsr_window_wayland *self) {
+    if(!self->xdg_output_manager) {
+        fprintf(stderr, "gsr warning: zxdg_output_manager not found. registered monitor positions might be incorrect\n");
+        return;
+    }
+
+    assert(self->num_xdg_outputs == 0);
+    self->num_xdg_outputs = self->num_outputs;
+    for(int i = 0; i < self->num_outputs; ++i) {
+        self->xdg_outputs[i] = (gsr_wayland_xdg_output) {
+            .gsr_output = &self->outputs[i],
+            .output = zxdg_output_manager_v1_get_xdg_output(self->xdg_output_manager, self->outputs[i].output),
+        };
+        zxdg_output_v1_add_listener(self->xdg_outputs[i].output, &xdg_output_listener, &self->xdg_outputs[i]);
+    }
+
+    // Fetch xdg_output
+    wl_display_roundtrip(self->display);
+}
+
 static void gsr_window_wayland_deinit(gsr_window_wayland *self) {
     if(self->window) {
         wl_egl_window_destroy(self->window);
@@ -162,6 +245,19 @@ static void gsr_window_wayland_deinit(gsr_window_wayland *self) {
     }
     self->num_outputs = 0;
 
+    for(int i = 0; i < self->num_xdg_outputs; ++i) {
+        if(self->xdg_outputs[i].output) {
+            zxdg_output_v1_destroy(self->xdg_outputs[i].output);
+            self->xdg_outputs[i].output = NULL;
+        }
+    }
+    self->num_xdg_outputs = 0;
+
+    if(self->xdg_output_manager) {
+        zxdg_output_manager_v1_destroy(self->xdg_output_manager);
+        self->xdg_output_manager = NULL;
+    }
+
     if(self->compositor) {
         wl_compositor_destroy(self->compositor);
         self->compositor = NULL;
@@ -194,6 +290,8 @@ static bool gsr_window_wayland_init(gsr_window_wayland *self) {
     // Fetch wl_output
     wl_display_roundtrip(self->display);
 
+    gsr_window_wayland_set_monitor_outputs_from_xdg_output(self);
+
     if(!self->compositor) {
         fprintf(stderr, "gsr error: gsr_window_wayland_init failed: failed to find compositor\n");
         goto fail;