hw/xwayland/xwayland-glamor-gbm.c

@@ -275,11 +275,12 @@ error:
 }
 
 static PixmapPtr
-xwl_glamor_gbm_create_pixmap(ScreenPtr screen,
-                             int width, int height, int depth,
-                             unsigned int hint)
+xwl_glamor_gbm_create_pixmap_internal(struct xwl_screen *xwl_screen,
+                                      DrawablePtr drawable,
+                                      int width, int height, int depth,
+                                      unsigned int hint,
+                                      Bool implicit_scanout)
 {
-    struct xwl_screen *xwl_screen = xwl_screen_get(screen);
     struct xwl_gbm_private *xwl_gbm = xwl_gbm_get(xwl_screen);
     struct gbm_bo *bo = NULL;
     PixmapPtr pixmap = NULL;
@@ -293,10 +294,18 @@ xwl_glamor_gbm_create_pixmap(ScreenPtr screen,
 
 #ifdef GBM_BO_WITH_MODIFIERS
         if (xwl_gbm->dmabuf_capable) {
-            uint32_t num_modifiers;
+            uint32_t num_modifiers = 0;
             uint64_t *modifiers = NULL;
 
-            xwl_glamor_get_modifiers(screen, format, &num_modifiers, &modifiers);
+            if (drawable) {
+                xwl_glamor_get_drawable_modifiers(drawable, format,
+                                                  &num_modifiers, &modifiers);
+            }
+
+            if (num_modifiers == 0) {
+                xwl_glamor_get_modifiers(xwl_screen->screen, format,
+                                         &num_modifiers, &modifiers);
+            }
 
             if (num_modifiers > 0)
                 bo = gbm_bo_create_with_modifiers(xwl_gbm->gbm, width, height,
@@ -305,13 +314,15 @@ xwl_glamor_gbm_create_pixmap(ScreenPtr screen,
         }
 #endif
         if (bo == NULL) {
+            uint32_t usage = GBM_BO_USE_RENDERING;
             implicit = TRUE;
-            bo = gbm_bo_create(xwl_gbm->gbm, width, height, format,
-                               GBM_BO_USE_RENDERING);
+            if (implicit_scanout)
+                usage |= GBM_BO_USE_SCANOUT;
+            bo = gbm_bo_create(xwl_gbm->gbm, width, height, format, usage);
         }
 
         if (bo) {
-            pixmap = xwl_glamor_gbm_create_pixmap_for_bo(screen, bo, depth, implicit);
+            pixmap = xwl_glamor_gbm_create_pixmap_for_bo(xwl_screen->screen, bo, depth, implicit);
 
             if (!pixmap) {
                 gbm_bo_destroy(bo);
@@ -323,11 +334,32 @@ xwl_glamor_gbm_create_pixmap(ScreenPtr screen,
     }
 
     if (!pixmap)
-        pixmap = glamor_create_pixmap(screen, width, height, depth, hint);
+        pixmap = glamor_create_pixmap(xwl_screen->screen, width, height, depth, hint);
 
     return pixmap;
 }
 
+static PixmapPtr
+xwl_glamor_gbm_create_pixmap(ScreenPtr screen,
+                             int width, int height, int depth,
+                             unsigned int hint)
+{
+    return xwl_glamor_gbm_create_pixmap_internal(xwl_screen_get(screen), NULL,
+                                                 width, height, depth, hint, FALSE);
+}
+
+static PixmapPtr
+xwl_glamor_gbm_create_pixmap_for_window(struct xwl_window *xwl_window)
+{
+    return xwl_glamor_gbm_create_pixmap_internal(xwl_window->xwl_screen,
+                                                 &xwl_window->window->drawable,
+                                                 xwl_window->window->drawable.width,
+                                                 xwl_window->window->drawable.height,
+                                                 xwl_window->window->drawable.depth,
+                                                 CREATE_PIXMAP_USAGE_BACKING_PIXMAP,
+                                                 xwl_window->has_implicit_scanout_support);
+}
+
 static Bool
 xwl_glamor_gbm_destroy_pixmap(PixmapPtr pixmap)
 {
@@ -1205,4 +1237,5 @@ xwl_glamor_init_gbm(struct xwl_screen *xwl_screen)
     xwl_screen->gbm_backend.is_available = TRUE;
     xwl_screen->gbm_backend.backend_flags = XWL_EGL_BACKEND_NEEDS_BUFFER_FLUSH |
                                             XWL_EGL_BACKEND_NEEDS_N_BUFFERING;
+    xwl_screen->gbm_backend.create_pixmap_for_window = xwl_glamor_gbm_create_pixmap_for_window;
 }

hw/xwayland/xwayland-glamor.c

@@ -43,6 +43,7 @@
 #include "xwayland-glx.h"
 #include "xwayland-screen.h"
 #include "xwayland-window.h"
+#include "xwayland-window-buffers.h"
 
 #include <sys/mman.h>
 
@@ -124,11 +125,15 @@ xwl_glamor_is_modifier_supported_in_formats(struct xwl_format *formats, int num_
 
 static Bool
 xwl_feedback_is_modifier_supported(struct xwl_dmabuf_feedback *xwl_feedback,
-                                   uint32_t format, uint64_t modifier)
+                                   uint32_t format, uint64_t modifier,
+                                   int supports_scanout)
 {
     for (int i = 0; i < xwl_feedback->dev_formats_len; i++) {
         struct xwl_device_formats *dev_formats = &xwl_feedback->dev_formats[i];
 
+        if (supports_scanout && !dev_formats->supports_scanout)
+            continue;
+
         if (xwl_glamor_is_modifier_supported_in_formats(dev_formats->formats,
                                                         dev_formats->num_formats,
                                                         format, modifier))
@@ -157,11 +162,11 @@ xwl_glamor_is_modifier_supported(struct xwl_screen *xwl_screen,
                                                            format, modifier);
     }
 
-    if (xwl_feedback_is_modifier_supported(&xwl_screen->default_feedback, format, modifier))
+    if (xwl_feedback_is_modifier_supported(&xwl_screen->default_feedback, format, modifier, FALSE))
         return TRUE;
 
     xorg_list_for_each_entry(xwl_window, &xwl_screen->window_list, link_window) {
-        if (xwl_feedback_is_modifier_supported(&xwl_window->feedback, format, modifier))
+        if (xwl_feedback_is_modifier_supported(&xwl_window->feedback, format, modifier, FALSE))
             return TRUE;
     }
 
@@ -659,24 +664,6 @@ static const struct zwp_linux_dmabuf_feedback_v1_listener xwl_dmabuf_feedback_li
     .tranche_flags = xwl_dmabuf_feedback_tranche_flags,
 };
 
-Bool
-xwl_dmabuf_setup_feedback_for_window(struct xwl_window *xwl_window)
-{
-    struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
-
-    xwl_window->feedback.dmabuf_feedback =
-        zwp_linux_dmabuf_v1_get_surface_feedback(xwl_screen->dmabuf, xwl_window->surface);
-
-    if (!xwl_window->feedback.dmabuf_feedback)
-        return FALSE;
-
-    zwp_linux_dmabuf_feedback_v1_add_listener(xwl_window->feedback.dmabuf_feedback,
-                                              &xwl_dmabuf_feedback_listener,
-                                              &xwl_window->feedback);
-
-    return TRUE;
-}
-
 Bool
 xwl_screen_set_dmabuf_interface(struct xwl_screen *xwl_screen,
                                 uint32_t id, uint32_t version)
@@ -707,6 +694,115 @@ xwl_screen_set_dmabuf_interface(struct xwl_screen *xwl_screen,
     return TRUE;
 }
 
+static void
+xwl_window_dmabuf_feedback_main_device(void *data,
+                                       struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                       struct wl_array *dev)
+{
+    struct xwl_window *xwl_window = data;
+
+    xwl_dmabuf_feedback_main_device(&xwl_window->feedback, dmabuf_feedback, dev);
+}
+
+static void
+xwl_window_dmabuf_feedback_tranche_target_device(void *data,
+                                                 struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                                 struct wl_array *dev)
+{
+    struct xwl_window *xwl_window = data;
+
+    xwl_dmabuf_feedback_tranche_target_device(&xwl_window->feedback, dmabuf_feedback, dev);
+}
+
+static void
+xwl_window_dmabuf_feedback_tranche_flags(void *data,
+                                         struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                         uint32_t flags)
+{
+    struct xwl_window *xwl_window = data;
+
+    xwl_dmabuf_feedback_tranche_flags(&xwl_window->feedback, dmabuf_feedback, flags);
+}
+
+static void
+xwl_window_dmabuf_feedback_tranche_formats(void *data,
+                                           struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                           struct wl_array *indices)
+{
+    struct xwl_window *xwl_window = data;
+
+    xwl_dmabuf_feedback_tranche_formats(&xwl_window->feedback, dmabuf_feedback, indices);
+}
+
+static void
+xwl_window_dmabuf_feedback_tranche_done(void *data,
+                                        struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback)
+{
+    struct xwl_window *xwl_window = data;
+
+    xwl_dmabuf_feedback_tranche_done(&xwl_window->feedback, dmabuf_feedback);
+}
+
+static void
+xwl_window_dmabuf_feedback_done(void *data,
+                                struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback)
+{
+    struct xwl_window *xwl_window = data;
+    uint32_t format = wl_drm_format_for_depth(xwl_window->window->drawable.depth);
+
+    xwl_dmabuf_feedback_done(&xwl_window->feedback, dmabuf_feedback);
+
+    xwl_window->has_implicit_scanout_support =
+        xwl_feedback_is_modifier_supported(&xwl_window->feedback, format,
+                                           DRM_FORMAT_MOD_INVALID, TRUE);
+    DebugF("XWAYLAND: Window 0x%x can%s get implicit scanout support\n",
+            xwl_window->window->drawable.id,
+            xwl_window->has_implicit_scanout_support ? "" : "not");
+
+    /* If the linux-dmabuf v4 per-surface feedback changed, recycle the
+     * window buffers so that they get re-created with appropriate parameters.
+     */
+    xwl_window_buffers_recycle(xwl_window);
+}
+
+static void
+xwl_window_dmabuf_feedback_format_table(void *data,
+                                        struct zwp_linux_dmabuf_feedback_v1 *dmabuf_feedback,
+                                        int32_t fd, uint32_t size)
+{
+    struct xwl_window *xwl_window = data;
+
+    xwl_dmabuf_feedback_format_table(&xwl_window->feedback, dmabuf_feedback, fd, size);
+}
+
+static const struct zwp_linux_dmabuf_feedback_v1_listener xwl_window_dmabuf_feedback_listener = {
+    .done = xwl_window_dmabuf_feedback_done,
+    .format_table = xwl_window_dmabuf_feedback_format_table,
+    .main_device = xwl_window_dmabuf_feedback_main_device,
+    .tranche_done = xwl_window_dmabuf_feedback_tranche_done,
+    .tranche_target_device = xwl_window_dmabuf_feedback_tranche_target_device,
+    .tranche_formats = xwl_window_dmabuf_feedback_tranche_formats,
+    .tranche_flags = xwl_window_dmabuf_feedback_tranche_flags,
+};
+
+Bool
+xwl_dmabuf_setup_feedback_for_window(struct xwl_window *xwl_window)
+{
+    struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
+
+    xwl_window->feedback.dmabuf_feedback =
+        zwp_linux_dmabuf_v1_get_surface_feedback(xwl_screen->dmabuf, xwl_window->surface);
+
+    if (!xwl_window->feedback.dmabuf_feedback)
+        return FALSE;
+
+    zwp_linux_dmabuf_feedback_v1_add_listener(xwl_window->feedback.dmabuf_feedback,
+                                              &xwl_window_dmabuf_feedback_listener,
+                                              xwl_window);
+
+    return TRUE;
+}
+
 void
 xwl_glamor_init_wl_registry(struct xwl_screen *xwl_screen,
                             struct wl_registry *registry,
@@ -829,6 +925,20 @@ xwl_glamor_needs_n_buffering(struct xwl_screen *xwl_screen)
                 XWL_EGL_BACKEND_NEEDS_N_BUFFERING);
 }
 
+PixmapPtr
+xwl_glamor_create_pixmap_for_window(struct xwl_window *xwl_window)
+{
+    struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
+
+    if (!xwl_screen->glamor || !xwl_screen->egl_backend)
+        return NullPixmap;
+
+    if (xwl_screen->egl_backend->create_pixmap_for_window)
+        return xwl_screen->egl_backend->create_pixmap_for_window(xwl_window);
+    else
+        return NullPixmap;
+}
+
 void
 xwl_glamor_init_backends(struct xwl_screen *xwl_screen, Bool use_eglstream)
 {

hw/xwayland/xwayland-glamor.h

@@ -104,6 +104,9 @@ struct xwl_egl_backend {
      * is set up on.
      */
     drmDevice *(*get_main_device)(struct xwl_screen *xwl_screen);
+
+    /* Direct hook to create the backing pixmap for a window */
+    PixmapPtr (*create_pixmap_for_window)(struct xwl_window *xwl_window);
 };
 
 #ifdef XWL_HAS_GLAMOR
@@ -142,6 +145,7 @@ Bool xwl_glamor_get_modifiers(ScreenPtr screen, uint32_t format,
 Bool xwl_glamor_get_drawable_modifiers(DrawablePtr drawable, uint32_t format,
                                        uint32_t *num_modifiers, uint64_t **modifiers);
 Bool xwl_glamor_check_flip(PixmapPtr pixmap);
+PixmapPtr xwl_glamor_create_pixmap_for_window (struct xwl_window *xwl_window);
 
 #ifdef XV
 /* glamor Xv Adaptor */

hw/xwayland/xwayland-window-buffers.c

@@ -328,12 +328,19 @@ xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
             pBox++;
         }
     } else {
+#ifdef XWL_HAS_GLAMOR
+        /* Try the xwayland/glamor direct hook first */
         xwl_window_buffer->pixmap =
-            (*xwl_screen->screen->CreatePixmap) (window_pixmap->drawable.pScreen,
-                                                 window_pixmap->drawable.width,
-                                                 window_pixmap->drawable.height,
-                                                 window_pixmap->drawable.depth,
-                                                 CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
+            xwl_glamor_create_pixmap_for_window(xwl_window);
+#endif /* XWL_HAS_GLAMOR */
+        if (!xwl_window_buffer->pixmap) {
+            xwl_window_buffer->pixmap =
+                (*xwl_screen->screen->CreatePixmap) (window_pixmap->drawable.pScreen,
+                                                     window_pixmap->drawable.width,
+                                                     window_pixmap->drawable.height,
+                                                     window_pixmap->drawable.depth,
+                                                     CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
+        }
 
         if (!xwl_window_buffer->pixmap)
             return window_pixmap;

hw/xwayland/xwayland-window.h

@@ -119,6 +119,8 @@ struct xwl_window {
 #endif
     struct xwayland_surface_v1 *xwayland_surface;
     struct xwl_dmabuf_feedback feedback;
+    /* If TRUE, the window buffer format supports scanout with implicit modifier */
+    Bool has_implicit_scanout_support;
 };
 
 struct xwl_window *xwl_window_get(WindowPtr window);