Compare revisions

Adam Jackson · Adam Jackson · Michel Dänzer · Michel Dänzer · Michel Dänzer · Michel Dänzer
--- a/glamor/glamor.c
+++ b/glamor/glamor.c
@@ -423,7 +423,8 @@ glamor_debug_output_callback(GLenum source,
 static void
 glamor_setup_debug_output(ScreenPtr screen)
 {
-    if (!epoxy_has_gl_extension("GL_ARB_debug_output"))
+    if (!epoxy_has_gl_extension("GL_KHR_debug") &&
+        !epoxy_has_gl_extension("GL_ARB_debug_output"))
        return;
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

--- a/glamor/glamor_rects.c
+++ b/glamor/glamor_rects.c
@@ -27,8 +27,10 @@
 static const glamor_facet glamor_facet_polyfillrect_130 = {
    .name = "poly_fill_rect",
    .version = 130,
-    .vs_vars = "attribute vec4 primitive;\n",
+    .source_name = "size",
-    .vs_exec = ("       vec2 pos = primitive.zw * vec2(gl_VertexID&1, (gl_VertexID&2)>>1);\n"
+    .vs_vars = "attribute vec2 primitive;\n"
+               "attribute vec2 size;\n",
+    .vs_exec = ("       vec2 pos = size * vec2(gl_VertexID&1, (gl_VertexID&2)>>1);\n"
                GLAMOR_POS(gl_Position, (primitive.xy + pos))),
 };
@@ -81,9 +83,14 @@ glamor_poly_fill_rect_gl(DrawablePtr drawable,
        glEnableVertexAttribArray(GLAMOR_VERTEX_POS);
        glVertexAttribDivisor(GLAMOR_VERTEX_POS, 1);
-        glVertexAttribPointer(GLAMOR_VERTEX_POS, 4, GL_SHORT, GL_FALSE,
+        glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_SHORT, GL_FALSE,
                              4 * sizeof (short), vbo_offset);
+        glEnableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
+        glVertexAttribDivisor(GLAMOR_VERTEX_SOURCE, 1);
+        glVertexAttribPointer(GLAMOR_VERTEX_SOURCE, 2, GL_UNSIGNED_SHORT, GL_FALSE,
+                              4 * sizeof (short), vbo_offset + 2 * sizeof (short));
        memcpy(v, prect, nrect * sizeof (xRectangle));
        glamor_put_vbo_space(screen);
@@ -156,8 +163,11 @@ glamor_poly_fill_rect_gl(DrawablePtr drawable,
 bail:
    glDisable(GL_SCISSOR_TEST);
-    if (glamor_priv->glsl_version >= 130)
+    if (glamor_priv->glsl_version >= 130) {
+        glVertexAttribDivisor(GLAMOR_VERTEX_SOURCE, 0);
+        glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
        glVertexAttribDivisor(GLAMOR_VERTEX_POS, 0);
+    }
    glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
    return ret;

--- a/present/present_execute.c
+++ b/present/present_execute.c
@@ -48,16 +48,13 @@ present_execute_wait(present_vblank_ptr vblank, uint64_t crtc_msc)
    ScreenPtr                   screen = window->drawable.pScreen;
    present_screen_priv_ptr screen_priv = present_screen_priv(screen);
-    if (vblank->requeue) {
+    /* We may have to requeue for the next MSC if check_flip_window prevented
-        vblank->requeue = FALSE;
+     * using a flip.
-        if (msc_is_after(vblank->target_msc, crtc_msc) &&
+     */
-            Success == screen_priv->queue_vblank(screen,
+    if (vblank->exec_msc == crtc_msc + 1 &&
-                                                 window,
+        screen_priv->queue_vblank(screen, window, vblank->crtc, vblank->event_id,
-                                                 vblank->crtc,
+                                  vblank->exec_msc) == Success)
-                                                 vblank->event_id,
+        return TRUE;
-                                                 vblank->target_msc))
-            return TRUE;
-    }
    if (vblank->wait_fence) {
        if (!present_fence_check_triggered(vblank->wait_fence)) {
@@ -75,13 +72,13 @@ present_execute_copy(present_vblank_ptr vblank, uint64_t crtc_msc)
    ScreenPtr                   screen = window->drawable.pScreen;
    present_screen_priv_ptr screen_priv = present_screen_priv(screen);
-    /* If present_flip failed, we may have to requeue for the target MSC */
+    /* If present_flip failed, we may have to requeue for the next MSC */
-    if (vblank->target_msc == crtc_msc + 1 &&
+    if (vblank->exec_msc == crtc_msc + 1 &&
        Success == screen_priv->queue_vblank(screen,
                                             window,
                                             vblank->crtc,
                                             vblank->event_id,
-                                             vblank->target_msc)) {
+                                             vblank->exec_msc)) {
        vblank->queued = TRUE;
        return;
    }

--- a/present/present_priv.h
+++ b/present/present_priv.h
@@ -70,14 +70,14 @@ struct present_vblank {
    int16_t             y_off;
    CARD16              kind;
    uint64_t            event_id;
-    uint64_t            target_msc;
+    uint64_t            target_msc;     /* target MSC when present should complete */
+    uint64_t            exec_msc;       /* MSC at which present can be executed */
    uint64_t            msc_offset;
    present_fence_ptr   idle_fence;
    present_fence_ptr   wait_fence;
    present_notify_ptr  notifies;
    int                 num_notifies;
    Bool                queued;         /* on present_exec_queue */
-    Bool                requeue;        /* on queue, but target_msc has changed */
    Bool                flip;           /* planning on using flip */
    Bool                flip_ready;     /* wants to flip, but waiting for previous flip or unflip */
    Bool                flip_idler;     /* driver explicitly permitted idling */
@@ -469,7 +469,7 @@ present_vblank_create(WindowPtr window,
                      const uint32_t *capabilities,
                      present_notify_ptr notifies,
                      int num_notifies,
-                      uint64_t *target_msc,
+                      uint64_t target_msc,
                      uint64_t crtc_msc);
 void

--- a/present/present_scmd.c
+++ b/present/present_scmd.c
@@ -335,8 +335,8 @@ present_flip_notify(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
    ScreenPtr                   screen = vblank->screen;
    present_screen_priv_ptr     screen_priv = present_screen_priv(screen);
-    DebugPresent(("\tn %" PRIu64 " %p %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
+    DebugPresent(("\tn %" PRIu64 " %p %" PRIu64 " %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
-                  vblank->event_id, vblank, vblank->target_msc,
+                  vblank->event_id, vblank, vblank->exec_msc, vblank->target_msc,
                  vblank->pixmap ? vblank->pixmap->drawable.id : 0,
                  vblank->window ? vblank->window->drawable.id : 0));
@@ -456,7 +456,7 @@ present_check_flip_window (WindowPtr window)
            vblank->flip = FALSE;
            vblank->reason = reason;
            if (vblank->sync_flip)
-                vblank->requeue = TRUE;
+                vblank->exec_msc = vblank->target_msc;
        }
    }
 }
@@ -582,6 +582,7 @@ present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
              */
            screen_priv->flip_pending = NULL;
            vblank->flip = FALSE;
+            vblank->exec_msc = vblank->target_msc;
        }
        DebugPresent(("\tc %p %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
                      vblank, crtc_msc, vblank->pixmap->drawable.id, vblank->window->drawable.id));
@@ -732,16 +733,19 @@ present_scmd_pixmap(WindowPtr window,
                                   screen_priv->info ? &screen_priv->info->capabilities : NULL,
                                   notifies,
                                   num_notifies,
-                                   &target_msc,
+                                   target_msc,
                                   crtc_msc);
    if (!vblank)
        return BadAlloc;
+    if (vblank->flip && vblank->sync_flip)
+        vblank->exec_msc--;
    xorg_list_append(&vblank->event_queue, &present_exec_queue);
    vblank->queued = TRUE;
-    if (msc_is_after(target_msc, crtc_msc)) {
+    if (msc_is_after(vblank->exec_msc, crtc_msc)) {
-        ret = present_queue_vblank(screen, window, target_crtc, vblank->event_id, target_msc);
+        ret = present_queue_vblank(screen, window, target_crtc, vblank->event_id, vblank->exec_msc);
        if (ret == Success)
            return Success;

--- a/present/present_vblank.c
+++ b/present/present_vblank.c
@@ -57,7 +57,7 @@ present_vblank_create(WindowPtr window,
                      const uint32_t *capabilities,
                      present_notify_ptr notifies,
                      int num_notifies,
-                      uint64_t *target_msc,
+                      uint64_t target_msc,
                      uint64_t crtc_msc)
 {
    ScreenPtr                   screen = window->drawable.pScreen;
@@ -100,7 +100,8 @@ present_vblank_create(WindowPtr window,
    vblank->x_off = x_off;
    vblank->y_off = y_off;
-    vblank->target_msc = *target_msc;
+    vblank->target_msc = target_msc;
+    vblank->exec_msc = target_msc;
    vblank->crtc = target_crtc;
    vblank->msc_offset = window_priv->msc_offset;
    vblank->notifies = notifies;
@@ -111,12 +112,11 @@ present_vblank_create(WindowPtr window,
    if (pixmap != NULL &&
        !(options & PresentOptionCopy) &&
        capabilities) {
-        if (msc_is_after(*target_msc, crtc_msc) &&
+        if (msc_is_after(target_msc, crtc_msc) &&
            screen_priv->check_flip (target_crtc, window, pixmap, TRUE, valid, x_off, y_off, &reason))
        {
            vblank->flip = TRUE;
            vblank->sync_flip = TRUE;
-            *target_msc = *target_msc - 1;
        } else if ((*capabilities & PresentCapabilityAsync) &&
            screen_priv->check_flip (target_crtc, window, pixmap, FALSE, valid, x_off, y_off, &reason))
        {
@@ -139,7 +139,7 @@ present_vblank_create(WindowPtr window,
    if (pixmap)
        DebugPresent(("q %" PRIu64 " %p %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 " (crtc %p) flip %d vsync %d serial %d\n",
-                      vblank->event_id, vblank, *target_msc,
+                      vblank->event_id, vblank, target_msc,
                      vblank->pixmap->drawable.id, vblank->window->drawable.id,
                      target_crtc, vblank->flip, vblank->sync_flip, vblank->serial));
    return vblank;
@@ -153,8 +153,8 @@ no_mem:
 void
 present_vblank_scrap(present_vblank_ptr vblank)
 {
-    DebugPresent(("\tx %" PRIu64 " %p %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 " (crtc %p)\n",
+    DebugPresent(("\tx %" PRIu64 " %p %" PRIu64 " %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 " (crtc %p)\n",
-                  vblank->event_id, vblank, vblank->target_msc,
+                  vblank->event_id, vblank, vblank->exec_msc, vblank->target_msc,
                  vblank->pixmap->drawable.id, vblank->window->drawable.id,
                  vblank->crtc));
@@ -175,8 +175,8 @@ present_vblank_destroy(present_vblank_ptr vblank)
    /* Also make sure vblank is removed from event queue (wnmd) */
    xorg_list_del(&vblank->event_queue);
-    DebugPresent(("\td %" PRIu64 " %p %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
+    DebugPresent(("\td %" PRIu64 " %p %" PRIu64 " %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
-                  vblank->event_id, vblank, vblank->target_msc,
+                  vblank->event_id, vblank, vblank->exec_msc, vblank->target_msc,
                  vblank->pixmap ? vblank->pixmap->drawable.id : 0,
                  vblank->window ? vblank->window->drawable.id : 0));

--- a/present/present_wnmd.c
+++ b/present/present_wnmd.c
@@ -42,6 +42,17 @@
 static void
 present_wnmd_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc);
+static int
+present_wnmd_queue_vblank(ScreenPtr screen,
+                          WindowPtr window,
+                          RRCrtcPtr crtc,
+                          uint64_t event_id,
+                          uint64_t msc)
+{
+    present_screen_priv_ptr screen_priv = present_screen_priv(screen);
+    return (*screen_priv->wnmd_info->queue_vblank) (window, crtc, event_id, msc);
+}
 static void
 present_wnmd_create_event_id(present_window_priv_ptr window_priv, present_vblank_ptr vblank)
 {
@@ -158,8 +169,8 @@ present_wnmd_flip_notify_vblank(present_vblank_ptr vblank, uint64_t ust, uint64_
    WindowPtr                   window = vblank->window;
    present_window_priv_ptr     window_priv = present_window_priv(window);
-    DebugPresent(("\tn %" PRIu64 " %p %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
+    DebugPresent(("\tn %" PRIu64 " %p %" PRIu64 " %" PRIu64 ": %08" PRIx32 " -> %08" PRIx32 "\n",
-                  vblank->event_id, vblank, vblank->target_msc,
+                  vblank->event_id, vblank, vblank->exec_msc, vblank->target_msc,
                  vblank->pixmap ? vblank->pixmap->drawable.id : 0,
                  vblank->window ? vblank->window->drawable.id : 0));
@@ -211,6 +222,14 @@ present_wnmd_event_notify(WindowPtr window, uint64_t event_id, uint64_t ust, uin
            return;
        }
    }
+    /* Copies which were executed but need their completion event sent */
+    xorg_list_for_each_entry(vblank, &window_priv->idle_queue, event_queue) {
+        if (vblank->event_id == event_id) {
+            present_execute_post(vblank, ust, msc);
+            return;
+        }
+    }
 }
 void
@@ -358,8 +377,6 @@ present_wnmd_check_flip_window (WindowPtr window)
                                         vblank->sync_flip, vblank->valid, 0, 0, &reason)) {
            vblank->flip = FALSE;
            vblank->reason = reason;
-            if (vblank->sync_flip)
-                vblank->requeue = TRUE;
        }
    }
 }
@@ -459,6 +476,7 @@ present_wnmd_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
    vblank->queued = FALSE;
    if (vblank->pixmap && vblank->window) {
+        ScreenPtr screen = window->drawable.pScreen;
        if (vblank->flip) {
            RegionPtr damage;
@@ -484,7 +502,6 @@ present_wnmd_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
            // ask the driver
            if (present_wnmd_flip(vblank->window, vblank->crtc, vblank->event_id,
                                     vblank->target_msc, vblank->pixmap, vblank->sync_flip, damage)) {
-                ScreenPtr screen = window->drawable.pScreen;
                WindowPtr toplvl_window = present_wnmd_toplvl_pixmap_window(vblank->window);
                PixmapPtr old_pixmap = screen->GetWindowPixmap(window);
@@ -514,9 +531,12 @@ present_wnmd_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
        present_wnmd_cancel_flip(window);
        present_execute_copy(vblank, crtc_msc);
+        assert(!vblank->queued);
-        if (vblank->queued) {
+        if (present_wnmd_queue_vblank(screen, window, vblank->crtc,
-            xorg_list_add(&vblank->event_queue, &window_priv->exec_queue);
+                                      vblank->event_id, crtc_msc + 1)
+            == Success) {
+            xorg_list_add(&vblank->event_queue, &window_priv->idle_queue);
            xorg_list_append(&vblank->window_list, &window_priv->vblank);
            return;
@@ -526,17 +546,6 @@ present_wnmd_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
    present_execute_post(vblank, ust, crtc_msc);
 }
-static int
-present_wnmd_queue_vblank(ScreenPtr screen,
-                             WindowPtr window,
-                             RRCrtcPtr crtc,
-                             uint64_t event_id,
-                             uint64_t msc)
-{
-    present_screen_priv_ptr screen_priv = present_screen_priv(screen);
-    return (*screen_priv->wnmd_info->queue_vblank) (window, crtc, event_id, msc);
-}
 static void
 present_wnmd_update_window_crtc(WindowPtr window, RRCrtcPtr crtc, uint64_t new_msc)
 {
@@ -645,15 +654,20 @@ present_wnmd_pixmap(WindowPtr window,
                                   &screen_priv->wnmd_info->capabilities,
                                   notifies,
                                   num_notifies,
-                                   &target_msc,
+                                   target_msc,
                                   crtc_msc);
    if (!vblank)
        return BadAlloc;
+    /* WNMD presentations always complete (at least) one frame after they
+     * are executed
+     */
+    vblank->exec_msc = vblank->target_msc - 1;
    xorg_list_append(&vblank->event_queue, &window_priv->exec_queue);
    vblank->queued = TRUE;
-    if (crtc_msc < target_msc) {
+    if (crtc_msc < vblank->exec_msc) {
-        if (present_wnmd_queue_vblank(screen, window, target_crtc, vblank->event_id, target_msc) == Success) {
+        if (present_wnmd_queue_vblank(screen, window, target_crtc, vblank->event_id, vblank->exec_msc) == Success) {
            return Success;
        }
        DebugPresent(("present_queue_vblank failed\n"));
No results found