src/gallium/auxiliary/vl/vl_winsys_dri3.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Advanced Micro Devices, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include <fcntl.h>
  29
  30 #include <X11/Xlib-xcb.h>
  31 #include <X11/xshmfence.h>
  32 #include <xcb/dri3.h>
  33 #include <xcb/present.h>
  34 #include <xcb/xfixes.h>
  35
  36 #include "loader.h"
  37
  38 #include "pipe/p_screen.h"
  39 #include "pipe/p_state.h"
  40 #include "pipe-loader/pipe_loader.h"
  41
  42 #include "util/u_memory.h"
  43 #include "util/u_inlines.h"
  44
  45 #include "vl/vl_compositor.h"
  46 #include "vl/vl_winsys.h"
  47
  48 #define BACK_BUFFER_NUM 3
  49
  50 struct vl_dri3_buffer
  51 {
  52    struct pipe_resource *texture;
  53    struct pipe_resource *linear_texture;
  54
  55    uint32_t pixmap;
  56    uint32_t sync_fence;
  57    struct xshmfence *shm_fence;
  58
  59    bool busy;
  60    uint32_t width, height, pitch;
  61 };
  62
  63 struct vl_dri3_screen
  64 {
  65    struct vl_screen base;
  66    xcb_connection_t *conn;
  67    xcb_drawable_t drawable;
  68
  69    uint32_t width, height, depth;
  70
  71    xcb_present_event_t eid;
  72    xcb_special_event_t *special_event;
  73
  74    struct pipe_context *pipe;
  75    struct pipe_resource *output_texture;
  76    uint32_t clip_width, clip_height;
  77
  78    struct vl_dri3_buffer *back_buffers[BACK_BUFFER_NUM];
  79    int cur_back;
  80    int next_back;
  81
  82    struct u_rect dirty_areas[BACK_BUFFER_NUM];
  83
  84    struct vl_dri3_buffer *front_buffer;
  85    bool is_pixmap;
  86
  87    uint32_t send_msc_serial, recv_msc_serial;
  88    uint64_t send_sbc, recv_sbc;
  89    int64_t last_ust, ns_frame, last_msc, next_msc;
  90
  91    bool flushed;
  92    bool is_different_gpu;
  93 };
  94
  95 static void
  96 dri3_free_front_buffer(struct vl_dri3_screen *scrn,
  97                         struct vl_dri3_buffer *buffer)
  98 {
  99    xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
 100    xshmfence_unmap_shm(buffer->shm_fence);
 101    pipe_resource_reference(&buffer->texture, NULL);
 102    FREE(buffer);
 103 }
 104
 105 static void
 106 dri3_free_back_buffer(struct vl_dri3_screen *scrn,
 107                         struct vl_dri3_buffer *buffer)
 108 {
 109    xcb_free_pixmap(scrn->conn, buffer->pixmap);
 110    xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
 111    xshmfence_unmap_shm(buffer->shm_fence);
 112    if (!scrn->output_texture)
 113       pipe_resource_reference(&buffer->texture, NULL);
 114    if (buffer->linear_texture)
 115        pipe_resource_reference(&buffer->linear_texture, NULL);
 116    FREE(buffer);
 117 }
 118
 119 static void
 120 dri3_handle_stamps(struct vl_dri3_screen *scrn, uint64_t ust, uint64_t msc)
 121 {
 122    int64_t ust_ns =  ust * 1000;
 123
 124    if (scrn->last_ust && (ust_ns > scrn->last_ust) &&
 125        scrn->last_msc && (msc > scrn->last_msc))
 126       scrn->ns_frame = (ust_ns - scrn->last_ust) / (msc - scrn->last_msc);
 127
 128    scrn->last_ust = ust_ns;
 129    scrn->last_msc = msc;
 130 }
 131
 132 static void
 133 dri3_handle_present_event(struct vl_dri3_screen *scrn,
 134                           xcb_present_generic_event_t *ge)
 135 {
 136    switch (ge->evtype) {
 137    case XCB_PRESENT_CONFIGURE_NOTIFY: {
 138       xcb_present_configure_notify_event_t *ce = (void *) ge;
 139       scrn->width = ce->width;
 140       scrn->height = ce->height;
 141       break;
 142    }
 143    case XCB_PRESENT_COMPLETE_NOTIFY: {
 144       xcb_present_complete_notify_event_t *ce = (void *) ge;
 145       if (ce->kind == XCB_PRESENT_COMPLETE_KIND_PIXMAP) {
 146          scrn->recv_sbc = (scrn->send_sbc & 0xffffffff00000000LL) | ce->serial;
 147          if (scrn->recv_sbc > scrn->send_sbc)
 148             scrn->recv_sbc -= 0x100000000;
 149          dri3_handle_stamps(scrn, ce->ust, ce->msc);
 150       } else if (ce->kind == XCB_PRESENT_COMPLETE_KIND_NOTIFY_MSC) {
 151          scrn->recv_msc_serial = ce->serial;
 152          dri3_handle_stamps(scrn, ce->ust, ce->msc);
 153       }
 154       break;
 155    }
 156    case XCB_PRESENT_EVENT_IDLE_NOTIFY: {
 157       xcb_present_idle_notify_event_t *ie = (void *) ge;
 158       int b;
 159       for (b = 0; b < BACK_BUFFER_NUM; b++) {
 160          struct vl_dri3_buffer *buf = scrn->back_buffers[b];
 161          if (buf && buf->pixmap == ie->pixmap) {
 162             buf->busy = false;
 163             break;
 164          }
 165       }
 166       break;
 167    }
 168    }
 169    free(ge);
 170 }
 171
 172 static void
 173 dri3_flush_present_events(struct vl_dri3_screen *scrn)
 174 {
 175    if (scrn->special_event) {
 176       xcb_generic_event_t *ev;
 177       while ((ev = xcb_poll_for_special_event(
 178                    scrn->conn, scrn->special_event)) != NULL)
 179          dri3_handle_present_event(scrn, (xcb_present_generic_event_t *)ev);
 180    }
 181 }
 182
 183 static bool
 184 dri3_wait_present_events(struct vl_dri3_screen *scrn)
 185 {
 186    if (scrn->special_event) {
 187       xcb_generic_event_t *ev;
 188       ev = xcb_wait_for_special_event(scrn->conn, scrn->special_event);
 189       if (!ev)
 190          return false;
 191       dri3_handle_present_event(scrn, (xcb_present_generic_event_t *)ev);
 192       return true;
 193    }
 194    return false;
 195 }
 196
 197 static int
 198 dri3_find_back(struct vl_dri3_screen *scrn)
 199 {
 200    int b;
 201
 202    for (;;) {
 203       for (b = 0; b < BACK_BUFFER_NUM; b++) {
 204          int id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
 205          struct vl_dri3_buffer *buffer = scrn->back_buffers[id];
 206          if (!buffer || !buffer->busy)
 207             return id;
 208       }
 209       xcb_flush(scrn->conn);
 210       if (!dri3_wait_present_events(scrn))
 211          return -1;
 212    }
 213 }
 214
 215 static struct vl_dri3_buffer *
 216 dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
 217 {
 218    struct vl_dri3_buffer *buffer;
 219    xcb_pixmap_t pixmap;
 220    xcb_sync_fence_t sync_fence;
 221    struct xshmfence *shm_fence;
 222    int buffer_fd, fence_fd;
 223    struct pipe_resource templ, *pixmap_buffer_texture;
 224    struct winsys_handle whandle;
 225    unsigned usage;
 226
 227    buffer = CALLOC_STRUCT(vl_dri3_buffer);
 228    if (!buffer)
 229       return NULL;
 230
 231    fence_fd = xshmfence_alloc_shm();
 232    if (fence_fd < 0)
 233       goto free_buffer;
 234
 235    shm_fence = xshmfence_map_shm(fence_fd);
 236    if (!shm_fence)
 237       goto close_fd;
 238
 239    memset(&templ, 0, sizeof(templ));
 240    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 241    templ.format = PIPE_FORMAT_B8G8R8X8_UNORM;
 242    templ.target = PIPE_TEXTURE_2D;
 243    templ.last_level = 0;
 244    templ.width0 = (scrn->output_texture) ?
 245                   scrn->output_texture->width0 : scrn->width;
 246    templ.height0 = (scrn->output_texture) ?
 247                    scrn->output_texture->height0 : scrn->height;
 248    templ.depth0 = 1;
 249    templ.array_size = 1;
 250
 251    if (scrn->is_different_gpu) {
 252       buffer->texture = (scrn->output_texture) ? scrn->output_texture :
 253                         scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
 254       if (!buffer->texture)
 255          goto unmap_shm;
 256
 257       templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED |
 258                     PIPE_BIND_LINEAR;
 259       buffer->linear_texture =
 260           scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
 261       pixmap_buffer_texture = buffer->linear_texture;
 262
 263       if (!buffer->linear_texture)
 264          goto no_linear_texture;
 265    } else {
 266       templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED;
 267       buffer->texture = (scrn->output_texture) ? scrn->output_texture :
 268                         scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
 269       if (!buffer->texture)
 270          goto unmap_shm;
 271       pixmap_buffer_texture = buffer->texture;
 272    }
 273    memset(&whandle, 0, sizeof(whandle));
 274    whandle.type= DRM_API_HANDLE_TYPE_FD;
 275    usage = PIPE_HANDLE_USAGE_EXPLICIT_FLUSH | PIPE_HANDLE_USAGE_READ;
 276    scrn->base.pscreen->resource_get_handle(scrn->base.pscreen, NULL,
 277                                            pixmap_buffer_texture, &whandle,
 278                                            usage);
 279    buffer_fd = whandle.handle;
 280    buffer->pitch = whandle.stride;
 281    buffer->width = templ.width0;
 282    buffer->height = templ.height0;
 283
 284    xcb_dri3_pixmap_from_buffer(scrn->conn,
 285                                (pixmap = xcb_generate_id(scrn->conn)),
 286                                scrn->drawable,
 287                                0,
 288                                buffer->width, buffer->height, buffer->pitch,
 289                                scrn->depth, 32,
 290                                buffer_fd);
 291    xcb_dri3_fence_from_fd(scrn->conn,
 292                           pixmap,
 293                           (sync_fence = xcb_generate_id(scrn->conn)),
 294                           false,
 295                           fence_fd);
 296
 297    buffer->pixmap = pixmap;
 298    buffer->sync_fence = sync_fence;
 299    buffer->shm_fence = shm_fence;
 300
 301    xshmfence_trigger(buffer->shm_fence);
 302
 303    return buffer;
 304
 305 no_linear_texture:
 306    pipe_resource_reference(&buffer->texture, NULL);
 307 unmap_shm:
 308    xshmfence_unmap_shm(shm_fence);
 309 close_fd:
 310    close(fence_fd);
 311 free_buffer:
 312    FREE(buffer);
 313    return NULL;
 314 }
 315
 316 static struct vl_dri3_buffer *
 317 dri3_get_back_buffer(struct vl_dri3_screen *scrn)
 318 {
 319    struct vl_dri3_buffer *buffer;
 320    struct pipe_resource *texture = NULL;
 321    bool allocate_new_buffer = false;
 322    int b, id;
 323
 324    assert(scrn);
 325
 326    scrn->cur_back = dri3_find_back(scrn);
 327    if (scrn->cur_back < 0)
 328       return NULL;
 329    buffer = scrn->back_buffers[scrn->cur_back];
 330
 331    if (scrn->output_texture) {
 332       if (!buffer || buffer->width < scrn->width ||
 333           buffer->height < scrn->height)
 334          allocate_new_buffer = true;
 335       else if (scrn->is_different_gpu)
 336          /* In case of different gpu we can reuse the linear
 337           * texture so we only need to set the external
 338           * texture for copying
 339           */
 340          buffer->texture = scrn->output_texture;
 341       else {
 342          /* In case of a single gpu we search if the texture is
 343           * already present as buffer if not we get the
 344           * handle and pixmap for the texture that is set
 345           */
 346          for (b = 0; b < BACK_BUFFER_NUM; b++) {
 347             id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
 348             buffer = scrn->back_buffers[id];
 349             if (buffer && !buffer->busy &&
 350                 buffer->texture == scrn->output_texture) {
 351                scrn->cur_back = id;
 352                break;
 353             }
 354          }
 355
 356          if (b == BACK_BUFFER_NUM) {
 357             allocate_new_buffer = true;
 358             scrn->cur_back = scrn->next_back;
 359             scrn->next_back = (scrn->next_back + 1) % BACK_BUFFER_NUM;
 360             buffer = scrn->back_buffers[scrn->cur_back];
 361          }
 362       }
 363
 364    } else {
 365       if (!buffer || buffer->width != scrn->width ||
 366           buffer->height != scrn->height)
 367          allocate_new_buffer = true;
 368    }
 369
 370    if (allocate_new_buffer) {
 371       struct vl_dri3_buffer *new_buffer;
 372
 373       new_buffer = dri3_alloc_back_buffer(scrn);
 374       if (!new_buffer)
 375          return NULL;
 376
 377       if (buffer)
 378          dri3_free_back_buffer(scrn, buffer);
 379
 380       if (!scrn->output_texture)
 381          vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
 382       buffer = new_buffer;
 383       scrn->back_buffers[scrn->cur_back] = buffer;
 384    }
 385
 386    pipe_resource_reference(&texture, buffer->texture);
 387    xcb_flush(scrn->conn);
 388    xshmfence_await(buffer->shm_fence);
 389
 390    return buffer;
 391 }
 392
 393 static bool
 394 dri3_set_drawable(struct vl_dri3_screen *scrn, Drawable drawable)
 395 {
 396    xcb_get_geometry_cookie_t geom_cookie;
 397    xcb_get_geometry_reply_t *geom_reply;
 398    xcb_void_cookie_t cookie;
 399    xcb_generic_error_t *error;
 400    bool ret = true;
 401
 402    assert(drawable);
 403
 404    if (scrn->drawable == drawable)
 405       return true;
 406
 407    scrn->drawable = drawable;
 408
 409    geom_cookie = xcb_get_geometry(scrn->conn, scrn->drawable);
 410    geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
 411    if (!geom_reply)
 412       return false;
 413
 414    scrn->width = geom_reply->width;
 415    scrn->height = geom_reply->height;
 416    scrn->depth = geom_reply->depth;
 417    free(geom_reply);
 418
 419    if (scrn->special_event) {
 420       xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
 421       scrn->special_event = NULL;
 422       cookie = xcb_present_select_input_checked(scrn->conn, scrn->eid,
 423                                                 scrn->drawable,
 424                                                 XCB_PRESENT_EVENT_MASK_NO_EVENT);
 425       xcb_discard_reply(scrn->conn, cookie.sequence);
 426    }
 427
 428    scrn->is_pixmap = false;
 429    scrn->eid = xcb_generate_id(scrn->conn);
 430    cookie =
 431       xcb_present_select_input_checked(scrn->conn, scrn->eid, scrn->drawable,
 432                       XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY |
 433                       XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY |
 434                       XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY);
 435
 436    error = xcb_request_check(scrn->conn, cookie);
 437    if (error) {
 438       if (error->error_code != BadWindow)
 439          ret = false;
 440       else {
 441          scrn->is_pixmap = true;
 442          if (scrn->front_buffer) {
 443             dri3_free_front_buffer(scrn, scrn->front_buffer);
 444             scrn->front_buffer = NULL;
 445          }
 446       }
 447       free(error);
 448    } else
 449       scrn->special_event =
 450          xcb_register_for_special_xge(scrn->conn, &xcb_present_id, scrn->eid, 0);
 451
 452    dri3_flush_present_events(scrn);
 453
 454    return ret;
 455 }
 456
 457 static struct vl_dri3_buffer *
 458 dri3_get_front_buffer(struct vl_dri3_screen *scrn)
 459 {
 460    xcb_dri3_buffer_from_pixmap_cookie_t bp_cookie;
 461    xcb_dri3_buffer_from_pixmap_reply_t *bp_reply;
 462    xcb_sync_fence_t sync_fence;
 463    struct xshmfence *shm_fence;
 464    int fence_fd, *fds;
 465    struct winsys_handle whandle;
 466    struct pipe_resource templ, *texture = NULL;
 467
 468    if (scrn->front_buffer) {
 469       pipe_resource_reference(&texture, scrn->front_buffer->texture);
 470       return scrn->front_buffer;
 471    }
 472
 473    scrn->front_buffer = CALLOC_STRUCT(vl_dri3_buffer);
 474    if (!scrn->front_buffer)
 475       return NULL;
 476
 477    fence_fd = xshmfence_alloc_shm();
 478    if (fence_fd < 0)
 479       goto free_buffer;
 480
 481    shm_fence = xshmfence_map_shm(fence_fd);
 482    if (!shm_fence)
 483       goto close_fd;
 484
 485    bp_cookie = xcb_dri3_buffer_from_pixmap(scrn->conn, scrn->drawable);
 486    bp_reply = xcb_dri3_buffer_from_pixmap_reply(scrn->conn, bp_cookie, NULL);
 487    if (!bp_reply)
 488       goto unmap_shm;
 489
 490    fds = xcb_dri3_buffer_from_pixmap_reply_fds(scrn->conn, bp_reply);
 491    if (fds[0] < 0)
 492       goto free_reply;
 493
 494    memset(&whandle, 0, sizeof(whandle));
 495    whandle.type = DRM_API_HANDLE_TYPE_FD;
 496    whandle.handle = (unsigned)fds[0];
 497    whandle.stride = bp_reply->stride;
 498    memset(&templ, 0, sizeof(templ));
 499    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 500    templ.format = PIPE_FORMAT_B8G8R8X8_UNORM;
 501    templ.target = PIPE_TEXTURE_2D;
 502    templ.last_level = 0;
 503    templ.width0 = bp_reply->width;
 504    templ.height0 = bp_reply->height;
 505    templ.depth0 = 1;
 506    templ.array_size = 1;
 507    scrn->front_buffer->texture =
 508       scrn->base.pscreen->resource_from_handle(scrn->base.pscreen,
 509                                                &templ, &whandle,
 510                                                PIPE_HANDLE_USAGE_READ_WRITE);
 511    close(fds[0]);
 512    if (!scrn->front_buffer->texture)
 513       goto free_reply;
 514
 515    xcb_dri3_fence_from_fd(scrn->conn,
 516                           scrn->drawable,
 517                           (sync_fence = xcb_generate_id(scrn->conn)),
 518                           false,
 519                           fence_fd);
 520
 521    pipe_resource_reference(&texture, scrn->front_buffer->texture);
 522    scrn->front_buffer->pixmap = scrn->drawable;
 523    scrn->front_buffer->width = bp_reply->width;
 524    scrn->front_buffer->height = bp_reply->height;
 525    scrn->front_buffer->shm_fence = shm_fence;
 526    scrn->front_buffer->sync_fence = sync_fence;
 527    free(bp_reply);
 528
 529    return scrn->front_buffer;
 530
 531 free_reply:
 532    free(bp_reply);
 533 unmap_shm:
 534    xshmfence_unmap_shm(shm_fence);
 535 close_fd:
 536    close(fence_fd);
 537 free_buffer:
 538    FREE(scrn->front_buffer);
 539    return NULL;
 540 }
 541
 542 static void
 543 vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
 544                           struct pipe_resource *resource,
 545                           unsigned level, unsigned layer,
 546                           void *context_private, struct pipe_box *sub_box)
 547 {
 548    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)context_private;
 549    uint32_t options = XCB_PRESENT_OPTION_NONE;
 550    struct vl_dri3_buffer *back;
 551    struct pipe_box src_box;
 552    xcb_xfixes_region_t region;
 553    xcb_rectangle_t rectangle;
 554
 555    back = scrn->back_buffers[scrn->cur_back];
 556    if (!back)
 557        return;
 558
 559    if (scrn->flushed) {
 560       while (scrn->special_event && scrn->recv_sbc < scrn->send_sbc)
 561          if (!dri3_wait_present_events(scrn))
 562             return;
 563    }
 564
 565    rectangle.x = 0;
 566    rectangle.y = 0;
 567    rectangle.width = (scrn->output_texture) ? scrn->clip_width : scrn->width;
 568    rectangle.height = (scrn->output_texture) ? scrn->clip_height : scrn->height;
 569
 570    region = xcb_generate_id(scrn->conn);
 571    xcb_xfixes_create_region(scrn->conn, region, 2, &rectangle);
 572
 573    if (scrn->is_different_gpu) {
 574       u_box_origin_2d(back->width, back->height, &src_box);
 575       scrn->pipe->resource_copy_region(scrn->pipe,
 576                                        back->linear_texture,
 577                                        0, 0, 0, 0,
 578                                        back->texture,
 579                                        0, &src_box);
 580
 581       scrn->pipe->flush(scrn->pipe, NULL, 0);
 582    }
 583    xshmfence_reset(back->shm_fence);
 584    back->busy = true;
 585
 586    xcb_present_pixmap(scrn->conn,
 587                       scrn->drawable,
 588                       back->pixmap,
 589                       (uint32_t)(++scrn->send_sbc),
 590                       0, region, 0, 0,
 591                       None, None,
 592                       back->sync_fence,
 593                       options,
 594                       scrn->next_msc,
 595                       0, 0, 0, NULL);
 596
 597    xcb_flush(scrn->conn);
 598
 599    scrn->flushed = true;
 600
 601    return;
 602 }
 603
 604 static struct pipe_resource *
 605 vl_dri3_screen_texture_from_drawable(struct vl_screen *vscreen, void *drawable)
 606 {
 607    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 608    struct vl_dri3_buffer *buffer;
 609
 610    assert(scrn);
 611
 612    if (!dri3_set_drawable(scrn, (Drawable)drawable))
 613       return NULL;
 614
 615    if (scrn->flushed) {
 616       while (scrn->special_event && scrn->recv_sbc < scrn->send_sbc)
 617          if (!dri3_wait_present_events(scrn))
 618             return NULL;
 619    }
 620    scrn->flushed = false;
 621
 622    buffer = (scrn->is_pixmap) ?
 623             dri3_get_front_buffer(scrn) :
 624             dri3_get_back_buffer(scrn);
 625    if (!buffer)
 626       return NULL;
 627
 628    return buffer->texture;
 629 }
 630
 631 static struct u_rect *
 632 vl_dri3_screen_get_dirty_area(struct vl_screen *vscreen)
 633 {
 634    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 635
 636    assert(scrn);
 637
 638    return &scrn->dirty_areas[scrn->cur_back];
 639 }
 640
 641 static uint64_t
 642 vl_dri3_screen_get_timestamp(struct vl_screen *vscreen, void *drawable)
 643 {
 644    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 645
 646    assert(scrn);
 647
 648    if (!dri3_set_drawable(scrn, (Drawable)drawable))
 649       return 0;
 650
 651    if (!scrn->last_ust) {
 652       xcb_present_notify_msc(scrn->conn,
 653                              scrn->drawable,
 654                              ++scrn->send_msc_serial,
 655                              0, 0, 0);
 656       xcb_flush(scrn->conn);
 657
 658       while (scrn->special_event &&
 659              scrn->send_msc_serial > scrn->recv_msc_serial) {
 660          if (!dri3_wait_present_events(scrn))
 661             return 0;
 662       }
 663    }
 664
 665    return scrn->last_ust;
 666 }
 667
 668 static void
 669 vl_dri3_screen_set_next_timestamp(struct vl_screen *vscreen, uint64_t stamp)
 670 {
 671    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 672
 673    assert(scrn);
 674
 675    if (stamp && scrn->last_ust && scrn->ns_frame && scrn->last_msc)
 676       scrn->next_msc = ((int64_t)stamp - scrn->last_ust + scrn->ns_frame/2) /
 677                        scrn->ns_frame + scrn->last_msc;
 678    else
 679       scrn->next_msc = 0;
 680 }
 681
 682 static void *
 683 vl_dri3_screen_get_private(struct vl_screen *vscreen)
 684 {
 685    return vscreen;
 686 }
 687
 688 static void
 689 vl_dri3_screen_set_back_texture_from_output(struct vl_screen *vscreen,
 690                                             struct pipe_resource *buffer,
 691                                             uint32_t width, uint32_t height)
 692 {
 693    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 694
 695    assert(scrn);
 696
 697    scrn->output_texture = buffer;
 698    scrn->clip_width = (width) ? width : scrn->width;
 699    scrn->clip_height = (height) ? height : scrn->height;
 700 }
 701
 702 static void
 703 vl_dri3_screen_destroy(struct vl_screen *vscreen)
 704 {
 705    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 706    int i;
 707
 708    assert(vscreen);
 709
 710    dri3_flush_present_events(scrn);
 711
 712    if (scrn->front_buffer) {
 713       dri3_free_front_buffer(scrn, scrn->front_buffer);
 714       scrn->front_buffer = NULL;
 715       return;
 716    }
 717
 718    for (i = 0; i < BACK_BUFFER_NUM; ++i) {
 719       if (scrn->back_buffers[i]) {
 720          dri3_free_back_buffer(scrn, scrn->back_buffers[i]);
 721          scrn->back_buffers[i] = NULL;
 722       }
 723    }
 724
 725    if (scrn->special_event) {
 726       xcb_void_cookie_t cookie =
 727          xcb_present_select_input_checked(scrn->conn, scrn->eid,
 728                                           scrn->drawable,
 729                                           XCB_PRESENT_EVENT_MASK_NO_EVENT);
 730
 731       xcb_discard_reply(scrn->conn, cookie.sequence);
 732       xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
 733    }
 734    scrn->pipe->destroy(scrn->pipe);
 735    scrn->base.pscreen->destroy(scrn->base.pscreen);
 736    pipe_loader_release(&scrn->base.dev, 1);
 737    FREE(scrn);
 738
 739    return;
 740 }
 741
 742 struct vl_screen *
 743 vl_dri3_screen_create(Display *display, int screen)
 744 {
 745    struct vl_dri3_screen *scrn;
 746    const xcb_query_extension_reply_t *extension;
 747    xcb_dri3_open_cookie_t open_cookie;
 748    xcb_dri3_open_reply_t *open_reply;
 749    xcb_get_geometry_cookie_t geom_cookie;
 750    xcb_get_geometry_reply_t *geom_reply;
 751    xcb_xfixes_query_version_cookie_t xfixes_cookie;
 752    xcb_xfixes_query_version_reply_t *xfixes_reply;
 753    xcb_generic_error_t *error;
 754    int fd;
 755
 756    assert(display);
 757
 758    scrn = CALLOC_STRUCT(vl_dri3_screen);
 759    if (!scrn)
 760       return NULL;
 761
 762    scrn->conn = XGetXCBConnection(display);
 763    if (!scrn->conn)
 764       goto free_screen;
 765
 766    xcb_prefetch_extension_data(scrn->conn , &xcb_dri3_id);
 767    xcb_prefetch_extension_data(scrn->conn, &xcb_present_id);
 768    xcb_prefetch_extension_data (scrn->conn, &xcb_xfixes_id);
 769    extension = xcb_get_extension_data(scrn->conn, &xcb_dri3_id);
 770    if (!(extension && extension->present))
 771       goto free_screen;
 772    extension = xcb_get_extension_data(scrn->conn, &xcb_present_id);
 773    if (!(extension && extension->present))
 774       goto free_screen;
 775    extension = xcb_get_extension_data(scrn->conn, &xcb_xfixes_id);
 776    if (!(extension && extension->present))
 777       goto free_screen;
 778
 779    xfixes_cookie = xcb_xfixes_query_version(scrn->conn, XCB_XFIXES_MAJOR_VERSION,
 780                                             XCB_XFIXES_MINOR_VERSION);
 781    xfixes_reply = xcb_xfixes_query_version_reply(scrn->conn, xfixes_cookie, &error);
 782    if (!xfixes_reply || error || xfixes_reply->major_version < 2) {
 783       free(error);
 784       free(xfixes_reply);
 785       goto free_screen;
 786    }
 787    free(xfixes_reply);
 788
 789    open_cookie = xcb_dri3_open(scrn->conn, RootWindow(display, screen), None);
 790    open_reply = xcb_dri3_open_reply(scrn->conn, open_cookie, NULL);
 791    if (!open_reply)
 792       goto free_screen;
 793    if (open_reply->nfd != 1) {
 794       free(open_reply);
 795       goto free_screen;
 796    }
 797
 798    fd = xcb_dri3_open_reply_fds(scrn->conn, open_reply)[0];
 799    if (fd < 0) {
 800       free(open_reply);
 801       goto free_screen;
 802    }
 803    fcntl(fd, F_SETFD, FD_CLOEXEC);
 804    free(open_reply);
 805
 806    fd = loader_get_user_preferred_fd(fd, &scrn->is_different_gpu);
 807
 808    geom_cookie = xcb_get_geometry(scrn->conn, RootWindow(display, screen));
 809    geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
 810    if (!geom_reply)
 811       goto close_fd;
 812    /* TODO support depth other than 24 */
 813    if (geom_reply->depth != 24) {
 814       free(geom_reply);
 815       goto close_fd;
 816    }
 817    free(geom_reply);
 818
 819    if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
 820       scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
 821
 822    if (!scrn->base.pscreen)
 823       goto release_pipe;
 824
 825    scrn->pipe = scrn->base.pscreen->context_create(scrn->base.pscreen,
 826                                                    NULL, 0);
 827    if (!scrn->pipe)
 828        goto no_context;
 829
 830    scrn->base.destroy = vl_dri3_screen_destroy;
 831    scrn->base.texture_from_drawable = vl_dri3_screen_texture_from_drawable;
 832    scrn->base.get_dirty_area = vl_dri3_screen_get_dirty_area;
 833    scrn->base.get_timestamp = vl_dri3_screen_get_timestamp;
 834    scrn->base.set_next_timestamp = vl_dri3_screen_set_next_timestamp;
 835    scrn->base.get_private = vl_dri3_screen_get_private;
 836    scrn->base.pscreen->flush_frontbuffer = vl_dri3_flush_frontbuffer;
 837    scrn->base.set_back_texture_from_output = vl_dri3_screen_set_back_texture_from_output;
 838
 839    scrn->next_back = 1;
 840    return &scrn->base;
 841
 842 no_context:
 843    scrn->base.pscreen->destroy(scrn->base.pscreen);
 844 release_pipe:
 845    if (scrn->base.dev) {
 846       pipe_loader_release(&scrn->base.dev, 1);
 847       fd = -1;
 848    }
 849 close_fd:
 850    if (fd != -1)
 851       close(fd);
 852 free_screen:
 853    FREE(scrn);
 854    return NULL;
 855 }