From: Marius Vlad Date: Tue, 15 Sep 2020 15:12:24 +0000 (+0300) Subject: screenshooter: Add agl-screenshooter protocol X-Git-Tag: 10.91.0~25 X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=commitdiff_plain;h=991714fc7f92aea3d07c7225247a821e3461027e;p=src%2Fagl-compositor.git screenshooter: Add agl-screenshooter protocol Just like weston, we add a private protocol. Underneath we make use of the weston renderer to get a hold of the pixels and transfer them to a user-supplied buffer. This only brings up the server side implementation of the protocol. Bug-AGL: SPEC-3580 Signed-off-by: Marius Vlad Change-Id: I02a07ad5eb492ef2ecad74efb34d1453ebcbedc0 --- diff --git a/meson.build b/meson.build index 9dd9673..4299d58 100644 --- a/meson.build +++ b/meson.build @@ -65,11 +65,13 @@ endforeach agl_shell_xml = files('protocol/agl-shell.xml') agl_shell_desktop_xml = files('protocol/agl-shell-desktop.xml') +agl_screenshooter = files('protocol/agl-screenshooter.xml') xdg_shell_xml = join_paths(dir_wp_base, 'stable', 'xdg-shell', 'xdg-shell.xml') protocols = [ { 'name': 'agl-shell', 'source': 'internal' }, { 'name': 'agl-shell-desktop', 'source': 'internal' }, + { 'name': 'agl-screenshooter', 'source': 'internal' }, { 'name': 'xdg-shell', 'source': 'wp-stable' }, ] @@ -140,12 +142,15 @@ srcs_agl_compositor = [ 'src/layout.c', 'src/policy.c', 'src/shell.c', + 'src/screenshooter.c', 'shared/option-parser.c', 'shared/os-compatibility.c', agl_shell_server_protocol_h, agl_shell_desktop_server_protocol_h, + agl_screenshooter_server_protocol_h, agl_shell_protocol_c, agl_shell_desktop_protocol_c, + agl_screenshooter_protocol_c, xdg_shell_protocol_c, ] diff --git a/protocol/agl-screenshooter.xml b/protocol/agl-screenshooter.xml new file mode 100644 index 0000000..6ed1457 --- /dev/null +++ b/protocol/agl-screenshooter.xml @@ -0,0 +1,84 @@ + + + + + Copyright © 2020 Collabora. Ltd, + + 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. + + + + + agl compositor extension that performs a screenshot of the output, which + is represented by a 'wl_output' object. + + A client would call 'take_shot' request and wait until the compositor + finishes to write the data to a wayland buffer, moment in which signals + back the client with the help of the 'done' event. Clients should wait + until the 'done' event is received, if they want to take another + screenshot, or take another screnshot of a different output. + + The client must provide a wl_shm-based wl_buffer of the correct size when + taking a shot. The compositor will write the shot into the wl_buffer and then + send the 'done' event that signals completion of writing the data. + + Once the compositor has finished to transfer the data back into the supplied + wayland buffer, the client should be able to transfer it to a popular + file format on the disk. + + + + + + + + + + + Takes a screenshot of the wayland output represented by a 'wl_output' + object. Clients should first retrieve it using global registry, as well + as the 'wl_shm' object in order to create a wayland buffer type of + object ('wl_buffer'). + + Clients can derive the stride and size from the 'wl_output' object, and + later on use those when creating shm-based 'wl_buffer', as well as supplying + the pixel format. + + + + + + + + + Even sent back to nofify client 'take_shot' request has completed. + + + + + + + Destroys the 'weston_screenshooter' interface. + + + + + + diff --git a/src/ivi-compositor.h b/src/ivi-compositor.h index 6969a7d..4506a5a 100644 --- a/src/ivi-compositor.h +++ b/src/ivi-compositor.h @@ -377,5 +377,7 @@ ivi_layout_find_with_app_id(const char *app_id, struct ivi_compositor *ivi); void shell_advertise_app_state(struct ivi_compositor *ivi, const char *app_id, const char *data, uint32_t app_state); +void +ivi_screenshooter_create(struct ivi_compositor *ivi); #endif diff --git a/src/main.c b/src/main.c index 99512d5..164b45b 100644 --- a/src/main.c +++ b/src/main.c @@ -1493,6 +1493,7 @@ int main(int argc, char *argv[]) ivi_shell_create_global(&ivi); ivi_launch_shell_client(&ivi); + ivi_screenshooter_create(&ivi); ivi_agl_systemd_notify(&ivi); wl_display_run(display); diff --git a/src/screenshooter.c b/src/screenshooter.c new file mode 100644 index 0000000..ef3d32e --- /dev/null +++ b/src/screenshooter.c @@ -0,0 +1,137 @@ +/* + * Copyright © 2020 Collabora, Ltd. + * + * 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. + */ + +#include "ivi-compositor.h" +#include "shared/helpers.h" + +#include +#include "agl-screenshooter-server-protocol.h" +#include + +struct screenshooter { + struct ivi_compositor *ivi; + struct wl_global *global; + struct wl_client *client; + struct wl_listener destroy_listener; +}; + +static void +screenshooter_done(void *data, enum weston_screenshooter_outcome outcome) +{ + struct wl_resource *resource = data; + + if (outcome == WESTON_SCREENSHOOTER_NO_MEMORY) { + wl_resource_post_no_memory(resource); + return; + } + + agl_screenshooter_send_done(resource, outcome); +} + +static void +screenshooter_shoot(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *output_resource, + struct wl_resource *buffer_resource) +{ + struct weston_output *output = + weston_head_from_resource(output_resource)->output; + struct weston_buffer *buffer = + weston_buffer_from_resource(buffer_resource); + + if (buffer == NULL) { + wl_resource_post_no_memory(resource); + return; + } + + weston_screenshooter_shoot(output, buffer, screenshooter_done, resource); +} + +static void +screenshooter_destructor_destroy(struct wl_client *client, + struct wl_resource *global_resource) +{ + wl_resource_destroy(global_resource); +} + +struct agl_screenshooter_interface screenshooter_implementation = { + screenshooter_shoot, + screenshooter_destructor_destroy +}; + +static void +bind_shooter(struct wl_client *client, + void *data, uint32_t version, uint32_t id) +{ + struct screenshooter *shooter = data; + struct wl_resource *resource; + bool debug_enabled = true; + + resource = wl_resource_create(client, + &agl_screenshooter_interface, 1, id); + + if (!debug_enabled && !shooter->client) { + wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT, + "screenshooter failed: permission denied. "\ + "Debug must be enabled"); + return; + } + + wl_resource_set_implementation(resource, &screenshooter_implementation, + data, NULL); +} + +static void +screenshooter_destroy(struct wl_listener *listener, void *data) +{ + struct screenshooter *shooter = + container_of(listener, struct screenshooter, destroy_listener); + + wl_list_remove(&shooter->destroy_listener.link); + + wl_global_destroy(shooter->global); + free(shooter); +} + +void +ivi_screenshooter_create(struct ivi_compositor *ivi) +{ + struct weston_compositor *ec = ivi->compositor; + struct screenshooter *shooter; + + shooter = zalloc(sizeof(*shooter)); + if (shooter == NULL) + return; + + shooter->ivi = ivi; + shooter->global = wl_global_create(ec->wl_display, + &agl_screenshooter_interface, 1, + shooter, bind_shooter); + + shooter->destroy_listener.notify = screenshooter_destroy; + wl_signal_add(&ec->destroy_signal, &shooter->destroy_listener); + + weston_log("Screenshooter interface created\n"); +}