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