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