.gitlab-ci/debian-install.sh

@@ -34,7 +34,6 @@ apt-get install -y \
 	libcairo2 \
 	libcairo2-dev \
 	libdbus-1-dev \
-	libdmx-dev \
 	libdrm-dev \
 	libegl1-mesa-dev \
 	libepoxy-dev \

Xext/panoramiX.c

@@ -27,10 +27,6 @@ Equipment Corporation.
 #include <dix-config.h>
 #endif
 
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
 #include <stdio.h>
 #include <X11/X.h>
 #include <X11/Xproto.h>

dix/dix_priv.h

@@ -15,4 +15,8 @@
 #define MAX_BIG_REQUEST_SIZE 4194303
 extern long maxBigRequestSize;
 
+void ClearWorkQueue(void);
+void ProcessWorkQueue(void);
+void ProcessWorkQueueZombies(void);
+
 #endif /* _XSERVER_DIX_PRIV_H */

dix/dixutils.c

@@ -86,6 +86,9 @@ Author:  Adobe Systems Incorporated
 
 #include <X11/X.h>
 #include <X11/Xmd.h>
+
+#include "dix/dix_priv.h"
+
 #include "misc.h"
 #include "windowstr.h"
 #include "dixstruct.h"

dix/events.c

@@ -3245,60 +3245,6 @@ WindowsRestructured(void)
     }
 }
 
-#ifdef PANORAMIX
-/* This was added to support reconfiguration under Xdmx.  The problem is
- * that if the 0th screen (i.e., screenInfo.screens[0]) is moved to an origin
- * other than 0,0, the information in the private sprite structure must
- * be updated accordingly, or XYToWindow (and other routines) will not
- * compute correctly. */
-void
-ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
-{
-    GrabPtr grab;
-    DeviceIntPtr pDev;
-    SpritePtr pSprite;
-
-    if (noPanoramiXExtension)
-        return;
-
-    pDev = inputInfo.devices;
-    while (pDev) {
-        if (DevHasCursor(pDev)) {
-            pSprite = pDev->spriteInfo->sprite;
-            pSprite->hot.x -= xoff;
-            pSprite->hot.y -= yoff;
-
-            pSprite->hotPhys.x -= xoff;
-            pSprite->hotPhys.y -= yoff;
-
-            pSprite->hotLimits.x1 -= xoff;
-            pSprite->hotLimits.y1 -= yoff;
-            pSprite->hotLimits.x2 -= xoff;
-            pSprite->hotLimits.y2 -= yoff;
-
-            if (RegionNotEmpty(&pSprite->Reg1))
-                RegionTranslate(&pSprite->Reg1, xoff, yoff);
-            if (RegionNotEmpty(&pSprite->Reg2))
-                RegionTranslate(&pSprite->Reg2, xoff, yoff);
-
-            /* FIXME: if we call ConfineCursorToWindow, must we do anything else? */
-            if ((grab = pDev->deviceGrab.grab) && grab->confineTo) {
-                if (grab->confineTo->drawable.pScreen
-                    != pSprite->hotPhys.pScreen)
-                    pSprite->hotPhys.x = pSprite->hotPhys.y = 0;
-                ConfineCursorToWindow(pDev, grab->confineTo, TRUE, TRUE);
-            }
-            else
-                ConfineCursorToWindow(pDev,
-                                      pSprite->hotPhys.pScreen->root,
-                                      TRUE, FALSE);
-
-        }
-        pDev = pDev->next;
-    }
-}
-#endif
-
 /**
  * Initialize a sprite for the given device and set it to some sane values. If
  * the device already has a sprite alloc'd, don't realloc but just reset to

dix/main.c

@@ -83,6 +83,7 @@ Equipment Corporation.
 #include <X11/Xproto.h>
 #include <pixman.h>
 
+#include "dix/dix_priv.h"
 #include "dix/registry_priv.h"
 
 #include "scrnintstr.h"

dix/protocol.txt

@@ -51,24 +51,6 @@ R003 DAMAGE:Subtract
 R004 DAMAGE:Add
 V000 DAMAGE:Notify
 E000 DAMAGE:BadDamage
-R000 DMX:DMXQueryVersion
-R001 DMX:DMXGetScreenCount
-R002 DMX:DMXGetScreenInfoDEPRECATED
-R003 DMX:DMXGetWindowAttributes
-R004 DMX:DMXGetInputCount
-R005 DMX:DMXGetInputAttributes
-R006 DMX:DMXForceWindowCreationDEPRECATED
-R007 DMX:DMXReconfigureScreenDEPRECATED
-R008 DMX:DMXSync
-R009 DMX:DMXForceWindowCreation
-R010 DMX:DMXGetScreenAttributes
-R011 DMX:DMXChangeScreensAttributes
-R012 DMX:DMXAddScreen
-R013 DMX:DMXRemoveScreen
-R014 DMX:DMXGetDesktopAttributes
-R015 DMX:DMXChangeDesktopAttributes
-R016 DMX:DMXAddInput
-R017 DMX:DMXRemoveInput
 R000 DOUBLE-BUFFER:GetVersion
 R001 DOUBLE-BUFFER:AllocateBackBufferName
 R002 DOUBLE-BUFFER:DeallocateBackBufferName

hw/xwayland/xwayland-glamor-gbm.c

@@ -396,11 +396,14 @@ xwl_glamor_gbm_create_pixmap(ScreenPtr screen,
 static PixmapPtr
 xwl_glamor_gbm_create_pixmap_for_window(struct xwl_window *xwl_window)
 {
+    WindowPtr window = xwl_window->window;
+    unsigned border_width = 2 * window->borderWidth;
+
     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,
+                                                 &window->drawable,
+                                                 window->drawable.width + border_width,
+                                                 window->drawable.height + border_width,
+                                                 window->drawable.depth,
                                                  CREATE_PIXMAP_USAGE_BACKING_PIXMAP,
                                                  xwl_window->has_implicit_scanout_support);
 }

hw/xwayland/xwayland-glamor.c

@@ -790,7 +790,7 @@ xwl_window_dmabuf_feedback_done(void *data,
      * window buffers get re-created with appropriate parameters.
      */
     xwl_window_buffers_dispose(xwl_window);
-    xwl_window_recycle_pixmap(xwl_window);
+    xwl_window_realloc_pixmap(xwl_window);
 }
 
 static void
@@ -874,9 +874,10 @@ xwl_glamor_pixmap_get_wl_buffer(PixmapPtr pixmap)
 
 Bool
 xwl_glamor_post_damage(struct xwl_window *xwl_window,
-                       PixmapPtr pixmap, RegionPtr region)
+                       PixmapPtr pixmap)
 {
     struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
+    RegionPtr region = xwl_window_get_damage_region(xwl_window);
 
     if (xwl_screen->egl_backend->post_damage)
         return xwl_screen->egl_backend->post_damage(xwl_window, pixmap, region);

hw/xwayland/xwayland-glamor.h

@@ -137,7 +137,7 @@ void xwl_glamor_init_wl_registry(struct xwl_screen *xwl_screen,
 Bool xwl_glamor_has_wl_interfaces(struct xwl_screen *xwl_screen,
                                  struct xwl_egl_backend *xwl_egl_backend);
 Bool xwl_glamor_post_damage(struct xwl_window *xwl_window,
-                            PixmapPtr pixmap, RegionPtr region);
+                            PixmapPtr pixmap);
 Bool xwl_glamor_allow_commits(struct xwl_window *xwl_window);
 void xwl_glamor_egl_make_current(struct xwl_screen *xwl_screen);
 Bool xwl_glamor_needs_buffer_flush(struct xwl_screen *xwl_screen);

hw/xwayland/xwayland-pixmap.h

@@ -45,4 +45,10 @@ void xwl_pixmap_del_buffer_release_cb(PixmapPtr pixmap);
 void xwl_pixmap_buffer_release_cb(void *data, struct wl_buffer *wl_buffer);
 Bool xwl_pixmap_init(void);
 
+static inline Bool
+xwl_is_client_pixmap(PixmapPtr pixmap)
+{
+    return clients[CLIENT_ID(pixmap->drawable.id)] != serverClient;
+}
+
 #endif /* XWAYLAND_PIXMAP_H */

hw/xwayland/xwayland-present.c

@@ -35,6 +35,7 @@
 #include "xwayland-screen.h"
 #include "xwayland-shm.h"
 #include "xwayland-window.h"
+#include "xwayland-window-buffers.h"
 #include "xwayland-pixmap.h"
 
 #include "tearing-control-v1-client-protocol.h"
@@ -833,7 +834,6 @@ xwl_present_flip(present_vblank_ptr vblank, RegionPtr damage)
     }
 
     wl_display_flush(xwl_window->xwl_screen->display);
-    xwl_window->present_flipped = TRUE;
     return TRUE;
 }
 
@@ -890,6 +890,8 @@ xwl_present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
 
             if (xwl_present_flip(vblank, damage)) {
                 WindowPtr toplvl_window = xwl_present_toplvl_pixmap_window(vblank->window);
+                struct xwl_window *xwl_window = xwl_window_from_window(window);
+                struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
                 PixmapPtr old_pixmap = screen->GetWindowPixmap(window);
 
                 /* Replace window pixmap with flip pixmap */
@@ -906,10 +908,19 @@ xwl_present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
                 vblank->pixmap->refcnt++;
                 dixDestroyPixmap(old_pixmap, old_pixmap->drawable.id);
 
-                /* Report damage */
+                /* Report damage, let damage_report ignore it though */
+                xwl_screen->ignore_damage = TRUE;
                 DamageDamageRegion(&vblank->window->drawable, damage);
+                xwl_screen->ignore_damage = FALSE;
                 RegionDestroy(damage);
 
+                /* Clear damage region, to ensure damage_report is called before
+                 * any drawing to the window
+                 */
+                xwl_window_buffer_add_damage_region(xwl_window);
+                RegionEmpty(xwl_window_get_damage_region(xwl_window));
+                xorg_list_del(&xwl_window->link_damage);
+
                 /* Put pending flip at the flip queue head */
                 xorg_list_add(&vblank->event_queue, &xwl_present_window->flip_queue);
 

hw/xwayland/xwayland-screen.h

@@ -90,6 +90,7 @@ struct xwl_screen {
     struct xorg_list seat_list;
     struct xorg_list damage_window_list;
     struct xorg_list window_list;
+    Bool ignore_damage;
 
     int wayland_fd;
     struct wl_display *display;

hw/xwayland/xwayland-window-buffers.c

@@ -78,8 +78,7 @@ xwl_window_buffer_new(struct xwl_window *xwl_window)
     xwl_window_buffer->pixmap = NullPixmap;
     xwl_window_buffer->refcnt = 1;
 
-    xorg_list_append(&xwl_window_buffer->link_buffer,
-                     &xwl_window->window_buffers_available);
+    xorg_list_init(&xwl_window_buffer->link_buffer);
 
     return xwl_window_buffer;
 }
@@ -113,10 +112,10 @@ xwl_window_buffer_maybe_dispose(struct xwl_window_buffer *xwl_window_buffer)
     return TRUE;
 }
 
-static void
-xwl_window_buffer_add_damage_region(struct xwl_window *xwl_window,
-                                    RegionPtr damage_region)
+void
+xwl_window_buffer_add_damage_region(struct xwl_window *xwl_window)
 {
+    RegionPtr region = xwl_window_get_damage_region(xwl_window);
     struct xwl_window_buffer *xwl_window_buffer;
 
     /* Add damage region to all buffers */
@@ -125,14 +124,14 @@ xwl_window_buffer_add_damage_region(struct xwl_window *xwl_window,
                              link_buffer) {
         RegionUnion(xwl_window_buffer->damage_region,
                     xwl_window_buffer->damage_region,
-                    damage_region);
+                    region);
     }
     xorg_list_for_each_entry(xwl_window_buffer,
                              &xwl_window->window_buffers_unavailable,
                              link_buffer) {
         RegionUnion(xwl_window_buffer->damage_region,
                     xwl_window_buffer->damage_region,
-                    damage_region);
+                    region);
     }
 }
 
@@ -309,7 +308,7 @@ xwl_window_allocate_pixmap(struct xwl_window *xwl_window)
 }
 
 void
-xwl_window_recycle_pixmap(struct xwl_window *xwl_window)
+xwl_window_realloc_pixmap(struct xwl_window *xwl_window)
 {
     PixmapPtr window_pixmap, new_window_pixmap;
     WindowPtr window;
@@ -332,21 +331,15 @@ xwl_window_recycle_pixmap(struct xwl_window *xwl_window)
 }
 
 PixmapPtr
-xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
-                              RegionPtr damage_region)
+xwl_window_swap_pixmap(struct xwl_window *xwl_window)
 {
     struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
     struct xwl_window_buffer *xwl_window_buffer;
-    PixmapPtr window_pixmap, new_window_pixmap;
+    PixmapPtr window_pixmap;
 
     window_pixmap = (*xwl_screen->screen->GetWindowPixmap) (xwl_window->window);
 
-#ifdef XWL_HAS_GLAMOR
-    if (!xwl_glamor_needs_n_buffering(xwl_screen))
-        return window_pixmap;
-#endif /* XWL_HAS_GLAMOR */
-
-    xwl_window_buffer_add_damage_region(xwl_window, damage_region);
+    xwl_window_buffer_add_damage_region(xwl_window);
 
     xwl_window_buffer = xwl_window_buffer_get_available(xwl_window);
     if (xwl_window_buffer) {
@@ -354,11 +347,9 @@ xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
         BoxPtr pBox = RegionRects(full_damage);
         int nBox = RegionNumRects(full_damage);
 
-        new_window_pixmap = xwl_window_buffer->pixmap;
-
         while (nBox--) {
             copy_pixmap_area(window_pixmap,
-                             new_window_pixmap,
+                             xwl_window_buffer->pixmap,
                              pBox->x1 + xwl_window->window->borderWidth,
                              pBox->y1 + xwl_window->window->borderWidth,
                              pBox->x2 - pBox->x1,
@@ -368,20 +359,25 @@ xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
         }
 
         RegionEmpty(xwl_window_buffer->damage_region);
-    } else {
-        xwl_window_buffer = xwl_window_buffer_new(xwl_window);
+        xorg_list_del(&xwl_window_buffer->link_buffer);
+        xwl_window_set_pixmap(xwl_window->window, xwl_window_buffer->pixmap);
 
-        new_window_pixmap = xwl_window_allocate_pixmap(xwl_window);
-        if (!new_window_pixmap) {
+        /* Can't re-use client pixmap as a window buffer */
+        if (xwl_is_client_pixmap(window_pixmap)) {
+            xwl_window_buffer->pixmap = NULL;
             xwl_window_buffer_maybe_dispose(xwl_window_buffer);
             return window_pixmap;
         }
+    } else {
+        /* Can't re-use client pixmap as a window buffer */
+        if (!xwl_is_client_pixmap(window_pixmap))
+            xwl_window_buffer = xwl_window_buffer_new(xwl_window);
 
-        copy_pixmap_area(window_pixmap,
-                         new_window_pixmap,
-                         0, 0,
-                         window_pixmap->drawable.width,
-                         window_pixmap->drawable.height);
+        window_pixmap->refcnt++;
+        xwl_window_realloc_pixmap(xwl_window);
+
+        if (!xwl_window_buffer)
+            return window_pixmap;
     }
 
     xwl_window_buffer->pixmap = window_pixmap;
@@ -392,14 +388,24 @@ xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
                                      xwl_window_buffer_release_callback,
                                      xwl_window_buffer);
 
-    xorg_list_del(&xwl_window_buffer->link_buffer);
     xorg_list_append(&xwl_window_buffer->link_buffer,
                      &xwl_window->window_buffers_unavailable);
 
-    xwl_window_set_pixmap(xwl_window->window, new_window_pixmap);
-
     if (xorg_list_is_empty(&xwl_window->window_buffers_available))
         TimerCancel(xwl_window->window_buffers_timer);
 
     return xwl_window_buffer->pixmap;
 }
+
+PixmapPtr
+xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window)
+{
+#ifdef XWL_HAS_GLAMOR
+    struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
+
+    if (!xwl_glamor_needs_n_buffering(xwl_screen))
+        return xwl_screen->screen->GetWindowPixmap(xwl_window->window);
+#endif /* XWL_HAS_GLAMOR */
+
+    return xwl_window_swap_pixmap(xwl_window);
+}

hw/xwayland/xwayland-window-buffers.h

@@ -30,12 +30,14 @@
 #include <xwayland-config.h>
 
 #include "xwayland-types.h"
-#include "regionstr.h"
 
+struct xwl_window_buffer;
+
+void xwl_window_buffer_add_damage_region(struct xwl_window *xwl_window);
 void xwl_window_buffers_init(struct xwl_window *xwl_window);
 void xwl_window_buffers_dispose(struct xwl_window *xwl_window);
-void xwl_window_recycle_pixmap(struct xwl_window *xwl_window);
-PixmapPtr xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window,
-                                        RegionPtr damage_region);
+void xwl_window_realloc_pixmap(struct xwl_window *xwl_window);
+PixmapPtr xwl_window_swap_pixmap(struct xwl_window *xwl_window);
+PixmapPtr xwl_window_buffers_get_pixmap(struct xwl_window *xwl_window);
 
 #endif /* XWAYLAND_WINDOW_BUFFERS_H */

hw/xwayland/xwayland-window.c

@@ -77,6 +77,12 @@ window_get_damage(WindowPtr window)
     return dixLookupPrivate(&window->devPrivates, &xwl_damage_private_key);
 }
 
+RegionPtr
+xwl_window_get_damage_region(struct xwl_window *xwl_window)
+{
+    return DamageRegion(window_get_damage(xwl_window->window));
+}
+
 struct xwl_window *
 xwl_window_from_window(WindowPtr window)
 {
@@ -182,24 +188,21 @@ damage_report(DamagePtr pDamage, RegionPtr pRegion, void *data)
     WindowPtr window = data;
     struct xwl_window *xwl_window = xwl_window_get(window);
     struct xwl_screen *xwl_screen;
+    PixmapPtr window_pixmap;
 
     if (!xwl_window)
         return;
 
     xwl_screen = xwl_window->xwl_screen;
-
-    if (xwl_window->present_flipped) {
-        /* This damage is from a Present flip, which already committed a new
-         * buffer for the surface, so we don't need to do anything in response
-         */
-        RegionEmpty(DamageRegion(pDamage));
-        xorg_list_del(&xwl_window->link_damage);
-        xwl_window->present_flipped = FALSE;
+    if (xwl_screen->ignore_damage)
         return;
-    }
 
     if (xorg_list_is_empty(&xwl_window->link_damage))
         xorg_list_add(&xwl_window->link_damage, &xwl_screen->damage_window_list);
+
+    window_pixmap = xwl_screen->screen->GetWindowPixmap(xwl_window->window);
+    if (xwl_is_client_pixmap(window_pixmap))
+        xwl_screen->screen->DestroyPixmap(xwl_window_swap_pixmap(xwl_window));
 }
 
 static void
@@ -220,7 +223,6 @@ register_damage(WindowPtr window)
     }
 
     DamageRegister(&window->drawable, damage);
-    DamageSetReportAfterOp(damage, TRUE);
 
     dixSetPrivate(&window->devPrivates, &xwl_damage_private_key, damage);
 
@@ -1380,8 +1382,7 @@ xwl_window_attach_buffer(struct xwl_window *xwl_window)
     PixmapPtr pixmap;
     int i;
 
-    region = DamageRegion(window_get_damage(xwl_window->window));
-    pixmap = xwl_window_buffers_get_pixmap(xwl_window, region);
+    pixmap = xwl_window_buffers_get_pixmap(xwl_window);
     buffer = xwl_pixmap_get_wl_buffer(pixmap);
 
     if (!buffer) {
@@ -1391,7 +1392,7 @@ xwl_window_attach_buffer(struct xwl_window *xwl_window)
 
 #ifdef XWL_HAS_GLAMOR
     if (xwl_screen->glamor) {
-        if (!xwl_glamor_post_damage(xwl_window, pixmap, region)) {
+        if (!xwl_glamor_post_damage(xwl_window, pixmap)) {
             ErrorF("glamor: Failed to post damage\n");
             return FALSE;
         }
@@ -1404,6 +1405,7 @@ xwl_window_attach_buffer(struct xwl_window *xwl_window)
      * connection. If we flood it too much anyway, this could
      * abort in libwayland-client.
      */
+    region = xwl_window_get_damage_region(xwl_window);
     if (RegionNumRects(region) > 256) {
         box = RegionExtents(region);
         xwl_surface_damage(xwl_screen, xwl_window->surface,

hw/xwayland/xwayland-window.h

@@ -111,7 +111,6 @@ struct xwl_window {
     struct wl_output *wl_output;
     struct wl_output *wl_output_fullscreen;
     struct xorg_list frame_callback_list;
-    Bool present_flipped;
 #ifdef XWL_HAS_LIBDECOR
     struct libdecor_frame *libdecor_frame;
 #endif
@@ -123,6 +122,7 @@ struct xwl_window {
 };
 
 struct xwl_window *xwl_window_get(WindowPtr window);
+RegionPtr xwl_window_get_damage_region(struct xwl_window *xwl_window);
 struct xwl_window *xwl_window_from_window(WindowPtr window);
 
 Bool is_surface_from_xwl_window(struct wl_surface *surface);

include/dix.h

@@ -259,12 +259,6 @@ extern _X_EXPORT void RemoveBlockAndWakeupHandlers(ServerBlockHandlerProcPtr blo
 
 extern _X_EXPORT void InitBlockAndWakeupHandlers(void);
 
-extern _X_EXPORT void ClearWorkQueue(void);
-
-extern _X_EXPORT void ProcessWorkQueue(void);
-
-extern _X_EXPORT void ProcessWorkQueueZombies(void);
-
 extern _X_EXPORT Bool QueueWorkProc(Bool (*function)(ClientPtr clientUnused,
                                                      void *closure),
                                     ClientPtr client,
@@ -570,11 +564,6 @@ IsInterferingGrab(ClientPtr /* client */ ,
                   DeviceIntPtr /* dev */ ,
                   xEvent * /* events */ );
 
-#ifdef PANORAMIX
-extern _X_EXPORT void
-ReinitializeRootWindow(WindowPtr win, int xoff, int yoff);
-#endif
-
 #ifdef RANDR
 extern _X_EXPORT void
 ScreenRestructured(ScreenPtr pScreen);

include/os.h

@@ -198,8 +198,6 @@ extern _X_EXPORT void TimerFree(OsTimerPtr /* pTimer */ );
 extern _X_EXPORT void SetScreenSaverTimer(void);
 extern _X_EXPORT void FreeScreenSaverTimer(void);
 
-extern _X_EXPORT void AutoResetServer(int /*sig */ );
-
 extern _X_EXPORT void GiveUp(int /*sig */ );
 
 extern _X_EXPORT void UseMsg(void);

include/protocol-versions.h

@@ -54,11 +54,6 @@
 #define SERVER_DRI3_MAJOR_VERSION               1
 #define SERVER_DRI3_MINOR_VERSION               2
 
-/* DMX */
-#define SERVER_DMX_MAJOR_VERSION		2
-#define SERVER_DMX_MINOR_VERSION		2
-#define SERVER_DMX_PATCH_VERSION		20040604
-
 /* Generic event extension */
 #define SERVER_GE_MAJOR_VERSION                 1
 #define SERVER_GE_MINOR_VERSION                 0