1 files changed, 34 insertions, 123 deletions

diff --git a/video/out/opengl/context_wayland.c b/video/out/opengl/context_wayland.c
index 95ea9f65e0..e091220349 100644
--- a/video/out/opengl/context_wayland.c
+++ b/video/out/opengl/context_wayland.c
@@ -20,14 +20,12 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
+#include "video/out/present_sync.h"
 #include "video/out/wayland_common.h"
 #include "context.h"
 #include "egl_helpers.h"
 #include "utils.h"
 
-// Generated from presentation-time.xml
-#include "generated/wayland/presentation-time.h"
-
 #define EGL_PLATFORM_WAYLAND_EXT 0x31D8
 
 struct priv {
@@ -39,79 +37,6 @@ struct priv {
     struct wl_egl_window *egl_window;
 };
 
-static const struct wp_presentation_feedback_listener feedback_listener;
-
-static void feedback_sync_output(void *data, struct wp_presentation_feedback *fback,
-                               struct wl_output *output)
-{
-}
-
-static void feedback_presented(void *data, struct wp_presentation_feedback *fback,
-                              uint32_t tv_sec_hi, uint32_t tv_sec_lo,
-                              uint32_t tv_nsec, uint32_t refresh_nsec,
-                              uint32_t seq_hi, uint32_t seq_lo,
-                              uint32_t flags)
-{
-    struct vo_wayland_state *wl = data;
-    vo_wayland_sync_shift(wl);
-
-    if (fback)
-        wp_presentation_feedback_destroy(fback);
-
-    // Very similar to oml_sync_control, in this case we assume that every
-    // time the compositor receives feedback, a buffer swap has been already
-    // been performed.
-    //
-    // Notes:
-    //  - tv_sec_lo + tv_sec_hi is the equivalent of oml's ust
-    //  - seq_lo + seq_hi is the equivalent of oml's msc
-    //  - these values are updated everytime the compositor receives feedback.
-
-    int index = last_available_sync(wl);
-    if (index < 0) {
-        queue_new_sync(wl);
-        index = 0;
-    }
-    int64_t sec = (uint64_t) tv_sec_lo + ((uint64_t) tv_sec_hi << 32);
-    wl->sync[index].ust = sec * 1000000LL + (uint64_t) tv_nsec / 1000;
-    wl->sync[index].msc = (uint64_t) seq_lo + ((uint64_t) seq_hi << 32);
-    wl->sync[index].filled = true;
-}
-
-static void feedback_discarded(void *data, struct wp_presentation_feedback *fback)
-{
-}
-
-static const struct wp_presentation_feedback_listener feedback_listener = {
-    feedback_sync_output,
-    feedback_presented,
-    feedback_discarded,
-};
-
-static const struct wl_callback_listener frame_listener;
-
-static void frame_callback(void *data, struct wl_callback *callback, uint32_t time)
-{
-    struct vo_wayland_state *wl = data;
-
-    if (callback)
-        wl_callback_destroy(callback);
-
-    wl->frame_callback = wl_surface_frame(wl->surface);
-    wl_callback_add_listener(wl->frame_callback, &frame_listener, wl);
-
-    if (wl->presentation) {
-        wl->feedback = wp_presentation_feedback(wl->presentation, wl->surface);
-        wp_presentation_feedback_add_listener(wl->feedback, &feedback_listener, wl);
-    }
-
-    wl->frame_wait = false;
-}
-
-static const struct wl_callback_listener frame_listener = {
-    frame_callback,
-};
-
 static void resize(struct ra_ctx *ctx)
 {
     struct priv *p = ctx->priv;
@@ -119,40 +44,26 @@ static void resize(struct ra_ctx *ctx)
 
     MP_VERBOSE(wl, "Handling resize on the egl side\n");
 
-    const int32_t width = wl->scaling * mp_rect_w(wl->geometry);
-    const int32_t height = wl->scaling * mp_rect_h(wl->geometry);
+    const int32_t width = mp_rect_w(wl->geometry);
+    const int32_t height = mp_rect_h(wl->geometry);
 
-    vo_wayland_set_opaque_region(wl, ctx->opts.want_alpha);
-    wl_surface_set_buffer_scale(wl->surface, wl->scaling);
+    vo_wayland_handle_scale(wl);
 
+    vo_wayland_set_opaque_region(wl, ctx->opts.want_alpha);
     if (p->egl_window)
         wl_egl_window_resize(p->egl_window, width, height, 0, 0);
 
-    if (!wl->vo_opts->fullscreen && !wl->vo_opts->window_maximized)
-        wl_surface_commit(wl->surface);
     wl->vo->dwidth  = width;
     wl->vo->dheight = height;
 }
 
-static bool wayland_egl_start_frame(struct ra_swapchain *sw, struct ra_fbo *out_fbo)
+static bool wayland_egl_check_visible(struct ra_ctx *ctx)
 {
-    struct ra_ctx *ctx = sw->ctx;
-    struct vo_wayland_state *wl = ctx->vo->wl;
-
-    bool render = !wl->hidden || wl->opts->disable_vsync;
-
-    if (wl->frame_wait && wl->presentation)
-        vo_wayland_sync_clear(wl);
-
-    if (render)
-        wl->frame_wait = true;
-
-    return render ? ra_gl_ctx_start_frame(sw, out_fbo) : false;
+    return vo_wayland_check_visible(ctx->vo);
 }
 
-static void wayland_egl_swap_buffers(struct ra_swapchain *sw)
+static void wayland_egl_swap_buffers(struct ra_ctx *ctx)
 {
-    struct ra_ctx *ctx = sw->ctx;
     struct priv *p = ctx->priv;
     struct vo_wayland_state *wl = ctx->vo->wl;
 
@@ -161,23 +72,15 @@ static void wayland_egl_swap_buffers(struct ra_swapchain *sw)
     if (!wl->opts->disable_vsync)
         vo_wayland_wait_frame(wl);
 
-    if (wl->presentation)
-        wayland_sync_swap(wl);
+    if (wl->use_present)
+        present_sync_swap(wl->present);
 }
 
-static const struct ra_swapchain_fns wayland_egl_swapchain = {
-    .start_frame   = wayland_egl_start_frame,
-    .swap_buffers  = wayland_egl_swap_buffers,
-};
-
 static void wayland_egl_get_vsync(struct ra_ctx *ctx, struct vo_vsync_info *info)
 {
     struct vo_wayland_state *wl = ctx->vo->wl;
-    if (wl->presentation) {
-        info->vsync_duration = wl->vsync_duration;
-        info->skipped_vsyncs = wl->last_skipped_vsyncs;
-        info->last_queue_display_time = wl->last_queue_display_time;
-    }
+    if (wl->use_present)
+        present_sync_get_info(wl->present, info);
 }
 
 static bool egl_create_context(struct ra_ctx *ctx)
@@ -202,8 +105,9 @@ static bool egl_create_context(struct ra_ctx *ctx)
     mpegl_load_functions(&p->gl, wl->log);
 
     struct ra_gl_ctx_params params = {
-        .external_swapchain = &wayland_egl_swapchain,
-        .get_vsync          = &wayland_egl_get_vsync,
+        .check_visible      = wayland_egl_check_visible,
+        .swap_buffers       = wayland_egl_swap_buffers,
+        .get_vsync          = wayland_egl_get_vsync,
     };
 
     if (!ra_gl_ctx_init(ctx, &p->gl, params))
@@ -211,9 +115,6 @@ static bool egl_create_context(struct ra_ctx *ctx)
 
     ra_add_native_resource(ctx->ra, "wl", wl->display);
 
-    wl->frame_callback = wl_surface_frame(wl->surface);
-    wl_callback_add_listener(wl->frame_callback, &frame_listener, wl);
-
     return true;
 }
 
@@ -222,13 +123,25 @@ static void egl_create_window(struct ra_ctx *ctx)
     struct priv *p = ctx->priv;
     struct vo_wayland_state *wl = ctx->vo->wl;
 
-    p->egl_window = wl_egl_window_create(wl->surface, mp_rect_w(wl->geometry),
+    p->egl_window = wl_egl_window_create(wl->surface,
+                                         mp_rect_w(wl->geometry),
                                          mp_rect_h(wl->geometry));
 
-    p->egl_surface = eglCreateWindowSurface(p->egl_display, p->egl_config,
-                                            p->egl_window, NULL);
+    p->egl_surface = mpegl_create_window_surface(
+        p->egl_display, p->egl_config, p->egl_window);
+    if (p->egl_surface == EGL_NO_SURFACE) {
+        p->egl_surface = eglCreateWindowSurface(
+            p->egl_display, p->egl_config, p->egl_window, NULL);
+    }
 
     eglMakeCurrent(p->egl_display, p->egl_surface, p->egl_surface, p->egl_context);
+    // eglMakeCurrent may not configure the draw or read buffers if the context
+    // has been made current previously. On nvidia GL_NONE is bound because EGL_NO_SURFACE
+    // is used initially and we must bind the read and draw buffers here.
+    if(!p->gl.es) {
+        p->gl.ReadBuffer(GL_BACK);
+        p->gl.DrawBuffer(GL_BACK);
+    }
 
     eglSwapInterval(p->egl_display, 0);
 }
@@ -285,9 +198,9 @@ static void wayland_egl_wakeup(struct ra_ctx *ctx)
     vo_wayland_wakeup(ctx->vo);
 }
 
-static void wayland_egl_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_ns)
 {
-    vo_wayland_wait_events(ctx->vo, until_time_us);
+    vo_wayland_wait_events(ctx->vo, until_time_ns);
 }
 
 static void wayland_egl_update_render_opts(struct ra_ctx *ctx)
@@ -299,17 +212,15 @@ static void wayland_egl_update_render_opts(struct ra_ctx *ctx)
 
 static bool wayland_egl_init(struct ra_ctx *ctx)
 {
-    if (!vo_wayland_init(ctx->vo)) {
-        vo_wayland_uninit(ctx->vo);
+    if (!vo_wayland_init(ctx->vo))
         return false;
-    }
-
     return egl_create_context(ctx);
 }
 
 const struct ra_ctx_fns ra_ctx_wayland_egl = {
     .type               = "opengl",
     .name               = "wayland",
+    .description        = "Wayland/EGL",
     .reconfig           = wayland_egl_reconfig,
     .control            = wayland_egl_control,
     .wakeup             = wayland_egl_wakeup,