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