wayland_common: rewrite from scratch

The wayland code was written more than 4 years ago when wayland wasn't
even at version 1.0. This commit rewrites everything in a more modern way,
switches to using the new xdg v6 shell interface which solves a lot of bugs
and makes mpv tiling-friedly, adds support for drag and drop, adds support
for touchscreens, adds support for KDE's server decorations protocol,
and finally adds support for the new idle-inhibitor protocol.

It does not yet use the frame callback as a main rendering loop driver,
this will happen with a later commit.

video/out/opengl/context_wayland.c

@@ -16,197 +16,170 @@
  * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <wayland-egl.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
 #include "video/out/wayland_common.h"
 #include "context.h"
 #include "egl_helpers.h"
 #include "utils.h"
 
-static void egl_resize(struct vo_wayland_state *wl)
+struct priv {
+    GL gl;
+    EGLDisplay egl_display;
+    EGLContext egl_context;
+    EGLSurface egl_surface;
+    EGLConfig  egl_config;
+    struct wl_egl_window *egl_window;
+};
+
+static void resize(struct ra_ctx *ctx)
 {
-    int32_t x = wl->window.sh_x;
+    struct priv *p = ctx->priv;
-    int32_t y = wl->window.sh_y;
+    struct vo_wayland_state *wl = ctx->vo->wl;
-    int32_t width = wl->window.sh_width;
-    int32_t height = wl->window.sh_height;
-    int32_t scale = 1;
 
-    if (!wl->egl_context.egl_window)
+    MP_VERBOSE(wl, "Handling resizing on the egl side\n");
-        return;
 
-    if (wl->display.current_output)
+    const int32_t width = wl->scaling*mp_rect_w(wl->geometry);
-        scale = wl->display.current_output->scale;
+    const int32_t height = wl->scaling*mp_rect_h(wl->geometry);
 
-    // get the real size of the window
+    wl_surface_set_buffer_scale(wl->surface, wl->scaling);
-    // this improves moving the window while resizing it
+    wl_egl_window_resize(p->egl_window, width, height, 0, 0);
-    wl_egl_window_get_attached_size(wl->egl_context.egl_window,
-                                    &wl->window.width,
-                                    &wl->window.height);
 
-    MP_VERBOSE(wl, "resizing %dx%d -> %dx%d\n", wl->window.width,
+    wl->vo->dwidth  = width;
-                                                wl->window.height,
+    wl->vo->dheight = height;
-                                                width,
-                                                height);
-
-    if (x != 0)
-        x = wl->window.width - width;
-
-    if (y != 0)
-        y = wl->window.height - height;
-
-    wl_surface_set_buffer_scale(wl->window.video_surface, scale);
-    wl_egl_window_resize(wl->egl_context.egl_window, scale*width, scale*height, x, y);
-
-    wl->window.width = width;
-    wl->window.height = height;
-
-    /* set size for mplayer */
-    wl->vo->dwidth  = scale*wl->window.width;
-    wl->vo->dheight = scale*wl->window.height;
-    wl->vo->want_redraw = true;
 }
 
-static void waylandgl_swap_buffers(struct ra_ctx *ctx)
+static void wayland_egl_swap_buffers(struct ra_ctx *ctx)
 {
-    struct vo_wayland_state *wl = ctx->vo->wayland;
+    struct priv *p = ctx->priv;
-    vo_wayland_wait_events(ctx->vo, 0);
+    eglSwapBuffers(p->egl_display, p->egl_surface);
-    eglSwapBuffers(wl->egl_context.egl.dpy, wl->egl_context.egl_surface);
 }
 
-static bool egl_create_context(struct ra_ctx *ctx, struct vo_wayland_state *wl)
+static bool egl_create_context(struct ra_ctx *ctx)
 {
-    GL *gl = ctx->priv = talloc_zero(ctx, GL);
+    struct priv *p = ctx->priv = talloc_zero(ctx, struct priv);
+    struct vo_wayland_state *wl = ctx->vo->wl;
 
-    if (!(wl->egl_context.egl.dpy = eglGetDisplay(wl->display.display)))
+    if (!(p->egl_display = eglGetDisplay(wl->display)))
         return false;
 
-    if (eglInitialize(wl->egl_context.egl.dpy, NULL, NULL) != EGL_TRUE)
+    if (eglInitialize(p->egl_display, NULL, NULL) != EGL_TRUE)
         return false;
 
-    if (!mpegl_create_context(ctx, wl->egl_context.egl.dpy,
+    if (!mpegl_create_context(ctx, p->egl_display, &p->egl_context,
-                              &wl->egl_context.egl.ctx,
+                              &p->egl_config))
-                              &wl->egl_context.egl.conf))
         return false;
 
-    eglMakeCurrent(wl->egl_context.egl.dpy, NULL, NULL, wl->egl_context.egl.ctx);
+    eglMakeCurrent(p->egl_display, NULL, NULL, p->egl_context);
 
-    mpegl_load_functions(gl, wl->log);
+    mpegl_load_functions(&p->gl, wl->log);
 
     struct ra_gl_ctx_params params = {
-        .swap_buffers = waylandgl_swap_buffers,
+        .swap_buffers = wayland_egl_swap_buffers,
         .native_display_type = "wl",
-        .native_display = wl->display.display,
+        .native_display = wl->display,
     };
 
-    if (!ra_gl_ctx_init(ctx, gl, params))
+    if (!ra_gl_ctx_init(ctx, &p->gl, params))
         return false;
 
+    vo_wayland_set_cb_exec(ctx->vo, NULL, NULL);
+
     return true;
 }
 
-static void egl_create_window(struct vo_wayland_state *wl)
+static void egl_create_window(struct ra_ctx *ctx)
 {
-    wl->egl_context.egl_window = wl_egl_window_create(wl->window.video_surface,
+    struct priv *p = ctx->priv;
-                                                      wl->window.width,
+    struct vo_wayland_state *wl = ctx->vo->wl;
-                                                      wl->window.height);
 
-    wl->egl_context.egl_surface = eglCreateWindowSurface(wl->egl_context.egl.dpy,
+    p->egl_window = wl_egl_window_create(wl->surface, mp_rect_w(wl->geometry),
-                                                         wl->egl_context.egl.conf,
+                                         mp_rect_h(wl->geometry));
-                                                         wl->egl_context.egl_window,
-                                                         NULL);
 
-    eglMakeCurrent(wl->egl_context.egl.dpy,
+    p->egl_surface = eglCreateWindowSurface(p->egl_display, p->egl_config,
-                   wl->egl_context.egl_surface,
+                                            p->egl_window, NULL);
-                   wl->egl_context.egl_surface,
-                   wl->egl_context.egl.ctx);
 
-    wl_display_dispatch_pending(wl->display.display);
+    eglMakeCurrent(p->egl_display, p->egl_surface, p->egl_surface, p->egl_context);
 
-    /**
+    eglSwapInterval(p->egl_display, 0);
-     * <http://lists.freedesktop.org/archives/wayland-devel/2013-November/012019.html>
-     *
-     * The main change is that if the swap interval is 0 then Mesa won't install a
-     * frame callback so that eglSwapBuffers can be executed as often as necessary.
-     * Instead it will do a sync request after the swap buffers. It will block for
-     * sync complete event in get_back_bo instead of the frame callback. The
-     * compositor is likely to send a release event while processing the new buffer
-     * attach and this makes sure we will receive that before deciding whether to
-     * allocate a new buffer.
-     */
 
-    eglSwapInterval(wl->egl_context.egl.dpy, 0);
+    wl_display_roundtrip(wl->display);
 }
 
-static bool waylandgl_reconfig(struct ra_ctx *ctx)
+static bool wayland_egl_reconfig(struct ra_ctx *ctx)
 {
-    struct vo_wayland_state * wl = ctx->vo->wayland;
+    struct priv *p = ctx->priv;
 
-    if (!vo_wayland_config(ctx->vo))
+    if (!vo_wayland_reconfig(ctx->vo))
         return false;
 
-    if (!wl->egl_context.egl_window)
+    if (!p->egl_window)
-        egl_create_window(wl);
+        egl_create_window(ctx);
 
     return true;
 }
 
-static void waylandgl_uninit(struct ra_ctx *ctx)
+static void wayland_egl_uninit(struct ra_ctx *ctx)
 {
-    struct vo_wayland_state *wl = ctx->vo->wayland;
+    struct priv *p = ctx->priv;
 
     ra_gl_ctx_uninit(ctx);
 
-    if (wl->egl_context.egl.ctx) {
+    if (p->egl_context) {
         eglReleaseThread();
-        if (wl->egl_context.egl_window)
+        if (p->egl_window)
-            wl_egl_window_destroy(wl->egl_context.egl_window);
+            wl_egl_window_destroy(p->egl_window);
-        eglDestroySurface(wl->egl_context.egl.dpy, wl->egl_context.egl_surface);
+        eglDestroySurface(p->egl_display, p->egl_surface);
-        eglMakeCurrent(wl->egl_context.egl.dpy, NULL, NULL, EGL_NO_CONTEXT);
+        eglMakeCurrent(p->egl_display, NULL, NULL, EGL_NO_CONTEXT);
-        eglDestroyContext(wl->egl_context.egl.dpy, wl->egl_context.egl.ctx);
+        eglDestroyContext(p->egl_display, p->egl_context);
+        p->egl_context = NULL;
     }
-    eglTerminate(wl->egl_context.egl.dpy);
+    eglTerminate(p->egl_display);
-    wl->egl_context.egl.ctx = NULL;
 
     vo_wayland_uninit(ctx->vo);
 }
 
-static int waylandgl_control(struct ra_ctx *ctx, int *events, int request,
+static int wayland_egl_control(struct ra_ctx *ctx, int *events, int request,
                              void *data)
 {
-    struct vo_wayland_state *wl = ctx->vo->wayland;
+    struct vo_wayland_state *wl = ctx->vo->wl;
     int r = vo_wayland_control(ctx->vo, events, request, data);
 
     if (*events & VO_EVENT_RESIZE) {
-        egl_resize(wl);
+        resize(ctx);
         ra_gl_ctx_resize(ctx->swapchain, wl->vo->dwidth, wl->vo->dheight, 0);
     }
 
     return r;
 }
 
-static void wayland_wakeup(struct ra_ctx *ctx)
+static void wayland_egl_wakeup(struct ra_ctx *ctx)
 {
     vo_wayland_wakeup(ctx->vo);
 }
 
-static void wayland_wait_events(struct ra_ctx *ctx, int64_t until_time_us)
+static void wayland_egl_wait_events(struct ra_ctx *ctx, int64_t until_time_us)
 {
     vo_wayland_wait_events(ctx->vo, until_time_us);
 }
 
-static bool waylandgl_init(struct ra_ctx *ctx)
+static bool wayland_egl_init(struct ra_ctx *ctx)
 {
     if (!vo_wayland_init(ctx->vo))
         return false;
 
-    return egl_create_context(ctx, ctx->vo->wayland);
+    return egl_create_context(ctx);
 }
 
 const struct ra_ctx_fns ra_ctx_wayland_egl = {
     .type           = "opengl",
     .name           = "wayland",
-    .reconfig       = waylandgl_reconfig,
+    .reconfig       = wayland_egl_reconfig,
-    .control        = waylandgl_control,
+    .control        = wayland_egl_control,
-    .wakeup         = wayland_wakeup,
+    .wakeup         = wayland_egl_wakeup,
-    .wait_events    = wayland_wait_events,
+    .wait_events    = wayland_egl_wait_events,
-    .init           = waylandgl_init,
+    .init           = wayland_egl_init,
-    .uninit         = waylandgl_uninit,
+    .uninit         = wayland_egl_uninit,
 };

video/out/vo.h

@@ -374,7 +374,7 @@ struct vo {
     struct vo_x11_state *x11;
     struct vo_w32_state *w32;
     struct vo_cocoa_state *cocoa;
-    struct vo_wayland_state *wayland;
+    struct vo_wayland_state *wl;
     struct mp_hwdec_devices *hwdec_devs;
     struct input_ctx *input_ctx;
     struct osd_state *osd;

video/out/vulkan/context_wayland.c

@@ -26,7 +26,7 @@ struct priv {
     struct mpvk_ctx vk;
 };
 
-static void wayland_uninit(struct ra_ctx *ctx)
+static void wayland_vk_uninit(struct ra_ctx *ctx)
 {
     struct priv *p = ctx->priv;
 
@@ -35,7 +35,7 @@ static void wayland_uninit(struct ra_ctx *ctx)
     vo_wayland_uninit(ctx->vo);
 }
 
-static bool wayland_init(struct ra_ctx *ctx)
+static bool wayland_vk_init(struct ra_ctx *ctx)
 {
     struct priv *p = ctx->priv = talloc_zero(ctx, struct priv);
     struct mpvk_ctx *vk = &p->vk;
@@ -48,13 +48,10 @@ static bool wayland_init(struct ra_ctx *ctx)
     if (!vo_wayland_init(ctx->vo))
         goto error;
 
-    if (!vo_wayland_config(ctx->vo))
-        goto error;
-
     VkWaylandSurfaceCreateInfoKHR wlinfo = {
          .sType   = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
-         .display = ctx->vo->wayland->display.display,
+         .display = ctx->vo->wl->display,
-         .surface = ctx->vo->wayland->window.video_surface,
+         .surface = ctx->vo->wl->surface,
     };
 
     VkResult res = vkCreateWaylandSurfaceKHR(vk->inst, &wlinfo, MPVK_ALLOCATOR,
@@ -73,63 +70,55 @@ static bool wayland_init(struct ra_ctx *ctx)
     if (!ra_vk_ctx_init(ctx, vk, VK_PRESENT_MODE_MAILBOX_KHR))
         goto error;
 
+    vo_wayland_set_cb_exec(ctx->vo, NULL, NULL);
+
     return true;
 
 error:
-    wayland_uninit(ctx);
+    wayland_vk_uninit(ctx);
     return false;
 }
 
-static bool resize(struct ra_ctx *ctx)
+static void resize(struct ra_ctx *ctx)
 {
-    struct vo_wayland_state *wl = ctx->vo->wayland;
+    struct vo_wayland_state *wl = ctx->vo->wl;
-    int32_t width = wl->window.sh_width;
-    int32_t height = wl->window.sh_height;
-    int32_t scale = 1;
 
-    if (wl->display.current_output)
+    MP_VERBOSE(wl, "Handling resizing on the vk side\n");
-        scale = wl->display.current_output->scale;
 
-    MP_VERBOSE(wl, "resizing %dx%d -> %dx%d\n", wl->window.width,
+    const int32_t width = wl->scaling*mp_rect_w(wl->geometry);
-                                                wl->window.height,
+    const int32_t height = wl->scaling*mp_rect_h(wl->geometry);
-                                                width,
-                                                height);
 
-    wl_surface_set_buffer_scale(wl->window.video_surface, scale);
+    wl_surface_set_buffer_scale(wl->surface, wl->scaling);
-    int err = ra_vk_ctx_resize(ctx->swapchain, scale*width, scale*height);
 
-    wl->window.width = width;
+    wl->vo->dwidth  = width;
-    wl->window.height = height;
+    wl->vo->dheight = height;
-
-    wl->vo->dwidth  = scale*wl->window.width;
-    wl->vo->dheight = scale*wl->window.height;
-    wl->vo->want_redraw = true;
-
-    return err;
 }
 
-static bool wayland_reconfig(struct ra_ctx *ctx)
+static bool wayland_vk_reconfig(struct ra_ctx *ctx)
 {
-    vo_wayland_config(ctx->vo);
+    if (!vo_wayland_reconfig(ctx->vo))
-    return resize(ctx);
+        return false;
+
+    return true;
 }
 
-static int wayland_control(struct ra_ctx *ctx, int *events, int request, void *arg)
+static int wayland_vk_control(struct ra_ctx *ctx, int *events, int request, void *arg)
 {
     int ret = vo_wayland_control(ctx->vo, events, request, arg);
     if (*events & VO_EVENT_RESIZE) {
-        if (!resize(ctx))
+        resize(ctx);
+        if (ra_vk_ctx_resize(ctx->swapchain, ctx->vo->dwidth, ctx->vo->dheight))
             return VO_ERROR;
     }
     return ret;
 }
 
-static void wayland_wakeup(struct ra_ctx *ctx)
+static void wayland_vk_wakeup(struct ra_ctx *ctx)
 {
     vo_wayland_wakeup(ctx->vo);
 }
 
-static void wayland_wait_events(struct ra_ctx *ctx, int64_t until_time_us)
+static void wayland_vk_wait_events(struct ra_ctx *ctx, int64_t until_time_us)
 {
     vo_wayland_wait_events(ctx->vo, until_time_us);
 }
@@ -137,10 +126,10 @@ static void wayland_wait_events(struct ra_ctx *ctx, int64_t until_time_us)
 const struct ra_ctx_fns ra_ctx_vulkan_wayland = {
     .type           = "vulkan",
     .name           = "wayland",
-    .reconfig       = wayland_reconfig,
+    .reconfig       = wayland_vk_reconfig,
-    .control        = wayland_control,
+    .control        = wayland_vk_control,
-    .wakeup         = wayland_wakeup,
+    .wakeup         = wayland_vk_wakeup,
-    .wait_events    = wayland_wait_events,
+    .wait_events    = wayland_vk_wait_events,
-    .init           = wayland_init,
+    .init           = wayland_vk_init,
-    .uninit         = wayland_uninit,
+    .uninit         = wayland_vk_uninit,
 };

video/out/wayland/server-decoration.xml

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="server_decoration">
+  <copyright><![CDATA[
+    Copyright (C) 2015 Martin Gräßlin
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2.1 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  ]]></copyright>
+  <interface  name="org_kde_kwin_server_decoration_manager" version="1">
+      <description summary="Server side window decoration manager">
+        This interface allows to coordinate whether the server should create
+        a server-side window decoration around a wl_surface representing a
+        shell surface (wl_shell_surface or similar). By announcing support
+        for this interface the server indicates that it supports server
+        side decorations.
+      </description>
+      <request name="create">
+        <description summary="Create a server-side decoration object for a given surface">
+            When a client creates a server-side decoration object it indicates
+            that it supports the protocol. The client is supposed to tell the
+            server whether it wants server-side decorations or will provide
+            client-side decorations.
+
+            If the client does not create a server-side decoration object for
+            a surface the server interprets this as lack of support for this
+            protocol and considers it as client-side decorated. Nevertheless a
+            client-side decorated surface should use this protocol to indicate
+            to the server that it does not want a server-side deco.
+        </description>
+        <arg name="id" type="new_id" interface="org_kde_kwin_server_decoration"/>
+        <arg name="surface" type="object" interface="wl_surface"/>
+      </request>
+      <enum name="mode">
+            <description summary="Possible values to use in request_mode and the event mode."/>
+            <entry name="None" value="0" summary="Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated."/>
+            <entry name="Client" value="1" summary="Client-side decoration: The decoration is part of the surface and the client."/>
+            <entry name="Server" value="2" summary="Server-side decoration: The server embeds the surface into a decoration frame."/>
+      </enum>
+      <event name="default_mode">
+          <description summary="The default mode used on the server">
+              This event is emitted directly after binding the interface. It contains
+              the default mode for the decoration. When a new server decoration object
+              is created this new object will be in the default mode until the first
+              request_mode is requested.
+
+              The server may change the default mode at any time.
+          </description>
+          <arg name="mode" type="uint" summary="The default decoration mode applied to newly created server decorations."/>
+      </event>
+  </interface>
+  <interface name="org_kde_kwin_server_decoration" version="1">
+      <request name="release" type="destructor">
+        <description summary="release the server decoration object"/>
+      </request>
+      <enum name="mode">
+            <description summary="Possible values to use in request_mode and the event mode."/>
+            <entry name="None" value="0" summary="Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated."/>
+            <entry name="Client" value="1" summary="Client-side decoration: The decoration is part of the surface and the client."/>
+            <entry name="Server" value="2" summary="Server-side decoration: The server embeds the surface into a decoration frame."/>
+      </enum>
+      <request name="request_mode">
+          <description summary="The decoration mode the surface wants to use."/>
+          <arg name="mode" type="uint" summary="The mode this surface wants to use."/>
+      </request>
+      <event name="mode">
+          <description summary="The new decoration mode applied by the server">
+              This event is emitted directly after the decoration is created and
+              represents the base decoration policy by the server. E.g. a server
+              which wants all surfaces to be client-side decorated will send Client,
+              a server which wants server-side decoration will send Server.
+
+              The client can request a different mode through the decoration request.
+              The server will acknowledge this by another event with the same mode. So
+              even if a server prefers server-side decoration it's possible to force a
+              client-side decoration.
+
+              The server may emit this event at any time. In this case the client can
+              again request a different mode. It's the responsibility of the server to
+              prevent a feedback loop.
+          </description>
+          <arg name="mode" type="uint" summary="The decoration mode applied to the surface by the server."/>
+      </event>
+  </interface>
+</protocol>

video/out/wayland_common.h

@@ -1,6 +1,5 @@
 /*
  * This file is part of mpv video player.
- * Copyright © 2013 Alexander Preisinger <alexander.preisinger@gmail.com>
  *
  * mpv is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,133 +18,100 @@
 #ifndef MPLAYER_WAYLAND_COMMON_H
 #define MPLAYER_WAYLAND_COMMON_H
 
-#include <stdint.h>
-#include <stdbool.h>
 #include <wayland-client.h>
 #include <wayland-cursor.h>
 #include <xkbcommon/xkbcommon.h>
 
-#include "config.h"
+#include "vo.h"
+#include "input/event.h"
 
-#if HAVE_GL_WAYLAND
+typedef void (*vo_wayland_frame_cb)(struct vo_wayland_state *wl, void *priv, uint32_t time);
-#include <wayland-egl.h>
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#endif
-
-struct vo;
 
 struct vo_wayland_output {
-    uint32_t id; /* unique name */
+    uint32_t id;
     struct wl_output *output;
+    struct mp_rect geometry;
+    int width;
+    int height;
+    int scale;
     uint32_t flags;
-    int32_t width;
+    double refresh_rate;
-    int32_t height;
-    int32_t scale;
-    int32_t refresh_rate; // fps (mHz)
     const char *make;
     const char *model;
+    int has_surface;
     struct wl_list link;
 };
 
-typedef void (*vo_wayland_frame_cb)(void *data, uint32_t time);
-
 struct vo_wayland_state {
-    struct vo *vo;
+    struct mp_log        *log;
-    struct mp_log* log;
+    struct vo            *vo;
+    struct wl_display    *display;
+    struct wl_shm        *shm;
+    struct wl_compositor *compositor;
+    struct wl_registry   *registry;
+
+    /* State */
+    struct mp_rect geometry;
+    struct mp_rect window_size;
+    float aspect_ratio;
+    int fullscreen;
+    char *window_title;
     int wakeup_pipe[2];
+    int pending_vo_events;
+    int mouse_x;
+    int mouse_y;
+    int scaling;
+    int touch_entries;
+    uint32_t pointer_id;
+    int display_fd;
+    int configured;
+    vo_wayland_frame_cb callback_exec;
+    void *callback_exec_priv;
+    struct wl_callback       *frame_callback;
+    struct wl_list            output_list;
+    struct vo_wayland_output *current_output;
 
-    struct {
+    /* Shell */
-        void *data;
+    struct wl_surface       *surface;
-        vo_wayland_frame_cb function;
+    struct zxdg_shell_v6    *shell;
-        struct wl_callback *callback;
+    struct zxdg_toplevel_v6 *xdg_toplevel;
-    } frame;
+    struct zxdg_surface_v6  *xdg_surface;
+    struct org_kde_kwin_server_decoration_manager *server_decoration_manager;
+    struct org_kde_kwin_server_decoration *server_decoration;
+    struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager;
+    struct zwp_idle_inhibitor_v1 *idle_inhibitor;
 
-#if HAVE_GL_WAYLAND
+    /* Input */
-    struct {
+    struct wl_seat     *seat;
-        EGLSurface egl_surface;
+    struct wl_pointer  *pointer;
+    struct wl_touch    *touch;
+    struct wl_keyboard *keyboard;
+    struct xkb_context *xkb_context;
+    struct xkb_keymap  *xkb_keymap;
+    struct xkb_state   *xkb_state;
 
-        struct wl_egl_window *egl_window;
+    /* DND */
+    struct wl_data_device_manager *dnd_devman;
+    struct wl_data_device *dnd_ddev;
+    struct wl_data_offer *dnd_offer;
+    enum mp_dnd_action dnd_action;
+    char *dnd_mime_type;
+    int dnd_mime_score;
+    int dnd_fd;
 
-        struct {
+    /* Cursor */
-            EGLDisplay dpy;
+    struct wl_cursor_theme *cursor_theme;
-            EGLContext ctx;
+    struct wl_cursor       *default_cursor;
-            EGLConfig conf;
+    struct wl_surface      *cursor_surface;
-        } egl;
-    } egl_context;
-#endif
-
-    struct {
-        int fd;
-        struct wl_display *display;
-        struct wl_registry *registry;
-        struct wl_compositor *compositor;
-        struct wl_shell *shell;
-
-        struct wl_list output_list;
-        struct wl_output *fs_output; /* fullscreen output */
-        struct vo_wayland_output *current_output;
-
-        int display_fd;
-
-        struct wl_shm *shm;
-
-        struct wl_subcompositor *subcomp;
-    } display;
-
-    struct {
-        int32_t width;    // current size of the window
-        int32_t height;
-        int32_t p_width;  // previous sizes for leaving fullscreen
-        int32_t p_height;
-        int32_t sh_width; // sheduled width for resizing
-        int32_t sh_height;
-        int32_t sh_x;     // x, y calculated with the drag edges for moving
-        int32_t sh_y;
-        float aspect;
-
-        bool is_fullscreen; // don't keep aspect ratio in fullscreen mode
-        int32_t fs_width;   // fullscreen sizes
-        int32_t fs_height;
-
-        struct wl_surface *video_surface;
-        int32_t mouse_x; // mouse position inside the surface
-        int32_t mouse_y;
-        struct wl_shell_surface *shell_surface;
-        int events; /* mplayer events (VO_EVENT_RESIZE) */
-    } window;
-
-    struct {
-        struct wl_cursor *default_cursor;
-        struct wl_cursor_theme *theme;
-        struct wl_surface *surface;
-
-        /* pointer for fading out */
-        bool visible;
-        struct wl_pointer *pointer;
-        uint32_t serial;
-    } cursor;
-
-    struct {
-        struct wl_seat *seat;
-        struct wl_keyboard *keyboard;
-        struct wl_pointer *pointer;
-
-        struct {
-            struct xkb_context *context;
-            struct xkb_keymap *keymap;
-            struct xkb_state *state;
-        } xkb;
-    } input;
 };
 
 int vo_wayland_init(struct vo *vo);
-void vo_wayland_uninit(struct vo *vo);
+int vo_wayland_reconfig(struct vo *vo);
-bool vo_wayland_config(struct vo *vo);
 int vo_wayland_control(struct vo *vo, int *events, int request, void *arg);
+void vo_wayland_check_events(struct vo *vo);
+void vo_wayland_uninit(struct vo *vo);
 void vo_wayland_wakeup(struct vo *vo);
 void vo_wayland_wait_events(struct vo *vo, int64_t until_time_us);
-void vo_wayland_request_frame(struct vo *vo, void *data, vo_wayland_frame_cb cb);
+void vo_wayland_set_cb_exec(struct vo *vo, vo_wayland_frame_cb cb, void *cb_priv);
 
 #endif /* MPLAYER_WAYLAND_COMMON_H */
-

waftools/checks/custom.py

@@ -4,7 +4,7 @@ from waflib import Utils
 import os
 
 __all__ = ["check_pthreads", "check_iconv", "check_lua",
-           "check_cocoa", "check_openal"]
+           "check_cocoa", "check_openal", "check_wl_protocols"]
 
 pthreads_program = load_fragment('pthreads.c')
 
@@ -83,6 +83,15 @@ def check_lua(ctx, dependency_identifier):
             return True
     return False
 
+def check_wl_protocols(ctx, dependency_identifier):
+    def fn(ctx, dependency_identifier):
+        ret = check_pkg_config_datadir("wayland-protocols")
+        ret = ret(ctx, dependency_identifier)
+        if ret != None:
+            ctx.env.WL_PROTO_DIR = ret.split()[0]
+        return ret
+    return fn(ctx, dependency_identifier)
+
 def check_cocoa(ctx, dependency_identifier):
     fn = check_cc(
         fragment         = load_fragment('cocoa.m'),

waftools/checks/generic.py

@@ -7,7 +7,8 @@ __all__ = [
     "check_pkg_config", "check_pkg_config_mixed", "check_pkg_config_mixed_all",
     "check_pkg_config_cflags", "check_cc", "check_statement", "check_libs",
     "check_headers", "compose_checks", "check_true", "any_version",
-    "load_fragment", "check_stub", "check_ctx_vars", "check_program"]
+    "load_fragment", "check_stub", "check_ctx_vars", "check_program",
+    "check_pkg_config_datadir"]
 
 any_version = None
 
@@ -82,6 +83,9 @@ def check_pkg_config_mixed_all(*all_args, **kw_ext):
 def check_pkg_config_cflags(*args, **kw_ext):
     return _check_pkg_config([], ["--cflags"], *args, **kw_ext)
 
+def check_pkg_config_datadir(*args, **kw_ext):
+    return _check_pkg_config([], ["--variable=pkgdatadir"], *args, **kw_ext)
+
 def _check_pkg_config(_dyn_libs, _pkgc_args, *args, **kw_ext):
     def fn(ctx, dependency_identifier, **kw):
         argsl     = list(args)
@@ -113,7 +117,7 @@ def _check_pkg_config(_dyn_libs, _pkgc_args, *args, **kw_ext):
         # added only at its first occurrence.
         original_append_unique  = ConfigSet.append_unique
         ConfigSet.append_unique = ConfigSet.append_value
-        result = bool(ctx.check_cfg(**opts))
+        result = ctx.check_cfg(**opts)
         ConfigSet.append_unique = original_append_unique
 
         defkey = inflector.define_key(dependency_identifier)

waftools/generators/sources.py

@@ -9,6 +9,9 @@ def __zshcomp_cmd__(ctx, argument):
     return '"${{BIN_PERL}}" "{0}/TOOLS/zsh.pl" "{1}" > "${{TGT}}"' \
                 .format(ctx.srcnode.abspath(), argument)
 
+def __wayland_scanner_cmd__(ctx, mode, dir, src):
+    return "${{WAYSCAN}} {0} < {1}/{2} > ${{TGT}}".format(mode, dir, src)
+
 def __file2string__(ctx, **kwargs):
     ctx(
         rule   = __file2string_cmd__(ctx),
@@ -51,5 +54,24 @@ def __zshcomp__(ctx, **kwargs):
         **kwargs
     )
 
-BuildContext.file2string = __file2string__
+def __wayland_protocol_code__(ctx, **kwargs):
-BuildContext.zshcomp = __zshcomp__
+    ctx(
+        rule   = __wayland_scanner_cmd__(ctx, 'code', kwargs['proto_dir'],
+                                         kwargs['protocol'] + '.xml'),
+        name   = os.path.basename(kwargs['target']),
+        **kwargs
+    )
+
+def __wayland_protocol_header__(ctx, **kwargs):
+    ctx(
+        rule   = __wayland_scanner_cmd__(ctx, 'client-header', kwargs['proto_dir'],
+                                         kwargs['protocol'] + '.xml'),
+        before = ('c',),
+        name   = os.path.basename(kwargs['target']),
+        **kwargs
+    )
+
+BuildContext.file2string             = __file2string__
+BuildContext.wayland_protocol_code   = __wayland_protocol_code__
+BuildContext.wayland_protocol_header = __wayland_protocol_header__
+BuildContext.zshcomp                 = __zshcomp__

wscript

@@ -593,9 +593,18 @@ video_output_features = [
         'desc': 'GBM',
         'deps': 'gbm.h',
         'func': check_pkg_config('gbm'),
+    } , {
+        'name': '--wayland-scanner',
+        'desc': 'wayland-scanner',
+        'func': check_program('wayland-scanner', 'WAYSCAN')
+    } , {
+        'name': '--wayland-protocols',
+        'desc': 'wayland-protocols',
+        'func': check_wl_protocols
     } , {
         'name': '--wayland',
         'desc': 'Wayland',
+        'deps': 'wayland-protocols && wayland-scanner',
         'func': check_pkg_config('wayland-client', '>= 1.6.0',
                                  'wayland-cursor', '>= 1.6.0',
                                  'xkbcommon',      '>= 0.3.0'),

wscript_build.py

@@ -116,6 +116,26 @@ def build(ctx):
         target = "player/javascript/defaults.js.inc",
     )
 
+    if ctx.dependency_satisfied('wayland'):
+        ctx.wayland_protocol_code(proto_dir = ctx.env.WL_PROTO_DIR,
+            protocol  = "unstable/xdg-shell/xdg-shell-unstable-v6",
+            target    = "video/out/wayland/xdg-shell-v6.c")
+        ctx.wayland_protocol_header(proto_dir = ctx.env.WL_PROTO_DIR,
+            protocol  = "unstable/xdg-shell/xdg-shell-unstable-v6",
+            target    = "video/out/wayland/xdg-shell-v6.h")
+        ctx.wayland_protocol_code(proto_dir = ctx.env.WL_PROTO_DIR,
+            protocol  = "unstable/idle-inhibit/idle-inhibit-unstable-v1",
+            target    = "video/out/wayland/idle-inhibit-v1.c")
+        ctx.wayland_protocol_header(proto_dir = ctx.env.WL_PROTO_DIR,
+            protocol  = "unstable/idle-inhibit/idle-inhibit-unstable-v1",
+            target    = "video/out/wayland/idle-inhibit-v1.h")
+        ctx.wayland_protocol_code(proto_dir = "../video/out/wayland",
+            protocol = "server-decoration",
+            target   = "video/out/wayland/srv-decor.c")
+        ctx.wayland_protocol_header(proto_dir = "../video/out/wayland",
+            protocol = "server-decoration",
+            target   = "video/out/wayland/srv-decor.h")
+
     ctx(features = "ebml_header", target = "ebml_types.h")
     ctx(features = "ebml_definitions", target = "ebml_defs.c")
 
@@ -454,6 +474,9 @@ def build(ctx):
         ( "video/out/vulkan/spirv_nvidia.c",     "vulkan" ),
         ( "video/out/win32/exclusive_hack.c",    "gl-win32" ),
         ( "video/out/wayland_common.c",          "wayland" ),
+        ( "video/out/wayland/xdg-shell-v6.c",    "wayland" ),
+        ( "video/out/wayland/idle-inhibit-v1.c", "wayland" ),
+        ( "video/out/wayland/srv-decor.c",       "wayland" ),
         ( "video/out/win_state.c"),
         ( "video/out/x11_common.c",              "x11" ),
         ( "video/out/drm_common.c",              "drm" ),