From 080d519a0da152df9c3aff21efa7bc21cb264439 Mon Sep 17 00:00:00 2001 From: Dan Shick Date: Wed, 19 Feb 2020 16:55:51 -0500 Subject: [PATCH] Add xdg_output protocol for output selection --- include/screencast_common.h | 4 + include/wlr_screencast.h | 7 +- include/xdpw.h | 2 +- protocols/meson.build | 12 +- protocols/xdg-output-unstable-v1.xml | 220 +++++++++++++++++++++++++++ src/core/main.c | 10 +- src/screencast/screencast.c | 32 ++-- src/screencast/wlr_screencast.c | 73 ++++++++- 8 files changed, 338 insertions(+), 22 deletions(-) create mode 100644 protocols/xdg-output-unstable-v1.xml diff --git a/include/screencast_common.h b/include/screencast_common.h index cbcf7e8..3d8956f 100644 --- a/include/screencast_common.h +++ b/include/screencast_common.h @@ -64,6 +64,7 @@ struct screencast_context { struct wl_list output_list; struct wl_registry *registry; struct zwlr_screencopy_manager_v1 *screencopy_manager; + struct zxdg_output_manager_v1* xdg_output_manager; struct wl_shm *shm; // main frame callback @@ -82,6 +83,7 @@ struct screencast_context { pthread_mutex_t lock; // cli options + const char *output_name; const char *forced_pixelformat; // if something happens during capture @@ -93,8 +95,10 @@ struct wayland_output { struct wl_list link; uint32_t id; struct wl_output *output; + struct zxdg_output_v1 *xdg_output; char *make; char *model; + char *name; int width; int height; float framerate; diff --git a/include/wlr_screencast.h b/include/wlr_screencast.h index a9f03dc..8b3ab0e 100644 --- a/include/wlr_screencast.h +++ b/include/wlr_screencast.h @@ -2,6 +2,7 @@ #define WLR_SCREENCAST_H #include "wlr-screencopy-unstable-v1-client-protocol.h" +#include "xdg-output-unstable-v1-client-protocol.h" #include #include #include @@ -22,8 +23,12 @@ void wlr_frame_free(struct screencast_context *ctx); int wlr_screencopy_init(struct screencast_context *ctx); void wlr_screencopy_uninit(struct screencast_context *ctx); -struct wayland_output *wlr_find_output(struct screencast_context *ctx, + +struct wayland_output *wlr_output_find_by_name(struct wl_list *output_list, const char* name); +struct wayland_output *wlr_output_find(struct screencast_context *ctx, struct wl_output *out, uint32_t id); +struct wayland_output *wlr_output_first(struct wl_list *output_list); + void wlr_register_cb(struct screencast_context *ctx); #endif diff --git a/include/xdpw.h b/include/xdpw.h index 625e2a8..0942207 100644 --- a/include/xdpw.h +++ b/include/xdpw.h @@ -19,7 +19,7 @@ enum { }; int init_screenshot(sd_bus *bus); -int init_screencast(sd_bus *bus, const char *forced_pixelformat); +int init_screencast(sd_bus *bus, const char *output_name, const char *forced_pixelformat); struct xdpw_request *request_create(sd_bus *bus, const char *object_path); void request_destroy(struct xdpw_request *req); diff --git a/protocols/meson.build b/protocols/meson.build index e14a53d..be773a9 100644 --- a/protocols/meson.build +++ b/protocols/meson.build @@ -8,11 +8,16 @@ else wayland_scanner = find_program('wayland-scanner', native: true) endif -xml='wlr-screencopy-unstable-v1.xml' +client_protocols = [ + 'wlr-screencopy-unstable-v1.xml', + 'xdg-output-unstable-v1.xml', +] + wl_protos_src = [] wl_protos_headers = [] -wl_protos_src += custom_target( +foreach xml: client_protocols + wl_protos_src += custom_target( xml.underscorify() + '_server_c', input: xml, output: '@BASENAME@-protocol.c', @@ -25,12 +30,13 @@ wl_protos_src += custom_target( command: [wayland_scanner, 'server-header', '@INPUT@', '@OUTPUT@'], ) -wl_protos_headers += custom_target( + wl_protos_headers += custom_target( xml.underscorify() + '_client_h', input: xml, output: '@BASENAME@-client-protocol.h', command: [wayland_scanner, 'client-header', '@INPUT@', '@OUTPUT@'], ) +endforeach lib_wl_protos = static_library( 'wl_protos', diff --git a/protocols/xdg-output-unstable-v1.xml b/protocols/xdg-output-unstable-v1.xml new file mode 100644 index 0000000..fe3a70a --- /dev/null +++ b/protocols/xdg-output-unstable-v1.xml @@ -0,0 +1,220 @@ + + + + + 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. + + + + 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. + + Some of the information provided in this protocol might be 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, + the connector name and types, 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. + + + + + A global factory interface for xdg_output objects. + + + + + 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. + + + + + + This creates a new xdg_output object for the given wl_output. + + + + + + + + + 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. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output object anymore. + + + + + + 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. + + + + + + + + The logical_size event describes the size of the output in the + global compositor space. + + For example, a surface without any buffer scale, transformation + nor rotation set, with the size matching the logical_size will + have the same size as the corresponding output when displayed. + + 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 surface buffers will advertise a + logical size of 3840×2160, + + - A compositor automatically scaling the surface buffers will + advertise a logical size of 1920×1080, + + - A compositor using a fractional scale of 1.5 will advertise a + logical size to 2560×1620. + + 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). + + + + + + + + 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. + + + + + + + + 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. + + + + + + + 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. + + + + + + diff --git a/src/core/main.c b/src/core/main.c index cdfbf5d..0592662 100644 --- a/src/core/main.c +++ b/src/core/main.c @@ -10,6 +10,7 @@ int xdpw_usage(FILE* stream, int rc) static const char* usage = "Usage: xdg-desktop-portal-wlr [options]\n" "\n" +" -o, --output= Select output to capture.\n" " -p,--pixelformat=BGRx|RGBx Force a pixelformat in pipewire\n" " metadata (performs no conversion).\n" " -h,--help Get help (this text).\n" @@ -22,10 +23,12 @@ int xdpw_usage(FILE* stream, int rc) int main(int argc, char *argv[]) { + const char* output_name = NULL; const char* forced_pixelformat = NULL; - static const char* shortopts = "p:h"; + static const char* shortopts = "o:p:h"; static const struct option longopts[] = { + { "output", required_argument, NULL, 'o' }, { "pixelformat", required_argument, NULL, 'p' }, { "help", no_argument, NULL, 'h' }, { NULL, 0, NULL, 0 } @@ -37,6 +40,9 @@ int main(int argc, char *argv[]) { break; switch (c) { + case 'o': + output_name = optarg; + break; case 'p': forced_pixelformat = optarg; break; @@ -57,7 +63,7 @@ int main(int argc, char *argv[]) { } init_screenshot(bus); - init_screencast(bus, forced_pixelformat); + init_screencast(bus, output_name, forced_pixelformat); ret = sd_bus_request_name(bus, service_name, 0); if (ret < 0) { diff --git a/src/screencast/screencast.c b/src/screencast/screencast.c index f384eb8..0aaef55 100644 --- a/src/screencast/screencast.c +++ b/src/screencast/screencast.c @@ -7,23 +7,30 @@ static const char interface_name[] = "org.freedesktop.impl.portal.ScreenCast"; int setup_outputs(struct screencast_context *ctx) { - int output_id; - struct wayland_output *output, *tmp_o; wl_list_for_each_reverse_safe(output, tmp_o, &ctx->output_list, link) { - printf("Capturable output: %s Model: %s: ID: %i\n", output->make, - output->model, output->id); - output_id = output->id; + printf("Capturable output: %s Model: %s: ID: %i Name: %s\n", output->make, + output->model, output->id, output->name); } - output = wlr_find_output(ctx, NULL, output_id); - if (!output) { - printf("Unable to find output with ID %i!\n", output_id); - return 1; + struct wayland_output *out; + if (ctx->output_name) { + out = wlr_output_find_by_name(&ctx->output_list, ctx->output_name); + if (!out) { + printf("No such output\n"); + exit(EXIT_FAILURE); + } + } else { + out = wlr_output_first(&ctx->output_list); + if (!out) { + printf("No output found\n"); + exit(EXIT_FAILURE); + } } + printf("here %s\n", out->name); - ctx->target_output = output; - ctx->framerate = output->framerate; + ctx->target_output = out; + ctx->framerate = out->framerate; ctx->with_cursor = true; printf("wl_display fd: %d\n", wl_display_get_fd(ctx->display)); @@ -300,12 +307,13 @@ static const sd_bus_vtable screencast_vtable[] = { SD_BUS_VTABLE_END }; -int init_screencast(sd_bus *bus, const char *forced_pixelformat) { +int init_screencast(sd_bus *bus, const char *output_name, const char *forced_pixelformat) { // TODO: cleanup sd_bus_slot *slot = NULL; //struct screencast_context ctx = (struct screencast_context){0}; ctx.forced_pixelformat = forced_pixelformat; + ctx.output_name = output_name; ctx.simple_frame = (struct simple_frame){0}; ctx.simple_frame.damage = &(struct damage){0}; diff --git a/src/screencast/wlr_screencast.c b/src/screencast/wlr_screencast.c index f13acb5..c3f022a 100644 --- a/src/screencast/wlr_screencast.c +++ b/src/screencast/wlr_screencast.c @@ -181,7 +181,62 @@ static const struct wl_output_listener wlr_output_listener = { .scale = wlr_output_handle_scale, }; -struct wayland_output *wlr_find_output(struct screencast_context *ctx, +static void wlr_xdg_output_name(void* data, struct zxdg_output_v1* xdg_output, + const char* name){ + struct wayland_output *output = data; + + output->name = strdup(name); +}; + +static void dontcare(){ +} + +static const struct zxdg_output_v1_listener wlr_xdg_output_listener = { + .logical_position = dontcare, + .logical_size = dontcare, + .done = NULL, /* Deprecated */ + .description = dontcare, + .name = wlr_xdg_output_name, +}; + +void wlr_add_xdg_output_listener(struct wayland_output *output, + struct zxdg_output_v1* xdg_output){ + output->xdg_output = xdg_output; + zxdg_output_v1_add_listener(output->xdg_output, &wlr_xdg_output_listener, + output); +} + +static void wlr_init_xdg_outputs(struct screencast_context *ctx){ + struct wayland_output *output, *tmp; + wl_list_for_each_safe(output, tmp, &ctx->output_list, link) { + struct zxdg_output_v1 *xdg_output = + zxdg_output_manager_v1_get_xdg_output( + ctx->xdg_output_manager, output->output); + + wlr_add_xdg_output_listener(output, xdg_output); + } +} + +struct wayland_output *wlr_output_first(struct wl_list *output_list) { + struct wayland_output *output, *tmp; + wl_list_for_each_safe(output, tmp, output_list, link) { + return output; + } + return NULL; +} + +struct wayland_output *wlr_output_find_by_name(struct wl_list *output_list, const char* name) { + struct wayland_output *output, *tmp; + wl_list_for_each_safe(output, tmp, output_list, link){ + if (strcmp(output->name, name) == 0){ + return output; + } + } + return NULL; +} + + +struct wayland_output *wlr_output_find(struct screencast_context *ctx, struct wl_output *out, uint32_t id) { struct wayland_output *output, *tmp; wl_list_for_each_safe(output, tmp, &ctx->output_list, link) { @@ -219,12 +274,17 @@ static void wlr_registry_handle_add(void *data, struct wl_registry *reg, if (strcmp(interface, wl_shm_interface.name) == 0) { ctx->shm = wl_registry_bind(reg, id, &wl_shm_interface, 1); } + + if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) { + ctx->xdg_output_manager = + wl_registry_bind(reg, id, &zxdg_output_manager_v1_interface, 3); + } } static void wlr_registry_handle_remove(void *data, struct wl_registry *reg, uint32_t id) { wlr_remove_output( - wlr_find_output((struct screencast_context *)data, NULL, id)); + wlr_output_find((struct screencast_context *)data, NULL, id)); } static const struct wl_registry_listener wlr_registry_listener = { @@ -247,8 +307,13 @@ int wlr_screencopy_init(struct screencast_context *ctx) { ctx->registry = wl_display_get_registry(ctx->display); wl_registry_add_listener(ctx->registry, &wlr_registry_listener, ctx); - wl_display_roundtrip(ctx->display); wl_display_dispatch(ctx->display); + wl_display_roundtrip(ctx->display); + + wlr_init_xdg_outputs(ctx); + + wl_display_dispatch(ctx->display); + wl_display_roundtrip(ctx->display); // make sure our wlroots supports screencopy protocol if (!ctx->shm) { @@ -270,6 +335,8 @@ void wlr_screencopy_uninit(struct screencast_context *ctx) { struct wayland_output *output, *tmp_o; wl_list_for_each_safe(output, tmp_o, &ctx->output_list, link) { wl_list_remove(&output->link); + zxdg_output_v1_destroy(output->xdg_output); + wl_output_destroy(output->output); } if (ctx->screencopy_manager) {