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
  35 #include "loader.h"
  36
  37 #include "pipe/p_screen.h"
  38 #include "pipe/p_state.h"
  39 #include "pipe-loader/pipe_loader.h"
  40
  41 #include "util/u_memory.h"
  42 #include "util/u_inlines.h"
  43
  44 #include "vl/vl_compositor.h"
  45 #include "vl/vl_winsys.h"
  46
  47 #define BACK_BUFFER_NUM 3
  48
  49 struct vl_dri3_buffer
  50 {
  51    struct pipe_resource *texture;
  52
  53    uint32_t pixmap;
  54    uint32_t sync_fence;
  55    struct xshmfence *shm_fence;
  56
  57    bool busy;
  58    uint32_t width, height, pitch;
  59 };
  60
  61 struct vl_dri3_screen
  62 {
  63    struct vl_screen base;
  64    xcb_connection_t *conn;
  65    xcb_drawable_t drawable;
  66
  67    uint32_t width, height, depth;
  68
  69    xcb_special_event_t *special_event;
  70
  71    struct vl_dri3_buffer *back_buffers[BACK_BUFFER_NUM];
  72    int cur_back;
  73
  74    struct u_rect dirty_areas[BACK_BUFFER_NUM];
  75
  76    struct vl_dri3_buffer *front_buffer;
  77    bool is_pixmap;
  78
  79    uint32_t send_msc_serial, recv_msc_serial;
  80    uint64_t send_sbc, recv_sbc;
  81    int64_t last_ust, ns_frame, last_msc, next_msc;
  82
  83    bool flushed;
  84 };
  85
  86 static void
  87 dri3_free_front_buffer(struct vl_dri3_screen *scrn,
  88                         struct vl_dri3_buffer *buffer)
  89 {
  90    xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
  91    xshmfence_unmap_shm(buffer->shm_fence);
  92    FREE(buffer);
  93 }
  94
  95 static void
  96 dri3_free_back_buffer(struct vl_dri3_screen *scrn,
  97                         struct vl_dri3_buffer *buffer)
  98 {
  99    xcb_free_pixmap(scrn->conn, buffer->pixmap);
 100    xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
 101    xshmfence_unmap_shm(buffer->shm_fence);
 102    pipe_resource_reference(&buffer->texture, NULL);
 103    FREE(buffer);
 104 }
 105
 106 static void
 107 dri3_handle_stamps(struct vl_dri3_screen *scrn, uint64_t ust, uint64_t msc)
 108 {
 109    int64_t ust_ns =  ust * 1000;
 110
 111    if (scrn->last_ust && (ust_ns > scrn->last_ust) &&
 112        scrn->last_msc && (msc > scrn->last_msc))
 113       scrn->ns_frame = (ust_ns - scrn->last_ust) / (msc - scrn->last_msc);
 114
 115    scrn->last_ust = ust_ns;
 116    scrn->last_msc = msc;
 117 }
 118
 119 static void
 120 dri3_handle_present_event(struct vl_dri3_screen *scrn,
 121                           xcb_present_generic_event_t *ge)
 122 {
 123    switch (ge->evtype) {
 124    case XCB_PRESENT_CONFIGURE_NOTIFY: {
 125       xcb_present_configure_notify_event_t *ce = (void *) ge;
 126       scrn->width = ce->width;
 127       scrn->height = ce->height;
 128       break;
 129    }
 130    case XCB_PRESENT_COMPLETE_NOTIFY: {
 131       xcb_present_complete_notify_event_t *ce = (void *) ge;
 132       if (ce->kind == XCB_PRESENT_COMPLETE_KIND_PIXMAP) {
 133          scrn->recv_sbc = (scrn->send_sbc & 0xffffffff00000000LL) | ce->serial;
 134          if (scrn->recv_sbc > scrn->send_sbc)
 135             scrn->recv_sbc -= 0x100000000;
 136          dri3_handle_stamps(scrn, ce->ust, ce->msc);
 137       } else if (ce->kind == XCB_PRESENT_COMPLETE_KIND_NOTIFY_MSC) {
 138          scrn->recv_msc_serial = ce->serial;
 139          dri3_handle_stamps(scrn, ce->ust, ce->msc);
 140       }
 141       break;
 142    }
 143    case XCB_PRESENT_EVENT_IDLE_NOTIFY: {
 144       xcb_present_idle_notify_event_t *ie = (void *) ge;
 145       int b;
 146       for (b = 0; b < BACK_BUFFER_NUM; b++) {
 147          struct vl_dri3_buffer *buf = scrn->back_buffers[b];
 148          if (buf && buf->pixmap == ie->pixmap) {
 149             buf->busy = false;
 150             break;
 151          }
 152       }
 153       break;
 154    }
 155    }
 156    free(ge);
 157 }
 158
 159 static void
 160 dri3_flush_present_events(struct vl_dri3_screen *scrn)
 161 {
 162    if (scrn->special_event) {
 163       xcb_generic_event_t *ev;
 164       while ((ev = xcb_poll_for_special_event(
 165                    scrn->conn, scrn->special_event)) != NULL)
 166          dri3_handle_present_event(scrn, (xcb_present_generic_event_t *)ev);
 167    }
 168 }
 169
 170 static bool
 171 dri3_wait_present_events(struct vl_dri3_screen *scrn)
 172 {
 173    if (scrn->special_event) {
 174       xcb_generic_event_t *ev;
 175       ev = xcb_wait_for_special_event(scrn->conn, scrn->special_event);
 176       if (!ev)
 177          return false;
 178       dri3_handle_present_event(scrn, (xcb_present_generic_event_t *)ev);
 179       return true;
 180    }
 181    return false;
 182 }
 183
 184 static int
 185 dri3_find_back(struct vl_dri3_screen *scrn)
 186 {
 187    int b;
 188
 189    for (;;) {
 190       for (b = 0; b < BACK_BUFFER_NUM; b++) {
 191          int id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
 192          struct vl_dri3_buffer *buffer = scrn->back_buffers[id];
 193          if (!buffer || !buffer->busy)
 194             return id;
 195       }
 196       xcb_flush(scrn->conn);
 197       if (!dri3_wait_present_events(scrn))
 198          return -1;
 199    }
 200 }
 201
 202 static struct vl_dri3_buffer *
 203 dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
 204 {
 205    struct vl_dri3_buffer *buffer;
 206    xcb_pixmap_t pixmap;
 207    xcb_sync_fence_t sync_fence;
 208    struct xshmfence *shm_fence;
 209    int buffer_fd, fence_fd;
 210    struct pipe_resource templ;
 211    struct winsys_handle whandle;
 212    unsigned usage;
 213
 214    buffer = CALLOC_STRUCT(vl_dri3_buffer);
 215    if (!buffer)
 216       return NULL;
 217
 218    fence_fd = xshmfence_alloc_shm();
 219    if (fence_fd < 0)
 220       goto free_buffer;
 221
 222    shm_fence = xshmfence_map_shm(fence_fd);
 223    if (!shm_fence)
 224       goto close_fd;
 225
 226    memset(&templ, 0, sizeof(templ));
 227    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
 228                 PIPE_BIND_SCANOUT | PIPE_BIND_SHARED;
 229    templ.format = PIPE_FORMAT_B8G8R8X8_UNORM;
 230    templ.target = PIPE_TEXTURE_2D;
 231    templ.last_level = 0;
 232    templ.width0 = scrn->width;
 233    templ.height0 = scrn->height;
 234    templ.depth0 = 1;
 235    templ.array_size = 1;
 236    buffer->texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
 237                                                          &templ);
 238    if (!buffer->texture)
 239       goto unmap_shm;
 240
 241    memset(&whandle, 0, sizeof(whandle));
 242    whandle.type= DRM_API_HANDLE_TYPE_FD;
 243    usage = PIPE_HANDLE_USAGE_EXPLICIT_FLUSH | PIPE_HANDLE_USAGE_READ;
 244    scrn->base.pscreen->resource_get_handle(scrn->base.pscreen,
 245                                            buffer->texture, &whandle,
 246                                            usage);
 247    buffer_fd = whandle.handle;
 248    buffer->pitch = whandle.stride;
 249    xcb_dri3_pixmap_from_buffer(scrn->conn,
 250                                (pixmap = xcb_generate_id(scrn->conn)),
 251                                scrn->drawable,
 252                                0,
 253                                scrn->width, scrn->height, buffer->pitch,
 254                                scrn->depth, 32,
 255                                buffer_fd);
 256    xcb_dri3_fence_from_fd(scrn->conn,
 257                           pixmap,
 258                           (sync_fence = xcb_generate_id(scrn->conn)),
 259                           false,
 260                           fence_fd);
 261
 262    buffer->pixmap = pixmap;
 263    buffer->sync_fence = sync_fence;
 264    buffer->shm_fence = shm_fence;
 265    buffer->width = scrn->width;
 266    buffer->height = scrn->height;
 267
 268    xshmfence_trigger(buffer->shm_fence);
 269
 270    return buffer;
 271
 272 unmap_shm:
 273    xshmfence_unmap_shm(shm_fence);
 274 close_fd:
 275    close(fence_fd);
 276 free_buffer:
 277    FREE(buffer);
 278    return NULL;
 279 }
 280
 281 static struct vl_dri3_buffer *
 282 dri3_get_back_buffer(struct vl_dri3_screen *scrn)
 283 {
 284    struct vl_dri3_buffer *buffer;
 285    struct pipe_resource *texture = NULL;
 286
 287    assert(scrn);
 288
 289    scrn->cur_back = dri3_find_back(scrn);
 290    if (scrn->cur_back < 0)
 291       return NULL;
 292    buffer = scrn->back_buffers[scrn->cur_back];
 293
 294    if (!buffer || buffer->width != scrn->width ||
 295        buffer->height != scrn->height) {
 296       struct vl_dri3_buffer *new_buffer;
 297
 298       new_buffer = dri3_alloc_back_buffer(scrn);
 299       if (!new_buffer)
 300          return NULL;
 301
 302       if (buffer)
 303          dri3_free_back_buffer(scrn, buffer);
 304
 305       vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
 306       buffer = new_buffer;
 307       scrn->back_buffers[scrn->cur_back] = buffer;
 308    }
 309
 310    pipe_resource_reference(&texture, buffer->texture);
 311    xcb_flush(scrn->conn);
 312    xshmfence_await(buffer->shm_fence);
 313
 314    return buffer;
 315 }
 316
 317 static bool
 318 dri3_set_drawable(struct vl_dri3_screen *scrn, Drawable drawable)
 319 {
 320    xcb_get_geometry_cookie_t geom_cookie;
 321    xcb_get_geometry_reply_t *geom_reply;
 322    xcb_void_cookie_t cookie;
 323    xcb_generic_error_t *error;
 324    xcb_present_event_t peid;
 325    bool ret = true;
 326
 327    assert(drawable);
 328
 329    if (scrn->drawable == drawable)
 330       return true;
 331
 332    scrn->drawable = drawable;
 333
 334    geom_cookie = xcb_get_geometry(scrn->conn, scrn->drawable);
 335    geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
 336    if (!geom_reply)
 337       return false;
 338
 339    scrn->width = geom_reply->width;
 340    scrn->height = geom_reply->height;
 341    scrn->depth = geom_reply->depth;
 342    free(geom_reply);
 343
 344    if (scrn->special_event) {
 345       xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
 346       scrn->special_event = NULL;
 347    }
 348
 349    scrn->is_pixmap = false;
 350    peid = xcb_generate_id(scrn->conn);
 351    cookie =
 352       xcb_present_select_input_checked(scrn->conn, peid, scrn->drawable,
 353                       XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY |
 354                       XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY |
 355                       XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY);
 356
 357    error = xcb_request_check(scrn->conn, cookie);
 358    if (error) {
 359       if (error->error_code != BadWindow)
 360          ret = false;
 361       else
 362          scrn->is_pixmap = true;
 363       free(error);
 364    } else
 365       scrn->special_event =
 366          xcb_register_for_special_xge(scrn->conn, &xcb_present_id, peid, 0);
 367
 368    dri3_flush_present_events(scrn);
 369
 370    return ret;
 371 }
 372
 373 static struct vl_dri3_buffer *
 374 dri3_get_front_buffer(struct vl_dri3_screen *scrn)
 375 {
 376    xcb_dri3_buffer_from_pixmap_cookie_t bp_cookie;
 377    xcb_dri3_buffer_from_pixmap_reply_t *bp_reply;
 378    xcb_sync_fence_t sync_fence;
 379    struct xshmfence *shm_fence;
 380    int fence_fd, *fds;
 381    struct winsys_handle whandle;
 382    struct pipe_resource templ, *texture = NULL;
 383
 384    if (scrn->front_buffer) {
 385       pipe_resource_reference(&texture, scrn->front_buffer->texture);
 386       return scrn->front_buffer;
 387    }
 388
 389    scrn->front_buffer = CALLOC_STRUCT(vl_dri3_buffer);
 390    if (!scrn->front_buffer)
 391       return NULL;
 392
 393    fence_fd = xshmfence_alloc_shm();
 394    if (fence_fd < 0)
 395       goto free_buffer;
 396
 397    shm_fence = xshmfence_map_shm(fence_fd);
 398    if (!shm_fence)
 399       goto close_fd;
 400
 401    bp_cookie = xcb_dri3_buffer_from_pixmap(scrn->conn, scrn->drawable);
 402    bp_reply = xcb_dri3_buffer_from_pixmap_reply(scrn->conn, bp_cookie, NULL);
 403    if (!bp_reply)
 404       goto unmap_shm;
 405
 406    fds = xcb_dri3_buffer_from_pixmap_reply_fds(scrn->conn, bp_reply);
 407    if (fds[0] < 0)
 408       goto free_reply;
 409
 410    memset(&whandle, 0, sizeof(whandle));
 411    whandle.type = DRM_API_HANDLE_TYPE_FD;
 412    whandle.handle = (unsigned)fds[0];
 413    whandle.stride = bp_reply->stride;
 414    memset(&templ, 0, sizeof(templ));
 415    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 416    templ.format = PIPE_FORMAT_B8G8R8X8_UNORM;
 417    templ.target = PIPE_TEXTURE_2D;
 418    templ.last_level = 0;
 419    templ.width0 = bp_reply->width;
 420    templ.height0 = bp_reply->height;
 421    templ.depth0 = 1;
 422    templ.array_size = 1;
 423    scrn->front_buffer->texture =
 424       scrn->base.pscreen->resource_from_handle(scrn->base.pscreen,
 425                                                &templ, &whandle,
 426                                                PIPE_HANDLE_USAGE_READ_WRITE);
 427    close(fds[0]);
 428    if (!scrn->front_buffer->texture)
 429       goto free_reply;
 430
 431    xcb_dri3_fence_from_fd(scrn->conn,
 432                           scrn->drawable,
 433                           (sync_fence = xcb_generate_id(scrn->conn)),
 434                           false,
 435                           fence_fd);
 436
 437    pipe_resource_reference(&texture, scrn->front_buffer->texture);
 438    scrn->front_buffer->pixmap = scrn->drawable;
 439    scrn->front_buffer->width = bp_reply->width;
 440    scrn->front_buffer->height = bp_reply->height;
 441    scrn->front_buffer->shm_fence = shm_fence;
 442    scrn->front_buffer->sync_fence = sync_fence;
 443    free(bp_reply);
 444
 445    return scrn->front_buffer;
 446
 447 free_reply:
 448    free(bp_reply);
 449 unmap_shm:
 450    xshmfence_unmap_shm(shm_fence);
 451 close_fd:
 452    close(fence_fd);
 453 free_buffer:
 454    FREE(scrn->front_buffer);
 455    return NULL;
 456 }
 457
 458 static void
 459 vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
 460                           struct pipe_resource *resource,
 461                           unsigned level, unsigned layer,
 462                           void *context_private, struct pipe_box *sub_box)
 463 {
 464    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)context_private;
 465    uint32_t options = XCB_PRESENT_OPTION_NONE;
 466    struct vl_dri3_buffer *back;
 467
 468    back = scrn->back_buffers[scrn->cur_back];
 469    if (!back)
 470        return;
 471
 472    if (scrn->flushed) {
 473       while (scrn->special_event && scrn->recv_sbc < scrn->send_sbc)
 474          if (!dri3_wait_present_events(scrn))
 475             return;
 476    }
 477
 478    xshmfence_reset(back->shm_fence);
 479    back->busy = true;
 480
 481    xcb_present_pixmap(scrn->conn,
 482                       scrn->drawable,
 483                       back->pixmap,
 484                       (uint32_t)(++scrn->send_sbc),
 485                       0, 0, 0, 0,
 486                       None, None,
 487                       back->sync_fence,
 488                       options,
 489                       scrn->next_msc,
 490                       0, 0, 0, NULL);
 491
 492    xcb_flush(scrn->conn);
 493
 494    scrn->flushed = true;
 495
 496    return;
 497 }
 498
 499 static struct pipe_resource *
 500 vl_dri3_screen_texture_from_drawable(struct vl_screen *vscreen, void *drawable)
 501 {
 502    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 503    struct vl_dri3_buffer *buffer;
 504
 505    assert(scrn);
 506
 507    if (!dri3_set_drawable(scrn, (Drawable)drawable))
 508       return NULL;
 509
 510    if (scrn->flushed) {
 511       while (scrn->special_event && scrn->recv_sbc < scrn->send_sbc)
 512          if (!dri3_wait_present_events(scrn))
 513             return NULL;
 514    }
 515    scrn->flushed = false;
 516
 517    buffer = (scrn->is_pixmap) ?
 518             dri3_get_front_buffer(scrn) :
 519             dri3_get_back_buffer(scrn);
 520    if (!buffer)
 521       return NULL;
 522
 523    return buffer->texture;
 524 }
 525
 526 static struct u_rect *
 527 vl_dri3_screen_get_dirty_area(struct vl_screen *vscreen)
 528 {
 529    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 530
 531    assert(scrn);
 532
 533    return &scrn->dirty_areas[scrn->cur_back];
 534 }
 535
 536 static uint64_t
 537 vl_dri3_screen_get_timestamp(struct vl_screen *vscreen, void *drawable)
 538 {
 539    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 540
 541    assert(scrn);
 542
 543    if (!dri3_set_drawable(scrn, (Drawable)drawable))
 544       return 0;
 545
 546    if (!scrn->last_ust) {
 547       xcb_present_notify_msc(scrn->conn,
 548                              scrn->drawable,
 549                              ++scrn->send_msc_serial,
 550                              0, 0, 0);
 551       xcb_flush(scrn->conn);
 552
 553       while (scrn->special_event &&
 554              scrn->send_msc_serial > scrn->recv_msc_serial) {
 555          if (!dri3_wait_present_events(scrn))
 556             return 0;
 557       }
 558    }
 559
 560    return scrn->last_ust;
 561 }
 562
 563 static void
 564 vl_dri3_screen_set_next_timestamp(struct vl_screen *vscreen, uint64_t stamp)
 565 {
 566    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 567
 568    assert(scrn);
 569
 570    if (stamp && scrn->last_ust && scrn->ns_frame && scrn->last_msc)
 571       scrn->next_msc = ((int64_t)stamp - scrn->last_ust + scrn->ns_frame/2) /
 572                        scrn->ns_frame + scrn->last_msc;
 573    else
 574       scrn->next_msc = 0;
 575 }
 576
 577 static void *
 578 vl_dri3_screen_get_private(struct vl_screen *vscreen)
 579 {
 580    return vscreen;
 581 }
 582
 583 static void
 584 vl_dri3_screen_destroy(struct vl_screen *vscreen)
 585 {
 586    struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
 587    int i;
 588
 589    assert(vscreen);
 590
 591    dri3_flush_present_events(scrn);
 592
 593    if (scrn->front_buffer) {
 594       dri3_free_front_buffer(scrn, scrn->front_buffer);
 595       scrn->front_buffer = NULL;
 596       return;
 597    }
 598
 599    for (i = 0; i < BACK_BUFFER_NUM; ++i) {
 600       if (scrn->back_buffers[i]) {
 601          dri3_free_back_buffer(scrn, scrn->back_buffers[i]);
 602          scrn->back_buffers[i] = NULL;
 603       }
 604    }
 605
 606    if (scrn->special_event)
 607       xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
 608    scrn->base.pscreen->destroy(scrn->base.pscreen);
 609    pipe_loader_release(&scrn->base.dev, 1);
 610    FREE(scrn);
 611
 612    return;
 613 }
 614
 615 struct vl_screen *
 616 vl_dri3_screen_create(Display *display, int screen)
 617 {
 618    struct vl_dri3_screen *scrn;
 619    const xcb_query_extension_reply_t *extension;
 620    xcb_dri3_open_cookie_t open_cookie;
 621    xcb_dri3_open_reply_t *open_reply;
 622    xcb_get_geometry_cookie_t geom_cookie;
 623    xcb_get_geometry_reply_t *geom_reply;
 624    int is_different_gpu;
 625    int fd;
 626
 627    assert(display);
 628
 629    scrn = CALLOC_STRUCT(vl_dri3_screen);
 630    if (!scrn)
 631       return NULL;
 632
 633    scrn->conn = XGetXCBConnection(display);
 634    if (!scrn->conn)
 635       goto free_screen;
 636
 637    xcb_prefetch_extension_data(scrn->conn , &xcb_dri3_id);
 638    xcb_prefetch_extension_data(scrn->conn, &xcb_present_id);
 639    extension = xcb_get_extension_data(scrn->conn, &xcb_dri3_id);
 640    if (!(extension && extension->present))
 641       goto free_screen;
 642    extension = xcb_get_extension_data(scrn->conn, &xcb_present_id);
 643    if (!(extension && extension->present))
 644       goto free_screen;
 645
 646    open_cookie = xcb_dri3_open(scrn->conn, RootWindow(display, screen), None);
 647    open_reply = xcb_dri3_open_reply(scrn->conn, open_cookie, NULL);
 648    if (!open_reply)
 649       goto free_screen;
 650    if (open_reply->nfd != 1) {
 651       free(open_reply);
 652       goto free_screen;
 653    }
 654
 655    fd = xcb_dri3_open_reply_fds(scrn->conn, open_reply)[0];
 656    if (fd < 0) {
 657       free(open_reply);
 658       goto free_screen;
 659    }
 660    fcntl(fd, F_SETFD, FD_CLOEXEC);
 661    free(open_reply);
 662
 663    fd = loader_get_user_preferred_fd(fd, &is_different_gpu);
 664    /* TODO support different GPU */
 665    if (is_different_gpu)
 666       goto close_fd;
 667
 668    geom_cookie = xcb_get_geometry(scrn->conn, RootWindow(display, screen));
 669    geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
 670    if (!geom_reply)
 671       goto close_fd;
 672    /* TODO support depth other than 24 */
 673    if (geom_reply->depth != 24) {
 674       free(geom_reply);
 675       goto close_fd;
 676    }
 677    free(geom_reply);
 678
 679    if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
 680       scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
 681
 682    if (!scrn->base.pscreen)
 683       goto release_pipe;
 684
 685    scrn->base.destroy = vl_dri3_screen_destroy;
 686    scrn->base.texture_from_drawable = vl_dri3_screen_texture_from_drawable;
 687    scrn->base.get_dirty_area = vl_dri3_screen_get_dirty_area;
 688    scrn->base.get_timestamp = vl_dri3_screen_get_timestamp;
 689    scrn->base.set_next_timestamp = vl_dri3_screen_set_next_timestamp;
 690    scrn->base.get_private = vl_dri3_screen_get_private;
 691    scrn->base.pscreen->flush_frontbuffer = vl_dri3_flush_frontbuffer;
 692
 693    return &scrn->base;
 694
 695 release_pipe:
 696    if (scrn->base.dev) {
 697       pipe_loader_release(&scrn->base.dev, 1);
 698       fd = -1;
 699    }
 700 close_fd:
 701    if (fd != -1)
 702       close(fd);
 703 free_screen:
 704    FREE(scrn);
 705    return NULL;
 706 }