src/egl/drivers/dri2/egl_dri2.c

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  19  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Kristian Høgsberg <krh@bitplanet.net>
  26  */
  27
  28 #include <stdbool.h>
  29 #include <stdint.h>
  30 #include <stdbool.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <stdio.h>
  34 #include <limits.h>
  35 #include <dlfcn.h>
  36 #include <fcntl.h>
  37 #include <errno.h>
  38 #include <unistd.h>
  39 #include <c11/threads.h>
  40 #include <time.h>
  41 #ifdef HAVE_LIBDRM
  42 #include <xf86drm.h>
  43 #include "drm-uapi/drm_fourcc.h"
  44 #endif
  45 #include <GL/gl.h>
  46 #include <GL/internal/dri_interface.h>
  47 #include <sys/types.h>
  48 #include <sys/stat.h>
  49
  50 #ifdef HAVE_WAYLAND_PLATFORM
  51 #include <wayland-client.h>
  52 #include "wayland-drm.h"
  53 #include "wayland-drm-client-protocol.h"
  54 #include "linux-dmabuf-unstable-v1-client-protocol.h"
  55 #endif
  56
  57 #ifdef HAVE_X11_PLATFORM
  58 #include "X11/Xlibint.h"
  59 #endif
  60
  61 #include "egldefines.h"
  62 #include "egl_dri2.h"
  63 #include "GL/mesa_glinterop.h"
  64 #include "loader/loader.h"
  65 #include "util/os_file.h"
  66 #include "util/u_atomic.h"
  67 #include "util/u_vector.h"
  68 #include "mapi/glapi/glapi.h"
  69 #include "util/bitscan.h"
  70 #include "util/u_math.h"
  71
  72 #define NUM_ATTRIBS 12
  73
  74 static const struct dri2_pbuffer_visual {
  75    const char *format_name;
  76    unsigned int dri_image_format;
  77    int rgba_shifts[4];
  78    unsigned int rgba_sizes[4];
  79 } dri2_pbuffer_visuals[] = {
  80    {
  81       "ABGR16F",
  82       __DRI_IMAGE_FORMAT_ABGR16161616F,
  83       { 0, 16, 32, 48 },
  84       { 16, 16, 16, 16 }
  85    },
  86    {
  87       "XBGR16F",
  88       __DRI_IMAGE_FORMAT_XBGR16161616F,
  89       { 0, 16, 32, -1 },
  90       { 16, 16, 16, 0 }
  91    },
  92    {
  93       "A2RGB10",
  94       __DRI_IMAGE_FORMAT_ARGB2101010,
  95       { 20, 10, 0, 30 },
  96       { 10, 10, 10, 2 }
  97    },
  98    {
  99       "X2RGB10",
 100       __DRI_IMAGE_FORMAT_XRGB2101010,
 101       { 20, 10, 0, -1 },
 102       { 10, 10, 10, 0 }
 103    },
 104    {
 105       "ARGB8888",
 106       __DRI_IMAGE_FORMAT_ARGB8888,
 107       { 16, 8, 0, 24 },
 108       { 8, 8, 8, 8 }
 109    },
 110    {
 111       "RGB888",
 112       __DRI_IMAGE_FORMAT_XRGB8888,
 113       { 16, 8, 0, -1 },
 114       { 8, 8, 8, 0 }
 115    },
 116    {
 117       "RGB565",
 118       __DRI_IMAGE_FORMAT_RGB565,
 119       { 11, 5, 0, -1 },
 120       { 5, 6, 5, 0 }
 121    },
 122 };
 123
 124 static void
 125 dri_set_background_context(void *loaderPrivate)
 126 {
 127    _EGLContext *ctx = _eglGetCurrentContext();
 128    _EGLThreadInfo *t = _eglGetCurrentThread();
 129
 130    _eglBindContextToThread(ctx, t);
 131 }
 132
 133 static void
 134 dri2_gl_flush()
 135 {
 136    static void (*glFlush)(void);
 137    static mtx_t glFlushMutex = _MTX_INITIALIZER_NP;
 138
 139    mtx_lock(&glFlushMutex);
 140    if (!glFlush)
 141       glFlush = _glapi_get_proc_address("glFlush");
 142    mtx_unlock(&glFlushMutex);
 143
 144    /* if glFlush is not available things are horribly broken */
 145    if (!glFlush) {
 146       _eglLog(_EGL_WARNING, "DRI2: failed to find glFlush entry point");
 147       return;
 148    }
 149
 150    glFlush();
 151 }
 152
 153 static GLboolean
 154 dri_is_thread_safe(void *loaderPrivate)
 155 {
 156    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 157    UNUSED _EGLDisplay *display =  dri2_surf->base.Resource.Display;
 158
 159 #ifdef HAVE_X11_PLATFORM
 160    Display *xdpy = (Display*)display->PlatformDisplay;
 161
 162    /* Check Xlib is running in thread safe mode when running on EGL/X11-xlib
 163     * platform
 164     *
 165     * 'lock_fns' is the XLockDisplay function pointer of the X11 display 'dpy'.
 166     * It wll be NULL if XInitThreads wasn't called.
 167     */
 168    if (display->Platform == _EGL_PLATFORM_X11 && xdpy && !xdpy->lock_fns)
 169       return false;
 170 #endif
 171
 172    return true;
 173 }
 174
 175 const __DRIbackgroundCallableExtension background_callable_extension = {
 176    .base = { __DRI_BACKGROUND_CALLABLE, 2 },
 177
 178    .setBackgroundContext = dri_set_background_context,
 179    .isThreadSafe         = dri_is_thread_safe,
 180 };
 181
 182 const __DRIuseInvalidateExtension use_invalidate = {
 183    .base = { __DRI_USE_INVALIDATE, 1 }
 184 };
 185
 186 static void
 187 dri2_get_pbuffer_drawable_info(__DRIdrawable * draw,
 188                                int *x, int *y, int *w, int *h,
 189                                void *loaderPrivate)
 190 {
 191    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 192
 193    *x = *y = 0;
 194    *w = dri2_surf->base.Width;
 195    *h = dri2_surf->base.Height;
 196 }
 197
 198 static int
 199 dri2_get_bytes_per_pixel(struct dri2_egl_surface *dri2_surf)
 200 {
 201    const int depth = dri2_surf->base.Config->BufferSize;
 202    return depth ? util_next_power_of_two(depth / 8) : 0;
 203 }
 204
 205 static void
 206 dri2_put_image(__DRIdrawable * draw, int op,
 207                int x, int y, int w, int h,
 208                char *data, void *loaderPrivate)
 209 {
 210    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 211    const int bpp = dri2_get_bytes_per_pixel(dri2_surf);
 212    const int width = dri2_surf->base.Width;
 213    const int height = dri2_surf->base.Height;
 214    const int dst_stride = width*bpp;
 215    const int src_stride = w*bpp;
 216    const int x_offset = x*bpp;
 217    int copy_width = src_stride;
 218
 219    if (!dri2_surf->swrast_device_buffer)
 220       dri2_surf->swrast_device_buffer = malloc(height*dst_stride);
 221
 222    if (dri2_surf->swrast_device_buffer) {
 223       const char *src = data;
 224       char *dst = dri2_surf->swrast_device_buffer;
 225
 226       dst += x_offset;
 227       dst += y*dst_stride;
 228
 229       /* Drivers are allowed to submit OOB PutImage requests, so clip here. */
 230       if (copy_width > dst_stride - x_offset)
 231          copy_width = dst_stride - x_offset;
 232       if (h > height - y)
 233          h = height - y;
 234
 235       for (; 0 < h; --h) {
 236          memcpy(dst, src, copy_width);
 237          dst += dst_stride;
 238          src += src_stride;
 239       }
 240    }
 241 }
 242
 243 static void
 244 dri2_get_image(__DRIdrawable * read,
 245                int x, int y, int w, int h,
 246                char *data, void *loaderPrivate)
 247 {
 248    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 249    const int bpp = dri2_get_bytes_per_pixel(dri2_surf);
 250    const int width = dri2_surf->base.Width;
 251    const int height = dri2_surf->base.Height;
 252    const int src_stride = width*bpp;
 253    const int dst_stride = w*bpp;
 254    const int x_offset = x*bpp;
 255    int copy_width = dst_stride;
 256    const char *src = dri2_surf->swrast_device_buffer;
 257    char *dst = data;
 258
 259    if (!src) {
 260       memset(data, 0, copy_width * h);
 261       return;
 262    }
 263
 264    src += x_offset;
 265    src += y*src_stride;
 266
 267    /* Drivers are allowed to submit OOB GetImage requests, so clip here. */
 268    if (copy_width > src_stride - x_offset)
 269       copy_width = src_stride - x_offset;
 270    if (h > height - y)
 271       h = height - y;
 272
 273    for (; 0 < h; --h) {
 274       memcpy(dst, src, copy_width);
 275       src += src_stride;
 276       dst += dst_stride;
 277    }
 278
 279 }
 280
 281 /* HACK: technically we should have swrast_null, instead of these.
 282  */
 283 const __DRIswrastLoaderExtension swrast_pbuffer_loader_extension = {
 284    .base            = { __DRI_SWRAST_LOADER, 1 },
 285    .getDrawableInfo = dri2_get_pbuffer_drawable_info,
 286    .putImage        = dri2_put_image,
 287    .getImage        = dri2_get_image,
 288 };
 289
 290 static const EGLint dri2_to_egl_attribute_map[__DRI_ATTRIB_MAX] = {
 291    [__DRI_ATTRIB_BUFFER_SIZE ]          = EGL_BUFFER_SIZE,
 292    [__DRI_ATTRIB_LEVEL]                 = EGL_LEVEL,
 293    [__DRI_ATTRIB_LUMINANCE_SIZE]        = EGL_LUMINANCE_SIZE,
 294    [__DRI_ATTRIB_DEPTH_SIZE]            = EGL_DEPTH_SIZE,
 295    [__DRI_ATTRIB_STENCIL_SIZE]          = EGL_STENCIL_SIZE,
 296    [__DRI_ATTRIB_SAMPLE_BUFFERS]        = EGL_SAMPLE_BUFFERS,
 297    [__DRI_ATTRIB_SAMPLES]               = EGL_SAMPLES,
 298    [__DRI_ATTRIB_MAX_PBUFFER_WIDTH]     = EGL_MAX_PBUFFER_WIDTH,
 299    [__DRI_ATTRIB_MAX_PBUFFER_HEIGHT]    = EGL_MAX_PBUFFER_HEIGHT,
 300    [__DRI_ATTRIB_MAX_PBUFFER_PIXELS]    = EGL_MAX_PBUFFER_PIXELS,
 301    [__DRI_ATTRIB_MAX_SWAP_INTERVAL]     = EGL_MAX_SWAP_INTERVAL,
 302    [__DRI_ATTRIB_MIN_SWAP_INTERVAL]     = EGL_MIN_SWAP_INTERVAL,
 303    [__DRI_ATTRIB_YINVERTED]             = EGL_Y_INVERTED_NOK,
 304 };
 305
 306 const __DRIconfig *
 307 dri2_get_dri_config(struct dri2_egl_config *conf, EGLint surface_type,
 308                     EGLenum colorspace)
 309 {
 310    const bool double_buffer = surface_type == EGL_WINDOW_BIT;
 311    const bool srgb = colorspace == EGL_GL_COLORSPACE_SRGB_KHR;
 312
 313    return conf->dri_config[double_buffer][srgb];
 314 }
 315
 316 static EGLBoolean
 317 dri2_match_config(const _EGLConfig *conf, const _EGLConfig *criteria)
 318 {
 319    if (_eglCompareConfigs(conf, criteria, NULL, EGL_FALSE) != 0)
 320       return EGL_FALSE;
 321
 322    if (!_eglMatchConfig(conf, criteria))
 323       return EGL_FALSE;
 324
 325    return EGL_TRUE;
 326 }
 327
 328 void
 329 dri2_get_shifts_and_sizes(const __DRIcoreExtension *core,
 330                           const __DRIconfig *config, int *shifts,
 331                           unsigned int *sizes)
 332 {
 333    unsigned int mask;
 334
 335    if (core->getConfigAttrib(config, __DRI_ATTRIB_RED_SHIFT, (unsigned int *)&shifts[0])) {
 336       core->getConfigAttrib(config, __DRI_ATTRIB_GREEN_SHIFT, (unsigned int *)&shifts[1]);
 337       core->getConfigAttrib(config, __DRI_ATTRIB_BLUE_SHIFT, (unsigned int *)&shifts[2]);
 338       core->getConfigAttrib(config, __DRI_ATTRIB_ALPHA_SHIFT, (unsigned int *)&shifts[3]);
 339    } else {
 340       /* Driver isn't exposing shifts, so convert masks to shifts */
 341       core->getConfigAttrib(config, __DRI_ATTRIB_RED_MASK, &mask);
 342       shifts[0] = ffs(mask) - 1;
 343       core->getConfigAttrib(config, __DRI_ATTRIB_GREEN_MASK, &mask);
 344       shifts[1] = ffs(mask) - 1;
 345       core->getConfigAttrib(config, __DRI_ATTRIB_BLUE_MASK, &mask);
 346       shifts[2] = ffs(mask) - 1;
 347       core->getConfigAttrib(config, __DRI_ATTRIB_ALPHA_MASK, &mask);
 348       shifts[3] = ffs(mask) - 1;
 349    }
 350
 351    core->getConfigAttrib(config, __DRI_ATTRIB_RED_SIZE, &sizes[0]);
 352    core->getConfigAttrib(config, __DRI_ATTRIB_GREEN_SIZE, &sizes[1]);
 353    core->getConfigAttrib(config, __DRI_ATTRIB_BLUE_SIZE, &sizes[2]);
 354    core->getConfigAttrib(config, __DRI_ATTRIB_ALPHA_SIZE, &sizes[3]);
 355 }
 356
 357 void
 358 dri2_get_render_type_float(const __DRIcoreExtension *core,
 359                            const __DRIconfig *config,
 360                            bool *is_float)
 361 {
 362    unsigned int render_type;
 363
 364    core->getConfigAttrib(config, __DRI_ATTRIB_RENDER_TYPE, &render_type);
 365    *is_float = (render_type & __DRI_ATTRIB_FLOAT_BIT) ? true : false;
 366 }
 367
 368 unsigned int
 369 dri2_image_format_for_pbuffer_config(struct dri2_egl_display *dri2_dpy,
 370                                      const __DRIconfig *config)
 371 {
 372    int shifts[4];
 373    unsigned int sizes[4];
 374
 375    dri2_get_shifts_and_sizes(dri2_dpy->core, config, shifts, sizes);
 376
 377    for (unsigned i = 0; i < ARRAY_SIZE(dri2_pbuffer_visuals); ++i) {
 378       const struct dri2_pbuffer_visual *visual = &dri2_pbuffer_visuals[i];
 379
 380       if (shifts[0] == visual->rgba_shifts[0] &&
 381           shifts[1] == visual->rgba_shifts[1] &&
 382           shifts[2] == visual->rgba_shifts[2] &&
 383           shifts[3] == visual->rgba_shifts[3] &&
 384           sizes[0] == visual->rgba_sizes[0] &&
 385           sizes[1] == visual->rgba_sizes[1] &&
 386           sizes[2] == visual->rgba_sizes[2] &&
 387           sizes[3] == visual->rgba_sizes[3]) {
 388          return visual->dri_image_format;
 389       }
 390    }
 391
 392    return __DRI_IMAGE_FORMAT_NONE;
 393 }
 394
 395 struct dri2_egl_config *
 396 dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
 397                 EGLint surface_type, const EGLint *attr_list,
 398                 const int *rgba_shifts, const unsigned int *rgba_sizes)
 399 {
 400    struct dri2_egl_config *conf;
 401    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 402    _EGLConfig base;
 403    unsigned int attrib, value, double_buffer;
 404    bool srgb = false;
 405    EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
 406    int dri_shifts[4] = { -1, -1, -1, -1 };
 407    unsigned int dri_sizes[4] = { 0, 0, 0, 0 };
 408    _EGLConfig *matching_config;
 409    EGLint num_configs = 0;
 410    EGLint config_id;
 411
 412    _eglInitConfig(&base, disp, id);
 413
 414    double_buffer = 0;
 415    bind_to_texture_rgb = 0;
 416    bind_to_texture_rgba = 0;
 417
 418    for (int i = 0; i < __DRI_ATTRIB_MAX; ++i) {
 419       if (!dri2_dpy->core->indexConfigAttrib(dri_config, i, &attrib, &value))
 420          break;
 421
 422       switch (attrib) {
 423       case __DRI_ATTRIB_RENDER_TYPE:
 424          if (value & __DRI_ATTRIB_FLOAT_BIT)
 425             base.ComponentType = EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT;
 426          if (value & __DRI_ATTRIB_RGBA_BIT)
 427             value = EGL_RGB_BUFFER;
 428          else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
 429             value = EGL_LUMINANCE_BUFFER;
 430          else
 431             return NULL;
 432          base.ColorBufferType = value;
 433          break;
 434
 435       case __DRI_ATTRIB_CONFIG_CAVEAT:
 436          if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
 437             value = EGL_NON_CONFORMANT_CONFIG;
 438          else if (value & __DRI_ATTRIB_SLOW_BIT)
 439             value = EGL_SLOW_CONFIG;
 440          else
 441             value = EGL_NONE;
 442          base.ConfigCaveat = value;
 443          break;
 444
 445       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
 446          bind_to_texture_rgb = value;
 447          break;
 448
 449       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
 450          bind_to_texture_rgba = value;
 451          break;
 452
 453       case __DRI_ATTRIB_DOUBLE_BUFFER:
 454          double_buffer = value;
 455          break;
 456
 457       case __DRI_ATTRIB_RED_SIZE:
 458          dri_sizes[0] = value;
 459          base.RedSize = value;
 460          break;
 461
 462       case __DRI_ATTRIB_RED_MASK:
 463          dri_shifts[0] = ffs(value) - 1;
 464          break;
 465
 466       case __DRI_ATTRIB_RED_SHIFT:
 467          dri_shifts[0] = value;
 468          break;
 469
 470       case __DRI_ATTRIB_GREEN_SIZE:
 471          dri_sizes[1] = value;
 472          base.GreenSize = value;
 473          break;
 474
 475       case __DRI_ATTRIB_GREEN_MASK:
 476          dri_shifts[1] = ffs(value) - 1;
 477          break;
 478
 479       case __DRI_ATTRIB_GREEN_SHIFT:
 480          dri_shifts[1] = value;
 481          break;
 482
 483       case __DRI_ATTRIB_BLUE_SIZE:
 484          dri_sizes[2] = value;
 485          base.BlueSize = value;
 486          break;
 487
 488       case __DRI_ATTRIB_BLUE_MASK:
 489          dri_shifts[2] = ffs(value) - 1;
 490          break;
 491
 492       case __DRI_ATTRIB_BLUE_SHIFT:
 493          dri_shifts[2] = value;
 494          break;
 495
 496      case __DRI_ATTRIB_ALPHA_SIZE:
 497          dri_sizes[3] = value;
 498          base.AlphaSize = value;
 499          break;
 500
 501       case __DRI_ATTRIB_ALPHA_MASK:
 502          dri_shifts[3] = ffs(value) - 1;
 503          break;
 504
 505       case __DRI_ATTRIB_ALPHA_SHIFT:
 506          dri_shifts[3] = value;
 507          break;
 508
 509       case __DRI_ATTRIB_ACCUM_RED_SIZE:
 510       case __DRI_ATTRIB_ACCUM_GREEN_SIZE:
 511       case __DRI_ATTRIB_ACCUM_BLUE_SIZE:
 512       case __DRI_ATTRIB_ACCUM_ALPHA_SIZE:
 513          /* Don't expose visuals with the accumulation buffer. */
 514          if (value > 0)
 515             return NULL;
 516          break;
 517
 518       case __DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE:
 519          srgb = value != 0;
 520          if (!disp->Extensions.KHR_gl_colorspace && srgb)
 521             return NULL;
 522          break;
 523
 524       case __DRI_ATTRIB_MAX_PBUFFER_WIDTH:
 525          base.MaxPbufferWidth = _EGL_MAX_PBUFFER_WIDTH;
 526          break;
 527       case __DRI_ATTRIB_MAX_PBUFFER_HEIGHT:
 528          base.MaxPbufferHeight = _EGL_MAX_PBUFFER_HEIGHT;
 529          break;
 530       case __DRI_ATTRIB_MUTABLE_RENDER_BUFFER:
 531          if (disp->Extensions.KHR_mutable_render_buffer)
 532             surface_type |= EGL_MUTABLE_RENDER_BUFFER_BIT_KHR;
 533          break;
 534       default:
 535          key = dri2_to_egl_attribute_map[attrib];
 536          if (key != 0)
 537             _eglSetConfigKey(&base, key, value);
 538          break;
 539       }
 540    }
 541
 542    if (attr_list)
 543       for (int i = 0; attr_list[i] != EGL_NONE; i += 2)
 544          _eglSetConfigKey(&base, attr_list[i], attr_list[i+1]);
 545
 546    if (rgba_shifts && memcmp(rgba_shifts, dri_shifts, sizeof(dri_shifts)))
 547       return NULL;
 548
 549    if (rgba_sizes && memcmp(rgba_sizes, dri_sizes, sizeof(dri_sizes)))
 550       return NULL;
 551
 552    base.NativeRenderable = EGL_TRUE;
 553
 554    base.SurfaceType = surface_type;
 555    if (surface_type & (EGL_PBUFFER_BIT |
 556        (disp->Extensions.NOK_texture_from_pixmap ? EGL_PIXMAP_BIT : 0))) {
 557       base.BindToTextureRGB = bind_to_texture_rgb;
 558       if (base.AlphaSize > 0)
 559          base.BindToTextureRGBA = bind_to_texture_rgba;
 560    }
 561
 562    if (double_buffer) {
 563       surface_type &= ~EGL_PIXMAP_BIT;
 564    }
 565
 566    /* No support for pbuffer + MSAA for now.
 567     *
 568     * XXX TODO: pbuffer + MSAA does not work and causes crashes.
 569     * See QT bugreport: https://bugreports.qt.io/browse/QTBUG-47509
 570     */
 571    if (base.Samples) {
 572       surface_type &= ~EGL_PBUFFER_BIT;
 573    }
 574
 575    if (!surface_type)
 576       return NULL;
 577
 578    base.RenderableType = disp->ClientAPIs;
 579    base.Conformant = disp->ClientAPIs;
 580
 581    base.MinSwapInterval = dri2_dpy->min_swap_interval;
 582    base.MaxSwapInterval = dri2_dpy->max_swap_interval;
 583
 584    if (!_eglValidateConfig(&base, EGL_FALSE)) {
 585       _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
 586       return NULL;
 587    }
 588
 589    config_id = base.ConfigID;
 590    base.ConfigID    = EGL_DONT_CARE;
 591    base.SurfaceType = EGL_DONT_CARE;
 592    num_configs = _eglFilterArray(disp->Configs, (void **) &matching_config, 1,
 593                                  (_EGLArrayForEach) dri2_match_config, &base);
 594
 595    if (num_configs == 1) {
 596       conf = (struct dri2_egl_config *) matching_config;
 597
 598       if (!conf->dri_config[double_buffer][srgb])
 599          conf->dri_config[double_buffer][srgb] = dri_config;
 600       else
 601          /* a similar config type is already added (unlikely) => discard */
 602          return NULL;
 603    }
 604    else if (num_configs == 0) {
 605       conf = calloc(1, sizeof *conf);
 606       if (conf == NULL)
 607          return NULL;
 608
 609       conf->dri_config[double_buffer][srgb] = dri_config;
 610
 611       memcpy(&conf->base, &base, sizeof base);
 612       conf->base.SurfaceType = 0;
 613       conf->base.ConfigID = config_id;
 614
 615       _eglLinkConfig(&conf->base);
 616    }
 617    else {
 618       unreachable("duplicates should not be possible");
 619       return NULL;
 620    }
 621
 622    conf->base.SurfaceType |= surface_type;
 623
 624    return conf;
 625 }
 626
 627 EGLBoolean
 628 dri2_add_pbuffer_configs_for_visuals(_EGLDisplay *disp)
 629 {
 630    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 631    unsigned int format_count[ARRAY_SIZE(dri2_pbuffer_visuals)] = { 0 };
 632    unsigned int config_count = 0;
 633
 634    for (unsigned i = 0; dri2_dpy->driver_configs[i] != NULL; i++) {
 635       for (unsigned j = 0; j < ARRAY_SIZE(dri2_pbuffer_visuals); j++) {
 636          struct dri2_egl_config *dri2_conf;
 637
 638          dri2_conf = dri2_add_config(disp, dri2_dpy->driver_configs[i],
 639                config_count + 1, EGL_PBUFFER_BIT, NULL,
 640                dri2_pbuffer_visuals[j].rgba_shifts, dri2_pbuffer_visuals[j].rgba_sizes);
 641
 642          if (dri2_conf) {
 643             if (dri2_conf->base.ConfigID == config_count + 1)
 644                config_count++;
 645             format_count[j]++;
 646          }
 647       }
 648    }
 649
 650    for (unsigned i = 0; i < ARRAY_SIZE(format_count); i++) {
 651       if (!format_count[i]) {
 652          _eglLog(_EGL_DEBUG, "No DRI config supports native format %s",
 653                dri2_pbuffer_visuals[i].format_name);
 654       }
 655    }
 656
 657    return (config_count != 0);
 658 }
 659
 660 __DRIimage *
 661 dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
 662 {
 663    _EGLDisplay *disp = data;
 664    struct dri2_egl_image *dri2_img;
 665    _EGLImage *img;
 666
 667    (void) screen;
 668
 669    mtx_lock(&disp->Mutex);
 670    img = _eglLookupImage(image, disp);
 671    mtx_unlock(&disp->Mutex);
 672
 673    if (img == NULL) {
 674       _eglError(EGL_BAD_PARAMETER, "dri2_lookup_egl_image");
 675       return NULL;
 676    }
 677
 678    dri2_img = dri2_egl_image(image);
 679
 680    return dri2_img->dri_image;
 681 }
 682
 683 const __DRIimageLookupExtension image_lookup_extension = {
 684    .base = { __DRI_IMAGE_LOOKUP, 1 },
 685
 686    .lookupEGLImage       = dri2_lookup_egl_image
 687 };
 688
 689 struct dri2_extension_match {
 690    const char *name;
 691    int version;
 692    int offset;
 693 };
 694
 695 static const struct dri2_extension_match dri3_driver_extensions[] = {
 696    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 697    { __DRI_IMAGE_DRIVER, 1, offsetof(struct dri2_egl_display, image_driver) },
 698    { NULL, 0, 0 }
 699 };
 700
 701 static const struct dri2_extension_match dri2_driver_extensions[] = {
 702    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 703    { __DRI_DRI2, 2, offsetof(struct dri2_egl_display, dri2) },
 704    { NULL, 0, 0 }
 705 };
 706
 707 static const struct dri2_extension_match dri2_core_extensions[] = {
 708    { __DRI2_FLUSH, 1, offsetof(struct dri2_egl_display, flush) },
 709    { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
 710    { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
 711    { NULL, 0, 0 }
 712 };
 713
 714 static const struct dri2_extension_match swrast_driver_extensions[] = {
 715    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 716    { __DRI_SWRAST, 2, offsetof(struct dri2_egl_display, swrast) },
 717    { NULL, 0, 0 }
 718 };
 719
 720 static const struct dri2_extension_match swrast_core_extensions[] = {
 721    { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
 722    { NULL, 0, 0 }
 723 };
 724
 725 static const struct dri2_extension_match optional_driver_extensions[] = {
 726    { __DRI_CONFIG_OPTIONS, 1, offsetof(struct dri2_egl_display, configOptions) },
 727    { NULL, 0, 0 }
 728 };
 729
 730 static const struct dri2_extension_match optional_core_extensions[] = {
 731    { __DRI2_ROBUSTNESS, 1, offsetof(struct dri2_egl_display, robustness) },
 732    { __DRI2_NO_ERROR, 1, offsetof(struct dri2_egl_display, no_error) },
 733    { __DRI2_CONFIG_QUERY, 1, offsetof(struct dri2_egl_display, config) },
 734    { __DRI2_FENCE, 1, offsetof(struct dri2_egl_display, fence) },
 735    { __DRI2_BUFFER_DAMAGE, 1, offsetof(struct dri2_egl_display, buffer_damage) },
 736    { __DRI2_RENDERER_QUERY, 1, offsetof(struct dri2_egl_display, rendererQuery) },
 737    { __DRI2_INTEROP, 1, offsetof(struct dri2_egl_display, interop) },
 738    { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
 739    { __DRI2_FLUSH_CONTROL, 1, offsetof(struct dri2_egl_display, flush_control) },
 740    { __DRI2_BLOB, 1, offsetof(struct dri2_egl_display, blob) },
 741    { __DRI_MUTABLE_RENDER_BUFFER_DRIVER, 1, offsetof(struct dri2_egl_display, mutable_render_buffer) },
 742    { NULL, 0, 0 }
 743 };
 744
 745 static EGLBoolean
 746 dri2_bind_extensions(struct dri2_egl_display *dri2_dpy,
 747                      const struct dri2_extension_match *matches,
 748                      const __DRIextension **extensions,
 749                      bool optional)
 750 {
 751    int ret = EGL_TRUE;
 752    void *field;
 753
 754    for (int i = 0; extensions[i]; i++) {
 755       _eglLog(_EGL_DEBUG, "found extension `%s'", extensions[i]->name);
 756       for (int j = 0; matches[j].name; j++) {
 757          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 758              extensions[i]->version >= matches[j].version) {
 759             field = ((char *) dri2_dpy + matches[j].offset);
 760             *(const __DRIextension **) field = extensions[i];
 761             _eglLog(_EGL_INFO, "found extension %s version %d",
 762                     extensions[i]->name, extensions[i]->version);
 763             break;
 764          }
 765       }
 766    }
 767
 768    for (int j = 0; matches[j].name; j++) {
 769       field = ((char *) dri2_dpy + matches[j].offset);
 770       if (*(const __DRIextension **) field == NULL) {
 771          if (optional) {
 772             _eglLog(_EGL_DEBUG, "did not find optional extension %s version %d",
 773                     matches[j].name, matches[j].version);
 774          } else {
 775             _eglLog(_EGL_WARNING, "did not find extension %s version %d",
 776                     matches[j].name, matches[j].version);
 777             ret = EGL_FALSE;
 778          }
 779       }
 780    }
 781
 782    return ret;
 783 }
 784
 785 static const __DRIextension **
 786 dri2_open_driver(_EGLDisplay *disp)
 787 {
 788    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 789    static const char *search_path_vars[] = {
 790       "LIBGL_DRIVERS_PATH",
 791       NULL,
 792    };
 793
 794    return loader_open_driver(dri2_dpy->driver_name,
 795                              &dri2_dpy->driver,
 796                              search_path_vars);
 797 }
 798
 799 static EGLBoolean
 800 dri2_load_driver_common(_EGLDisplay *disp,
 801                         const struct dri2_extension_match *driver_extensions)
 802 {
 803    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 804    const __DRIextension **extensions;
 805
 806    extensions = dri2_open_driver(disp);
 807    if (!extensions)
 808       return EGL_FALSE;
 809
 810    if (!dri2_bind_extensions(dri2_dpy, driver_extensions, extensions, false)) {
 811       dlclose(dri2_dpy->driver);
 812       dri2_dpy->driver = NULL;
 813       return EGL_FALSE;
 814    }
 815    dri2_dpy->driver_extensions = extensions;
 816
 817    dri2_bind_extensions(dri2_dpy, optional_driver_extensions, extensions, true);
 818
 819    return EGL_TRUE;
 820 }
 821
 822 EGLBoolean
 823 dri2_load_driver(_EGLDisplay *disp)
 824 {
 825    return dri2_load_driver_common(disp, dri2_driver_extensions);
 826 }
 827
 828 EGLBoolean
 829 dri2_load_driver_dri3(_EGLDisplay *disp)
 830 {
 831    return dri2_load_driver_common(disp, dri3_driver_extensions);
 832 }
 833
 834 EGLBoolean
 835 dri2_load_driver_swrast(_EGLDisplay *disp)
 836 {
 837    return dri2_load_driver_common(disp, swrast_driver_extensions);
 838 }
 839
 840 static unsigned
 841 dri2_renderer_query_integer(struct dri2_egl_display *dri2_dpy, int param)
 842 {
 843    const __DRI2rendererQueryExtension *rendererQuery = dri2_dpy->rendererQuery;
 844    unsigned int value = 0;
 845
 846    if (!rendererQuery ||
 847        rendererQuery->queryInteger(dri2_dpy->dri_screen, param, &value) == -1)
 848       return 0;
 849
 850    return value;
 851 }
 852
 853 static const char *
 854 dri2_query_driver_name(_EGLDisplay *disp)
 855 {
 856     struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 857     return dri2_dpy->driver_name;
 858 }
 859
 860 static char *
 861 dri2_query_driver_config(_EGLDisplay *disp)
 862 {
 863     struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 864     const __DRIconfigOptionsExtension *ext = dri2_dpy->configOptions;
 865
 866     if (ext->base.version >= 2)
 867         return ext->getXml(dri2_dpy->driver_name);
 868
 869     return strdup(ext->xml);
 870 }
 871
 872
 873 void
 874 dri2_setup_screen(_EGLDisplay *disp)
 875 {
 876    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 877    unsigned int api_mask;
 878
 879    /*
 880     * EGL 1.5 specification defines the default value to 1. Moreover,
 881     * eglSwapInterval() is required to clamp requested value to the supported
 882     * range. Since the default value is implicitly assumed to be supported,
 883     * use it as both minimum and maximum for the platforms that do not allow
 884     * changing the interval. Platforms, which allow it (e.g. x11, wayland)
 885     * override these values already.
 886     */
 887    dri2_dpy->min_swap_interval = 1;
 888    dri2_dpy->max_swap_interval = 1;
 889    dri2_dpy->default_swap_interval = 1;
 890
 891    if (dri2_dpy->image_driver) {
 892       api_mask = dri2_dpy->image_driver->getAPIMask(dri2_dpy->dri_screen);
 893    } else if (dri2_dpy->dri2) {
 894       api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
 895    } else {
 896       assert(dri2_dpy->swrast);
 897       api_mask = 1 << __DRI_API_OPENGL |
 898                  1 << __DRI_API_GLES |
 899                  1 << __DRI_API_GLES2 |
 900                  1 << __DRI_API_GLES3;
 901    }
 902
 903    disp->ClientAPIs = 0;
 904    if ((api_mask & (1 <<__DRI_API_OPENGL)) && _eglIsApiValid(EGL_OPENGL_API))
 905       disp->ClientAPIs |= EGL_OPENGL_BIT;
 906    if ((api_mask & (1 << __DRI_API_GLES)) && _eglIsApiValid(EGL_OPENGL_ES_API))
 907       disp->ClientAPIs |= EGL_OPENGL_ES_BIT;
 908    if ((api_mask & (1 << __DRI_API_GLES2)) && _eglIsApiValid(EGL_OPENGL_ES_API))
 909       disp->ClientAPIs |= EGL_OPENGL_ES2_BIT;
 910    if ((api_mask & (1 << __DRI_API_GLES3)) && _eglIsApiValid(EGL_OPENGL_ES_API))
 911       disp->ClientAPIs |= EGL_OPENGL_ES3_BIT_KHR;
 912
 913    assert(dri2_dpy->image_driver || dri2_dpy->dri2 || dri2_dpy->swrast);
 914    disp->Extensions.KHR_no_config_context = EGL_TRUE;
 915    disp->Extensions.KHR_surfaceless_context = EGL_TRUE;
 916
 917    if (dri2_dpy->configOptions) {
 918        disp->Extensions.MESA_query_driver = EGL_TRUE;
 919    }
 920
 921    /* Report back to EGL the bitmask of priorities supported */
 922    disp->Extensions.IMG_context_priority =
 923       dri2_renderer_query_integer(dri2_dpy,
 924                                   __DRI2_RENDERER_HAS_CONTEXT_PRIORITY);
 925
 926    disp->Extensions.EXT_pixel_format_float = EGL_TRUE;
 927
 928    if (dri2_renderer_query_integer(dri2_dpy,
 929                                    __DRI2_RENDERER_HAS_FRAMEBUFFER_SRGB))
 930       disp->Extensions.KHR_gl_colorspace = EGL_TRUE;
 931
 932    if (dri2_dpy->image_driver ||
 933        (dri2_dpy->dri2 && dri2_dpy->dri2->base.version >= 3) ||
 934        (dri2_dpy->swrast && dri2_dpy->swrast->base.version >= 3)) {
 935       disp->Extensions.KHR_create_context = EGL_TRUE;
 936
 937       if (dri2_dpy->robustness)
 938          disp->Extensions.EXT_create_context_robustness = EGL_TRUE;
 939    }
 940
 941    if (dri2_dpy->no_error)
 942       disp->Extensions.KHR_create_context_no_error = EGL_TRUE;
 943
 944    if (dri2_dpy->fence) {
 945       disp->Extensions.KHR_fence_sync = EGL_TRUE;
 946       disp->Extensions.KHR_wait_sync = EGL_TRUE;
 947       if (dri2_dpy->fence->get_fence_from_cl_event)
 948          disp->Extensions.KHR_cl_event2 = EGL_TRUE;
 949       if (dri2_dpy->fence->base.version >= 2 &&
 950           dri2_dpy->fence->get_capabilities) {
 951          unsigned capabilities =
 952             dri2_dpy->fence->get_capabilities(dri2_dpy->dri_screen);
 953          disp->Extensions.ANDROID_native_fence_sync =
 954             (capabilities & __DRI_FENCE_CAP_NATIVE_FD) != 0;
 955       }
 956    }
 957
 958    if (dri2_dpy->blob)
 959       disp->Extensions.ANDROID_blob_cache = EGL_TRUE;
 960
 961    disp->Extensions.KHR_reusable_sync = EGL_TRUE;
 962
 963    if (dri2_dpy->image) {
 964       if (dri2_dpy->image->base.version >= 10 &&
 965           dri2_dpy->image->getCapabilities != NULL) {
 966          int capabilities;
 967
 968          capabilities = dri2_dpy->image->getCapabilities(dri2_dpy->dri_screen);
 969          disp->Extensions.MESA_drm_image = (capabilities & __DRI_IMAGE_CAP_GLOBAL_NAMES) != 0;
 970
 971          if (dri2_dpy->image->base.version >= 11)
 972             disp->Extensions.MESA_image_dma_buf_export = EGL_TRUE;
 973       } else {
 974          disp->Extensions.MESA_drm_image = EGL_TRUE;
 975          if (dri2_dpy->image->base.version >= 11)
 976             disp->Extensions.MESA_image_dma_buf_export = EGL_TRUE;
 977       }
 978
 979       disp->Extensions.KHR_image_base = EGL_TRUE;
 980       disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
 981       if (dri2_dpy->image->base.version >= 5 &&
 982           dri2_dpy->image->createImageFromTexture) {
 983          disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
 984          disp->Extensions.KHR_gl_texture_cubemap_image = EGL_TRUE;
 985
 986          if (dri2_renderer_query_integer(dri2_dpy,
 987                                          __DRI2_RENDERER_HAS_TEXTURE_3D))
 988              disp->Extensions.KHR_gl_texture_3D_image = EGL_TRUE;
 989       }
 990 #ifdef HAVE_LIBDRM
 991       if (dri2_dpy->image->base.version >= 8 &&
 992           dri2_dpy->image->createImageFromDmaBufs) {
 993          disp->Extensions.EXT_image_dma_buf_import = EGL_TRUE;
 994          disp->Extensions.EXT_image_dma_buf_import_modifiers = EGL_TRUE;
 995       }
 996 #endif
 997    }
 998
 999    if (dri2_dpy->flush_control)
1000       disp->Extensions.KHR_context_flush_control = EGL_TRUE;
1001
1002    if (dri2_dpy->buffer_damage && dri2_dpy->buffer_damage->set_damage_region)
1003       disp->Extensions.KHR_partial_update = EGL_TRUE;
1004
1005    disp->Extensions.EXT_protected_surface =
1006       dri2_renderer_query_integer(dri2_dpy,
1007                                   __DRI2_RENDERER_HAS_PROTECTED_CONTENT);
1008 }
1009
1010 void
1011 dri2_setup_swap_interval(_EGLDisplay *disp, int max_swap_interval)
1012 {
1013    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1014    GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
1015
1016    /* Allow driconf to override applications.*/
1017    if (dri2_dpy->config)
1018       dri2_dpy->config->configQueryi(dri2_dpy->dri_screen,
1019                                      "vblank_mode", &vblank_mode);
1020    switch (vblank_mode) {
1021    case DRI_CONF_VBLANK_NEVER:
1022       dri2_dpy->min_swap_interval = 0;
1023       dri2_dpy->max_swap_interval = 0;
1024       dri2_dpy->default_swap_interval = 0;
1025       break;
1026    case DRI_CONF_VBLANK_ALWAYS_SYNC:
1027       dri2_dpy->min_swap_interval = 1;
1028       dri2_dpy->max_swap_interval = max_swap_interval;
1029       dri2_dpy->default_swap_interval = 1;
1030       break;
1031    case DRI_CONF_VBLANK_DEF_INTERVAL_0:
1032       dri2_dpy->min_swap_interval = 0;
1033       dri2_dpy->max_swap_interval = max_swap_interval;
1034       dri2_dpy->default_swap_interval = 0;
1035       break;
1036    default:
1037    case DRI_CONF_VBLANK_DEF_INTERVAL_1:
1038       dri2_dpy->min_swap_interval = 0;
1039       dri2_dpy->max_swap_interval = max_swap_interval;
1040       dri2_dpy->default_swap_interval = 1;
1041       break;
1042    }
1043 }
1044
1045 /* All platforms but DRM call this function to create the screen and populate
1046  * the driver_configs. DRM inherits that information from its display - GBM.
1047  */
1048 EGLBoolean
1049 dri2_create_screen(_EGLDisplay *disp)
1050 {
1051    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1052
1053    if (dri2_dpy->image_driver) {
1054       dri2_dpy->dri_screen =
1055          dri2_dpy->image_driver->createNewScreen2(0, dri2_dpy->fd,
1056                                                   dri2_dpy->loader_extensions,
1057                                                   dri2_dpy->driver_extensions,
1058                                                   &dri2_dpy->driver_configs,
1059                                                   disp);
1060    } else if (dri2_dpy->dri2) {
1061       if (dri2_dpy->dri2->base.version >= 4) {
1062          dri2_dpy->dri_screen =
1063             dri2_dpy->dri2->createNewScreen2(0, dri2_dpy->fd,
1064                                              dri2_dpy->loader_extensions,
1065                                              dri2_dpy->driver_extensions,
1066                                              &dri2_dpy->driver_configs, disp);
1067       } else {
1068          dri2_dpy->dri_screen =
1069             dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd,
1070                                             dri2_dpy->loader_extensions,
1071                                             &dri2_dpy->driver_configs, disp);
1072       }
1073    } else {
1074       assert(dri2_dpy->swrast);
1075       if (dri2_dpy->swrast->base.version >= 4) {
1076          dri2_dpy->dri_screen =
1077             dri2_dpy->swrast->createNewScreen2(0, dri2_dpy->loader_extensions,
1078                                                dri2_dpy->driver_extensions,
1079                                                &dri2_dpy->driver_configs, disp);
1080       } else {
1081          dri2_dpy->dri_screen =
1082             dri2_dpy->swrast->createNewScreen(0, dri2_dpy->loader_extensions,
1083                                               &dri2_dpy->driver_configs, disp);
1084       }
1085    }
1086
1087    if (dri2_dpy->dri_screen == NULL) {
1088       _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
1089       return EGL_FALSE;
1090    }
1091
1092    dri2_dpy->own_dri_screen = true;
1093    return EGL_TRUE;
1094 }
1095
1096 EGLBoolean
1097 dri2_setup_extensions(_EGLDisplay *disp)
1098 {
1099    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1100    const struct dri2_extension_match *mandatory_core_extensions;
1101    const __DRIextension **extensions;
1102
1103    extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
1104
1105    if (dri2_dpy->image_driver || dri2_dpy->dri2)
1106       mandatory_core_extensions = dri2_core_extensions;
1107    else
1108       mandatory_core_extensions = swrast_core_extensions;
1109
1110    if (!dri2_bind_extensions(dri2_dpy, mandatory_core_extensions, extensions, false))
1111       return EGL_FALSE;
1112
1113 #ifdef HAVE_DRI3_MODIFIERS
1114    dri2_dpy->multibuffers_available =
1115       (dri2_dpy->dri3_major_version > 1 || (dri2_dpy->dri3_major_version == 1 &&
1116                                             dri2_dpy->dri3_minor_version >= 2)) &&
1117       (dri2_dpy->present_major_version > 1 || (dri2_dpy->present_major_version == 1 &&
1118                                                dri2_dpy->present_minor_version >= 2)) &&
1119       (dri2_dpy->image && dri2_dpy->image->base.version >= 15);
1120 #endif
1121
1122    dri2_bind_extensions(dri2_dpy, optional_core_extensions, extensions, true);
1123    return EGL_TRUE;
1124 }
1125
1126 /**
1127  * Called via eglInitialize(), drv->Initialize().
1128  *
1129  * This must be guaranteed to be called exactly once, even if eglInitialize is
1130  * called many times (without a eglTerminate in between).
1131  */
1132 static EGLBoolean
1133 dri2_initialize(_EGLDisplay *disp)
1134 {
1135    EGLBoolean ret = EGL_FALSE;
1136    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1137
1138    /* In the case where the application calls eglMakeCurrent(context1),
1139     * eglTerminate, then eglInitialize again (without a call to eglReleaseThread
1140     * or eglMakeCurrent(NULL) before that), dri2_dpy structure is still
1141     * initialized, as we need it to be able to free context1 correctly.
1142     *
1143     * It would probably be safest to forcibly release the display with
1144     * dri2_display_release, to make sure the display is reinitialized correctly.
1145     * However, the EGL spec states that we need to keep a reference to the
1146     * current context (so we cannot call dri2_make_current(NULL)), and therefore
1147     * we would leak context1 as we would be missing the old display connection
1148     * to free it up correctly.
1149     */
1150    if (dri2_dpy) {
1151       dri2_dpy->ref_count++;
1152       return EGL_TRUE;
1153    }
1154
1155    loader_set_logger(_eglLog);
1156
1157    switch (disp->Platform) {
1158    case _EGL_PLATFORM_SURFACELESS:
1159       ret = dri2_initialize_surfaceless(disp);
1160       break;
1161    case _EGL_PLATFORM_DEVICE:
1162       ret = dri2_initialize_device(disp);
1163       break;
1164    case _EGL_PLATFORM_X11:
1165    case _EGL_PLATFORM_XCB:
1166       ret = dri2_initialize_x11(disp);
1167       break;
1168    case _EGL_PLATFORM_DRM:
1169       ret = dri2_initialize_drm(disp);
1170       break;
1171    case _EGL_PLATFORM_WAYLAND:
1172       ret = dri2_initialize_wayland(disp);
1173       break;
1174    case _EGL_PLATFORM_ANDROID:
1175       ret = dri2_initialize_android(disp);
1176       break;
1177    default:
1178       unreachable("Callers ensure we cannot get here.");
1179       return EGL_FALSE;
1180    }
1181
1182    if (!ret)
1183       return EGL_FALSE;
1184
1185    dri2_dpy = dri2_egl_display(disp);
1186    dri2_dpy->ref_count++;
1187
1188    return EGL_TRUE;
1189 }
1190
1191 /**
1192  * Decrement display reference count, and free up display if necessary.
1193  */
1194 static void
1195 dri2_display_release(_EGLDisplay *disp)
1196 {
1197    struct dri2_egl_display *dri2_dpy;
1198
1199    if (!disp)
1200       return;
1201
1202    dri2_dpy = dri2_egl_display(disp);
1203
1204    assert(dri2_dpy->ref_count > 0);
1205    dri2_dpy->ref_count--;
1206
1207    if (dri2_dpy->ref_count > 0)
1208       return;
1209
1210    _eglCleanupDisplay(disp);
1211    dri2_display_destroy(disp);
1212 }
1213
1214 void
1215 dri2_display_destroy(_EGLDisplay *disp)
1216 {
1217    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1218
1219    if (dri2_dpy->own_dri_screen) {
1220       if (dri2_dpy->vtbl && dri2_dpy->vtbl->close_screen_notify)
1221          dri2_dpy->vtbl->close_screen_notify(disp);
1222       dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1223    }
1224    if (dri2_dpy->fd >= 0)
1225       close(dri2_dpy->fd);
1226
1227    /* Don't dlclose the driver when building with the address sanitizer, so you
1228     * get good symbols from the leak reports.
1229     */
1230 #if !BUILT_WITH_ASAN || defined(NDEBUG)
1231    if (dri2_dpy->driver)
1232       dlclose(dri2_dpy->driver);
1233 #endif
1234
1235    free(dri2_dpy->driver_name);
1236
1237 #ifdef HAVE_WAYLAND_PLATFORM
1238    free(dri2_dpy->device_name);
1239 #endif
1240
1241    switch (disp->Platform) {
1242    case _EGL_PLATFORM_X11:
1243       dri2_teardown_x11(dri2_dpy);
1244       break;
1245    case _EGL_PLATFORM_DRM:
1246       dri2_teardown_drm(dri2_dpy);
1247       break;
1248    case _EGL_PLATFORM_WAYLAND:
1249       dri2_teardown_wayland(dri2_dpy);
1250       break;
1251    default:
1252       /* TODO: add teardown for other platforms */
1253       break;
1254    }
1255
1256    /* The drm platform does not create the screen/driver_configs but reuses
1257     * the ones from the gbm device. As such the gbm itself is responsible
1258     * for the cleanup.
1259     */
1260    if (disp->Platform != _EGL_PLATFORM_DRM && dri2_dpy->driver_configs) {
1261       for (unsigned i = 0; dri2_dpy->driver_configs[i]; i++)
1262          free((__DRIconfig *) dri2_dpy->driver_configs[i]);
1263       free(dri2_dpy->driver_configs);
1264    }
1265    free(dri2_dpy);
1266    disp->DriverData = NULL;
1267 }
1268
1269 __DRIbuffer *
1270 dri2_egl_surface_alloc_local_buffer(struct dri2_egl_surface *dri2_surf,
1271                                     unsigned int att, unsigned int format)
1272 {
1273    struct dri2_egl_display *dri2_dpy =
1274       dri2_egl_display(dri2_surf->base.Resource.Display);
1275
1276    if (att >= ARRAY_SIZE(dri2_surf->local_buffers))
1277       return NULL;
1278
1279    if (!dri2_surf->local_buffers[att]) {
1280       dri2_surf->local_buffers[att] =
1281          dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen, att, format,
1282                                         dri2_surf->base.Width, dri2_surf->base.Height);
1283    }
1284
1285    return dri2_surf->local_buffers[att];
1286 }
1287
1288 void
1289 dri2_egl_surface_free_local_buffers(struct dri2_egl_surface *dri2_surf)
1290 {
1291    struct dri2_egl_display *dri2_dpy =
1292       dri2_egl_display(dri2_surf->base.Resource.Display);
1293
1294    for (int i = 0; i < ARRAY_SIZE(dri2_surf->local_buffers); i++) {
1295       if (dri2_surf->local_buffers[i]) {
1296          dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
1297                                        dri2_surf->local_buffers[i]);
1298          dri2_surf->local_buffers[i] = NULL;
1299       }
1300    }
1301 }
1302
1303 /**
1304  * Called via eglTerminate(), drv->Terminate().
1305  *
1306  * This must be guaranteed to be called exactly once, even if eglTerminate is
1307  * called many times (without a eglInitialize in between).
1308  */
1309 static EGLBoolean
1310 dri2_terminate(_EGLDisplay *disp)
1311 {
1312    /* Release all non-current Context/Surfaces. */
1313    _eglReleaseDisplayResources(disp);
1314
1315    dri2_display_release(disp);
1316
1317    return EGL_TRUE;
1318 }
1319
1320 /**
1321  * Set the error code after a call to
1322  * dri2_egl_display::dri2::createContextAttribs.
1323  */
1324 static void
1325 dri2_create_context_attribs_error(int dri_error)
1326 {
1327    EGLint egl_error;
1328
1329    switch (dri_error) {
1330    case __DRI_CTX_ERROR_SUCCESS:
1331       return;
1332
1333    case __DRI_CTX_ERROR_NO_MEMORY:
1334       egl_error = EGL_BAD_ALLOC;
1335       break;
1336
1337   /* From the EGL_KHR_create_context spec, section "Errors":
1338    *
1339    *   * If <config> does not support a client API context compatible
1340    *     with the requested API major and minor version, [...] context flags,
1341    *     and context reset notification behavior (for client API types where
1342    *     these attributes are supported), then an EGL_BAD_MATCH error is
1343    *     generated.
1344    *
1345    *   * If an OpenGL ES context is requested and the values for
1346    *     attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
1347    *     EGL_CONTEXT_MINOR_VERSION_KHR specify an OpenGL ES version that
1348    *     is not defined, than an EGL_BAD_MATCH error is generated.
1349    *
1350    *   * If an OpenGL context is requested, the requested version is
1351    *     greater than 3.2, and the value for attribute
1352    *     EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR has no bits set; has any
1353    *     bits set other than EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR and
1354    *     EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR; has more than
1355    *     one of these bits set; or if the implementation does not support
1356    *     the requested profile, then an EGL_BAD_MATCH error is generated.
1357    */
1358    case __DRI_CTX_ERROR_BAD_API:
1359    case __DRI_CTX_ERROR_BAD_VERSION:
1360    case __DRI_CTX_ERROR_BAD_FLAG:
1361       egl_error = EGL_BAD_MATCH;
1362       break;
1363
1364   /* From the EGL_KHR_create_context spec, section "Errors":
1365    *
1366    *   * If an attribute name or attribute value in <attrib_list> is not
1367    *     recognized (including unrecognized bits in bitmask attributes),
1368    *     then an EGL_BAD_ATTRIBUTE error is generated."
1369    */
1370    case __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE:
1371    case __DRI_CTX_ERROR_UNKNOWN_FLAG:
1372       egl_error = EGL_BAD_ATTRIBUTE;
1373       break;
1374
1375    default:
1376       assert(!"unknown dri_error code");
1377       egl_error = EGL_BAD_MATCH;
1378       break;
1379    }
1380
1381    _eglError(egl_error, "dri2_create_context");
1382 }
1383
1384 static bool
1385 dri2_fill_context_attribs(struct dri2_egl_context *dri2_ctx,
1386                           struct dri2_egl_display *dri2_dpy,
1387                           uint32_t *ctx_attribs,
1388                           unsigned *num_attribs)
1389 {
1390    int pos = 0;
1391
1392    assert(*num_attribs >= NUM_ATTRIBS);
1393
1394    ctx_attribs[pos++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
1395    ctx_attribs[pos++] = dri2_ctx->base.ClientMajorVersion;
1396    ctx_attribs[pos++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
1397    ctx_attribs[pos++] = dri2_ctx->base.ClientMinorVersion;
1398
1399    if (dri2_ctx->base.Flags != 0 || dri2_ctx->base.NoError) {
1400       /* If the implementation doesn't support the __DRI2_ROBUSTNESS
1401        * extension, don't even try to send it the robust-access flag.
1402        * It may explode.  Instead, generate the required EGL error here.
1403        */
1404       if ((dri2_ctx->base.Flags & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) != 0
1405             && !dri2_dpy->robustness) {
1406          _eglError(EGL_BAD_MATCH, "eglCreateContext");
1407          return false;
1408       }
1409
1410       ctx_attribs[pos++] = __DRI_CTX_ATTRIB_FLAGS;
1411       ctx_attribs[pos++] = dri2_ctx->base.Flags |
1412          (dri2_ctx->base.NoError ? __DRI_CTX_FLAG_NO_ERROR : 0);
1413    }
1414
1415    if (dri2_ctx->base.ResetNotificationStrategy != EGL_NO_RESET_NOTIFICATION_KHR) {
1416       /* If the implementation doesn't support the __DRI2_ROBUSTNESS
1417        * extension, don't even try to send it a reset strategy.  It may
1418        * explode.  Instead, generate the required EGL error here.
1419        */
1420       if (!dri2_dpy->robustness) {
1421          _eglError(EGL_BAD_CONFIG, "eglCreateContext");
1422          return false;
1423       }
1424
1425       ctx_attribs[pos++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
1426       ctx_attribs[pos++] = __DRI_CTX_RESET_LOSE_CONTEXT;
1427    }
1428
1429    if (dri2_ctx->base.ContextPriority != EGL_CONTEXT_PRIORITY_MEDIUM_IMG) {
1430       unsigned val;
1431
1432       switch (dri2_ctx->base.ContextPriority) {
1433       case EGL_CONTEXT_PRIORITY_HIGH_IMG:
1434          val = __DRI_CTX_PRIORITY_HIGH;
1435          break;
1436       case EGL_CONTEXT_PRIORITY_MEDIUM_IMG:
1437          val = __DRI_CTX_PRIORITY_MEDIUM;
1438          break;
1439       case EGL_CONTEXT_PRIORITY_LOW_IMG:
1440          val = __DRI_CTX_PRIORITY_LOW;
1441          break;
1442       default:
1443          _eglError(EGL_BAD_CONFIG, "eglCreateContext");
1444          return false;
1445       }
1446
1447       ctx_attribs[pos++] = __DRI_CTX_ATTRIB_PRIORITY;
1448       ctx_attribs[pos++] = val;
1449    }
1450
1451    if (dri2_ctx->base.ReleaseBehavior == EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR) {
1452       ctx_attribs[pos++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR;
1453       ctx_attribs[pos++] = __DRI_CTX_RELEASE_BEHAVIOR_NONE;
1454    }
1455
1456    *num_attribs = pos;
1457
1458    return true;
1459 }
1460
1461 /**
1462  * Called via eglCreateContext(), drv->CreateContext().
1463  */
1464 static _EGLContext *
1465 dri2_create_context(_EGLDisplay *disp, _EGLConfig *conf,
1466                     _EGLContext *share_list, const EGLint *attrib_list)
1467 {
1468    struct dri2_egl_context *dri2_ctx;
1469    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1470    struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
1471    __DRIcontext *shared =
1472       dri2_ctx_shared ? dri2_ctx_shared->dri_context : NULL;
1473    struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
1474    const __DRIconfig *dri_config;
1475    int api;
1476    unsigned error;
1477    unsigned num_attribs = NUM_ATTRIBS;
1478    uint32_t ctx_attribs[NUM_ATTRIBS];
1479
1480    dri2_ctx = malloc(sizeof *dri2_ctx);
1481    if (!dri2_ctx) {
1482       _eglError(EGL_BAD_ALLOC, "eglCreateContext");
1483       return NULL;
1484    }
1485
1486    if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
1487       goto cleanup;
1488
1489    /* The EGL_EXT_create_context_robustness spec says:
1490     *
1491     *    "Add to the eglCreateContext context creation errors: [...]
1492     *
1493     *     * If the reset notification behavior of <share_context> and the
1494     *       newly created context are different then an EGL_BAD_MATCH error is
1495     *       generated."
1496     */
1497    if (share_list && share_list->ResetNotificationStrategy !=
1498                      dri2_ctx->base.ResetNotificationStrategy) {
1499       _eglError(EGL_BAD_MATCH, "eglCreateContext");
1500       goto cleanup;
1501    }
1502
1503    /* The EGL_KHR_create_context_no_error spec says:
1504     *
1505     *    "BAD_MATCH is generated if the value of EGL_CONTEXT_OPENGL_NO_ERROR_KHR
1506     *    used to create <share_context> does not match the value of
1507     *    EGL_CONTEXT_OPENGL_NO_ERROR_KHR for the context being created."
1508     */
1509    if (share_list && share_list->NoError != dri2_ctx->base.NoError) {
1510       _eglError(EGL_BAD_MATCH, "eglCreateContext");
1511       goto cleanup;
1512    }
1513
1514    switch (dri2_ctx->base.ClientAPI) {
1515    case EGL_OPENGL_ES_API:
1516       switch (dri2_ctx->base.ClientMajorVersion) {
1517       case 1:
1518          api = __DRI_API_GLES;
1519          break;
1520       case 2:
1521          api = __DRI_API_GLES2;
1522          break;
1523       case 3:
1524          api = __DRI_API_GLES3;
1525          break;
1526       default:
1527          _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1528          free(dri2_ctx);
1529          return NULL;
1530       }
1531       break;
1532    case EGL_OPENGL_API:
1533       if ((dri2_ctx->base.ClientMajorVersion >= 4
1534            || (dri2_ctx->base.ClientMajorVersion == 3
1535                && dri2_ctx->base.ClientMinorVersion >= 2))
1536           && dri2_ctx->base.Profile == EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR)
1537          api = __DRI_API_OPENGL_CORE;
1538       else if (dri2_ctx->base.ClientMajorVersion == 3 &&
1539                dri2_ctx->base.ClientMinorVersion == 1)
1540          api = __DRI_API_OPENGL_CORE;
1541       else
1542          api = __DRI_API_OPENGL;
1543       break;
1544    default:
1545       _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1546       free(dri2_ctx);
1547       return NULL;
1548    }
1549
1550    if (conf != NULL) {
1551       /* The config chosen here isn't necessarily
1552        * used for surfaces later.
1553        * A pixmap surface will use the single config.
1554        * This opportunity depends on disabling the
1555        * doubleBufferMode check in
1556        * src/mesa/main/context.c:check_compatible()
1557        */
1558       if (dri2_config->dri_config[1][0])
1559          dri_config = dri2_config->dri_config[1][0];
1560       else
1561          dri_config = dri2_config->dri_config[0][0];
1562    }
1563    else
1564       dri_config = NULL;
1565
1566    if (!dri2_fill_context_attribs(dri2_ctx, dri2_dpy, ctx_attribs,
1567                                   &num_attribs))
1568       goto cleanup;
1569
1570    if (dri2_dpy->image_driver) {
1571       dri2_ctx->dri_context =
1572          dri2_dpy->image_driver->createContextAttribs(dri2_dpy->dri_screen,
1573                                                       api,
1574                                                       dri_config,
1575                                                       shared,
1576                                                       num_attribs / 2,
1577                                                       ctx_attribs,
1578                                                       & error,
1579                                                       dri2_ctx);
1580       dri2_create_context_attribs_error(error);
1581    } else if (dri2_dpy->dri2) {
1582       if (dri2_dpy->dri2->base.version >= 3) {
1583          dri2_ctx->dri_context =
1584             dri2_dpy->dri2->createContextAttribs(dri2_dpy->dri_screen,
1585                                                  api,
1586                                                  dri_config,
1587                                                  shared,
1588                                                  num_attribs / 2,
1589                                                  ctx_attribs,
1590                                                  & error,
1591                                                  dri2_ctx);
1592          dri2_create_context_attribs_error(error);
1593       } else {
1594          dri2_ctx->dri_context =
1595             dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
1596                                                    api,
1597                                                    dri_config,
1598                                                    shared,
1599                                                    dri2_ctx);
1600       }
1601    } else {
1602       assert(dri2_dpy->swrast);
1603       if (dri2_dpy->swrast->base.version >= 3) {
1604          dri2_ctx->dri_context =
1605             dri2_dpy->swrast->createContextAttribs(dri2_dpy->dri_screen,
1606                                                    api,
1607                                                    dri_config,
1608                                                    shared,
1609                                                    num_attribs / 2,
1610                                                    ctx_attribs,
1611                                                    & error,
1612                                                    dri2_ctx);
1613          dri2_create_context_attribs_error(error);
1614       } else {
1615          dri2_ctx->dri_context =
1616             dri2_dpy->swrast->createNewContextForAPI(dri2_dpy->dri_screen,
1617                                                      api,
1618                                                      dri_config,
1619                                                      shared,
1620                                                      dri2_ctx);
1621       }
1622    }
1623
1624    if (!dri2_ctx->dri_context)
1625       goto cleanup;
1626
1627    return &dri2_ctx->base;
1628
1629  cleanup:
1630    free(dri2_ctx);
1631    return NULL;
1632 }
1633
1634 /**
1635  * Called via eglDestroyContext(), drv->DestroyContext().
1636  */
1637 static EGLBoolean
1638 dri2_destroy_context(_EGLDisplay *disp, _EGLContext *ctx)
1639 {
1640    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1641    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1642
1643    if (_eglPutContext(ctx)) {
1644       dri2_dpy->core->destroyContext(dri2_ctx->dri_context);
1645       free(dri2_ctx);
1646    }
1647
1648    return EGL_TRUE;
1649 }
1650
1651 EGLBoolean
1652 dri2_init_surface(_EGLSurface *surf, _EGLDisplay *disp, EGLint type,
1653         _EGLConfig *conf, const EGLint *attrib_list,
1654         EGLBoolean enable_out_fence, void *native_surface)
1655 {
1656    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1657    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1658
1659    dri2_surf->out_fence_fd = -1;
1660    dri2_surf->enable_out_fence = false;
1661    if (dri2_dpy->fence && dri2_dpy->fence->base.version >= 2 &&
1662        dri2_dpy->fence->get_capabilities &&
1663        (dri2_dpy->fence->get_capabilities(dri2_dpy->dri_screen) &
1664         __DRI_FENCE_CAP_NATIVE_FD)) {
1665       dri2_surf->enable_out_fence = enable_out_fence;
1666    }
1667
1668    return _eglInitSurface(surf, disp, type, conf, attrib_list, native_surface);
1669 }
1670
1671 static void
1672 dri2_surface_set_out_fence_fd( _EGLSurface *surf, int fence_fd)
1673 {
1674    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1675
1676    if (dri2_surf->out_fence_fd >= 0)
1677       close(dri2_surf->out_fence_fd);
1678
1679    dri2_surf->out_fence_fd = fence_fd;
1680 }
1681
1682 void
1683 dri2_fini_surface(_EGLSurface *surf)
1684 {
1685    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1686
1687    dri2_surface_set_out_fence_fd(surf, -1);
1688    dri2_surf->enable_out_fence = false;
1689 }
1690
1691 static EGLBoolean
1692 dri2_destroy_surface(_EGLDisplay *disp, _EGLSurface *surf)
1693 {
1694    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1695
1696    if (!_eglPutSurface(surf))
1697       return EGL_TRUE;
1698
1699    return dri2_dpy->vtbl->destroy_surface(disp, surf);
1700 }
1701
1702 static void
1703 dri2_surf_update_fence_fd(_EGLContext *ctx,
1704                           _EGLDisplay *disp, _EGLSurface *surf)
1705 {
1706    __DRIcontext *dri_ctx = dri2_egl_context(ctx)->dri_context;
1707    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1708    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1709    int fence_fd = -1;
1710    void *fence;
1711
1712    if (!dri2_surf->enable_out_fence)
1713       return;
1714
1715    fence = dri2_dpy->fence->create_fence_fd(dri_ctx, -1);
1716    if (fence) {
1717       fence_fd = dri2_dpy->fence->get_fence_fd(dri2_dpy->dri_screen,
1718                                                fence);
1719       dri2_dpy->fence->destroy_fence(dri2_dpy->dri_screen, fence);
1720    }
1721    dri2_surface_set_out_fence_fd(surf, fence_fd);
1722 }
1723
1724 EGLBoolean
1725 dri2_create_drawable(struct dri2_egl_display *dri2_dpy,
1726                      const __DRIconfig *config,
1727                      struct dri2_egl_surface *dri2_surf,
1728                      void *loaderPrivate)
1729 {
1730    __DRIcreateNewDrawableFunc createNewDrawable;
1731
1732    if (dri2_dpy->image_driver)
1733       createNewDrawable = dri2_dpy->image_driver->createNewDrawable;
1734    else if (dri2_dpy->dri2)
1735       createNewDrawable = dri2_dpy->dri2->createNewDrawable;
1736    else if (dri2_dpy->swrast)
1737       createNewDrawable = dri2_dpy->swrast->createNewDrawable;
1738    else
1739       return _eglError(EGL_BAD_ALLOC, "no createNewDrawable");
1740
1741    dri2_surf->dri_drawable = createNewDrawable(dri2_dpy->dri_screen,
1742                                                config, loaderPrivate);
1743    if (dri2_surf->dri_drawable == NULL)
1744       return _eglError(EGL_BAD_ALLOC, "createNewDrawable");
1745
1746    return EGL_TRUE;
1747 }
1748
1749 /**
1750  * Called via eglMakeCurrent(), drv->MakeCurrent().
1751  */
1752 static EGLBoolean
1753 dri2_make_current(_EGLDisplay *disp, _EGLSurface *dsurf,
1754                   _EGLSurface *rsurf, _EGLContext *ctx)
1755 {
1756    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1757    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1758    _EGLDisplay *old_disp = NULL;
1759    struct dri2_egl_display *old_dri2_dpy = NULL;
1760    _EGLContext *old_ctx;
1761    _EGLSurface *old_dsurf, *old_rsurf;
1762    _EGLSurface *tmp_dsurf, *tmp_rsurf;
1763    __DRIdrawable *ddraw, *rdraw;
1764    __DRIcontext *cctx;
1765    EGLint egl_error = EGL_SUCCESS;
1766
1767    if (!dri2_dpy)
1768       return _eglError(EGL_NOT_INITIALIZED, "eglMakeCurrent");
1769
1770    /* make new bindings, set the EGL error otherwise */
1771    if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
1772       return EGL_FALSE;
1773
1774    if (old_ctx) {
1775       __DRIcontext *old_cctx = dri2_egl_context(old_ctx)->dri_context;
1776       old_disp = old_ctx->Resource.Display;
1777       old_dri2_dpy = dri2_egl_display(old_disp);
1778
1779       /* flush before context switch */
1780       dri2_gl_flush();
1781
1782       if (old_dsurf)
1783          dri2_surf_update_fence_fd(old_ctx, disp, old_dsurf);
1784
1785       /* Disable shared buffer mode */
1786       if (old_dsurf && _eglSurfaceInSharedBufferMode(old_dsurf) &&
1787           old_dri2_dpy->vtbl->set_shared_buffer_mode) {
1788          old_dri2_dpy->vtbl->set_shared_buffer_mode(old_disp, old_dsurf, false);
1789       }
1790
1791       dri2_dpy->core->unbindContext(old_cctx);
1792    }
1793
1794    ddraw = (dsurf) ? dri2_dpy->vtbl->get_dri_drawable(dsurf) : NULL;
1795    rdraw = (rsurf) ? dri2_dpy->vtbl->get_dri_drawable(rsurf) : NULL;
1796    cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
1797
1798    if (cctx || ddraw || rdraw) {
1799       if (!dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
1800          _EGLContext *tmp_ctx;
1801
1802          /* dri2_dpy->core->bindContext failed. We cannot tell for sure why, but
1803           * setting the error to EGL_BAD_MATCH is surely better than leaving it
1804           * as EGL_SUCCESS.
1805           */
1806          egl_error = EGL_BAD_MATCH;
1807
1808          /* undo the previous _eglBindContext */
1809          _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &tmp_dsurf, &tmp_rsurf);
1810          assert(&dri2_ctx->base == ctx &&
1811                 tmp_dsurf == dsurf &&
1812                 tmp_rsurf == rsurf);
1813
1814          _eglPutSurface(dsurf);
1815          _eglPutSurface(rsurf);
1816          _eglPutContext(ctx);
1817
1818          _eglPutSurface(old_dsurf);
1819          _eglPutSurface(old_rsurf);
1820          _eglPutContext(old_ctx);
1821
1822          ddraw = (old_dsurf) ? dri2_dpy->vtbl->get_dri_drawable(old_dsurf) : NULL;
1823          rdraw = (old_rsurf) ? dri2_dpy->vtbl->get_dri_drawable(old_rsurf) : NULL;
1824          cctx = (old_ctx) ? dri2_egl_context(old_ctx)->dri_context : NULL;
1825
1826          /* undo the previous dri2_dpy->core->unbindContext */
1827          if (dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
1828             if (old_dsurf && _eglSurfaceInSharedBufferMode(old_dsurf) &&
1829                 old_dri2_dpy->vtbl->set_shared_buffer_mode) {
1830                old_dri2_dpy->vtbl->set_shared_buffer_mode(old_disp, old_dsurf, true);
1831             }
1832
1833             return _eglError(egl_error, "eglMakeCurrent");
1834          }
1835
1836          /* We cannot restore the same state as it was before calling
1837           * eglMakeCurrent() and the spec isn't clear about what to do. We
1838           * can prevent EGL from calling into the DRI driver with no DRI
1839           * context bound.
1840           */
1841          dsurf = rsurf = NULL;
1842          ctx = NULL;
1843
1844          _eglBindContext(ctx, dsurf, rsurf, &tmp_ctx, &tmp_dsurf, &tmp_rsurf);
1845          assert(tmp_ctx == old_ctx && tmp_dsurf == old_dsurf &&
1846                 tmp_rsurf == old_rsurf);
1847
1848          _eglLog(_EGL_WARNING, "DRI2: failed to rebind the previous context");
1849       } else {
1850          /* dri2_dpy->core->bindContext succeeded, so take a reference on the
1851           * dri2_dpy. This prevents dri2_dpy from being reinitialized when a
1852           * EGLDisplay is terminated and then initialized again while a
1853           * context is still bound. See dri2_intitialize() for a more in depth
1854           * explanation. */
1855          dri2_dpy->ref_count++;
1856       }
1857    }
1858
1859    dri2_destroy_surface(disp, old_dsurf);
1860    dri2_destroy_surface(disp, old_rsurf);
1861
1862    if (old_ctx) {
1863       dri2_destroy_context(disp, old_ctx);
1864       dri2_display_release(old_disp);
1865    }
1866
1867    if (egl_error != EGL_SUCCESS)
1868       return _eglError(egl_error, "eglMakeCurrent");
1869
1870    if (dsurf && _eglSurfaceHasMutableRenderBuffer(dsurf) &&
1871        dri2_dpy->vtbl->set_shared_buffer_mode) {
1872       /* Always update the shared buffer mode. This is obviously needed when
1873        * the active EGL_RENDER_BUFFER is EGL_SINGLE_BUFFER. When
1874        * EGL_RENDER_BUFFER is EGL_BACK_BUFFER, the update protects us in the
1875        * case where external non-EGL API may have changed window's shared
1876        * buffer mode since we last saw it.
1877        */
1878       bool mode = (dsurf->ActiveRenderBuffer == EGL_SINGLE_BUFFER);
1879       dri2_dpy->vtbl->set_shared_buffer_mode(disp, dsurf, mode);
1880    }
1881
1882    return EGL_TRUE;
1883 }
1884
1885 __DRIdrawable *
1886 dri2_surface_get_dri_drawable(_EGLSurface *surf)
1887 {
1888    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1889
1890    return dri2_surf->dri_drawable;
1891 }
1892
1893 /*
1894  * Called from eglGetProcAddress() via drv->GetProcAddress().
1895  */
1896 static _EGLProc
1897 dri2_get_proc_address(const char *procname)
1898 {
1899    return _glapi_get_proc_address(procname);
1900 }
1901
1902 static _EGLSurface*
1903 dri2_create_window_surface(_EGLDisplay *disp, _EGLConfig *conf,
1904                            void *native_window, const EGLint *attrib_list)
1905 {
1906    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1907    return dri2_dpy->vtbl->create_window_surface(disp, conf, native_window,
1908                                                 attrib_list);
1909 }
1910
1911 static _EGLSurface*
1912 dri2_create_pixmap_surface(_EGLDisplay *disp, _EGLConfig *conf,
1913                            void *native_pixmap, const EGLint *attrib_list)
1914 {
1915    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1916    if (!dri2_dpy->vtbl->create_pixmap_surface)
1917       return NULL;
1918    return dri2_dpy->vtbl->create_pixmap_surface(disp, conf, native_pixmap,
1919                                                 attrib_list);
1920 }
1921
1922 static _EGLSurface*
1923 dri2_create_pbuffer_surface(_EGLDisplay *disp, _EGLConfig *conf,
1924                             const EGLint *attrib_list)
1925 {
1926    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1927    if (!dri2_dpy->vtbl->create_pbuffer_surface)
1928       return NULL;
1929    return dri2_dpy->vtbl->create_pbuffer_surface(disp, conf, attrib_list);
1930 }
1931
1932 static EGLBoolean
1933 dri2_swap_interval(_EGLDisplay *disp, _EGLSurface *surf, EGLint interval)
1934 {
1935    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1936    if (!dri2_dpy->vtbl->swap_interval)
1937       return EGL_TRUE;
1938    return dri2_dpy->vtbl->swap_interval(disp, surf, interval);
1939 }
1940
1941 /**
1942  * Asks the client API to flush any rendering to the drawable so that we can
1943  * do our swapbuffers.
1944  */
1945 void
1946 dri2_flush_drawable_for_swapbuffers(_EGLDisplay *disp, _EGLSurface *draw)
1947 {
1948    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1949    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(draw);
1950
1951    if (dri2_dpy->flush) {
1952       if (dri2_dpy->flush->base.version >= 4) {
1953          /* We know there's a current context because:
1954           *
1955           *     "If surface is not bound to the calling thread’s current
1956           *      context, an EGL_BAD_SURFACE error is generated."
1957          */
1958          _EGLContext *ctx = _eglGetCurrentContext();
1959          struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1960
1961          /* From the EGL 1.4 spec (page 52):
1962           *
1963           *     "The contents of ancillary buffers are always undefined
1964           *      after calling eglSwapBuffers."
1965           */
1966          dri2_dpy->flush->flush_with_flags(dri2_ctx->dri_context,
1967                                            dri_drawable,
1968                                            __DRI2_FLUSH_DRAWABLE |
1969                                            __DRI2_FLUSH_INVALIDATE_ANCILLARY,
1970                                            __DRI2_THROTTLE_SWAPBUFFER);
1971       } else {
1972          dri2_dpy->flush->flush(dri_drawable);
1973       }
1974    }
1975 }
1976
1977 static EGLBoolean
1978 dri2_swap_buffers(_EGLDisplay *disp, _EGLSurface *surf)
1979 {
1980    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1981    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
1982    _EGLContext *ctx = _eglGetCurrentContext();
1983    EGLBoolean ret;
1984
1985    if (ctx && surf)
1986       dri2_surf_update_fence_fd(ctx, disp, surf);
1987    ret = dri2_dpy->vtbl->swap_buffers(disp, surf);
1988
1989    /* SwapBuffers marks the end of the frame; reset the damage region for
1990     * use again next time.
1991     */
1992    if (ret && dri2_dpy->buffer_damage &&
1993        dri2_dpy->buffer_damage->set_damage_region)
1994       dri2_dpy->buffer_damage->set_damage_region(dri_drawable, 0, NULL);
1995
1996    return ret;
1997 }
1998
1999 static EGLBoolean
2000 dri2_swap_buffers_with_damage(_EGLDisplay *disp, _EGLSurface *surf,
2001                               const EGLint *rects, EGLint n_rects)
2002 {
2003    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2004    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
2005    _EGLContext *ctx = _eglGetCurrentContext();
2006    EGLBoolean ret;
2007
2008    if (ctx && surf)
2009       dri2_surf_update_fence_fd(ctx, disp, surf);
2010    if (dri2_dpy->vtbl->swap_buffers_with_damage)
2011       ret = dri2_dpy->vtbl->swap_buffers_with_damage(disp, surf,
2012                                                      rects, n_rects);
2013    else
2014       ret = dri2_dpy->vtbl->swap_buffers(disp, surf);
2015
2016    /* SwapBuffers marks the end of the frame; reset the damage region for
2017     * use again next time.
2018     */
2019    if (ret && dri2_dpy->buffer_damage &&
2020        dri2_dpy->buffer_damage->set_damage_region)
2021       dri2_dpy->buffer_damage->set_damage_region(dri_drawable, 0, NULL);
2022
2023    return ret;
2024 }
2025
2026 static EGLBoolean
2027 dri2_swap_buffers_region(_EGLDisplay *disp, _EGLSurface *surf,
2028                          EGLint numRects, const EGLint *rects)
2029 {
2030    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2031    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
2032    EGLBoolean ret;
2033
2034    if (!dri2_dpy->vtbl->swap_buffers_region)
2035       return EGL_FALSE;
2036    ret = dri2_dpy->vtbl->swap_buffers_region(disp, surf, numRects, rects);
2037
2038    /* SwapBuffers marks the end of the frame; reset the damage region for
2039     * use again next time.
2040     */
2041    if (ret && dri2_dpy->buffer_damage &&
2042        dri2_dpy->buffer_damage->set_damage_region)
2043       dri2_dpy->buffer_damage->set_damage_region(dri_drawable, 0, NULL);
2044
2045    return ret;
2046 }
2047
2048 static EGLBoolean
2049 dri2_set_damage_region(_EGLDisplay *disp, _EGLSurface *surf,
2050                        EGLint *rects, EGLint n_rects)
2051 {
2052    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2053    __DRIdrawable *drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
2054
2055    if (!dri2_dpy->buffer_damage || !dri2_dpy->buffer_damage->set_damage_region)
2056       return EGL_FALSE;
2057
2058    dri2_dpy->buffer_damage->set_damage_region(drawable, n_rects, rects);
2059    return EGL_TRUE;
2060 }
2061
2062 static EGLBoolean
2063 dri2_post_sub_buffer(_EGLDisplay *disp, _EGLSurface *surf,
2064                      EGLint x, EGLint y, EGLint width, EGLint height)
2065 {
2066    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2067    if (!dri2_dpy->vtbl->post_sub_buffer)
2068       return EGL_FALSE;
2069    return dri2_dpy->vtbl->post_sub_buffer(disp, surf, x, y, width, height);
2070 }
2071
2072 static EGLBoolean
2073 dri2_copy_buffers(_EGLDisplay *disp, _EGLSurface *surf, void *native_pixmap_target)
2074 {
2075    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2076    if (!dri2_dpy->vtbl->copy_buffers)
2077       return _eglError(EGL_BAD_NATIVE_PIXMAP, "no support for native pixmaps");
2078    return dri2_dpy->vtbl->copy_buffers(disp, surf, native_pixmap_target);
2079 }
2080
2081 static EGLint
2082 dri2_query_buffer_age(_EGLDisplay *disp, _EGLSurface *surf)
2083 {
2084    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2085    if (!dri2_dpy->vtbl->query_buffer_age)
2086       return 0;
2087    return dri2_dpy->vtbl->query_buffer_age(disp, surf);
2088 }
2089
2090 static EGLBoolean
2091 dri2_wait_client(_EGLDisplay *disp, _EGLContext *ctx)
2092 {
2093    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2094    _EGLSurface *surf = ctx->DrawSurface;
2095    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
2096
2097    /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
2098     * we need to copy fake to real here.*/
2099
2100    if (dri2_dpy->flush != NULL)
2101       dri2_dpy->flush->flush(dri_drawable);
2102
2103    return EGL_TRUE;
2104 }
2105
2106 static EGLBoolean
2107 dri2_wait_native(EGLint engine)
2108 {
2109    if (engine != EGL_CORE_NATIVE_ENGINE)
2110       return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
2111    /* glXWaitX(); */
2112
2113    return EGL_TRUE;
2114 }
2115
2116 static EGLBoolean
2117 dri2_bind_tex_image(_EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
2118 {
2119    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2120    struct dri2_egl_context *dri2_ctx;
2121    _EGLContext *ctx;
2122    GLint format, target;
2123    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
2124
2125    ctx = _eglGetCurrentContext();
2126    dri2_ctx = dri2_egl_context(ctx);
2127
2128    if (!_eglBindTexImage(disp, surf, buffer))
2129       return EGL_FALSE;
2130
2131    switch (surf->TextureFormat) {
2132    case EGL_TEXTURE_RGB:
2133       format = __DRI_TEXTURE_FORMAT_RGB;
2134       break;
2135    case EGL_TEXTURE_RGBA:
2136       format = __DRI_TEXTURE_FORMAT_RGBA;
2137       break;
2138    default:
2139       assert(!"Unexpected texture format in dri2_bind_tex_image()");
2140       format = __DRI_TEXTURE_FORMAT_RGBA;
2141    }
2142
2143    switch (surf->TextureTarget) {
2144    case EGL_TEXTURE_2D:
2145       target = GL_TEXTURE_2D;
2146       break;
2147    default:
2148       target = GL_TEXTURE_2D;
2149       assert(!"Unexpected texture target in dri2_bind_tex_image()");
2150    }
2151
2152    dri2_dpy->tex_buffer->setTexBuffer2(dri2_ctx->dri_context,
2153                                        target, format,
2154                                        dri_drawable);
2155
2156    return EGL_TRUE;
2157 }
2158
2159 static EGLBoolean
2160 dri2_release_tex_image(_EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
2161 {
2162    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2163    struct dri2_egl_context *dri2_ctx;
2164    _EGLContext *ctx;
2165    GLint  target;
2166    __DRIdrawable *dri_drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
2167
2168    ctx = _eglGetCurrentContext();
2169    dri2_ctx = dri2_egl_context(ctx);
2170
2171    if (!_eglReleaseTexImage(disp, surf, buffer))
2172       return EGL_FALSE;
2173
2174    switch (surf->TextureTarget) {
2175    case EGL_TEXTURE_2D:
2176       target = GL_TEXTURE_2D;
2177       break;
2178    default:
2179       assert(!"missing texture target");
2180    }
2181
2182    if (dri2_dpy->tex_buffer->base.version >= 3 &&
2183        dri2_dpy->tex_buffer->releaseTexBuffer != NULL) {
2184       dri2_dpy->tex_buffer->releaseTexBuffer(dri2_ctx->dri_context,
2185                                              target, dri_drawable);
2186    }
2187
2188    return EGL_TRUE;
2189 }
2190
2191 static _EGLImage*
2192 dri2_create_image(_EGLDisplay *disp, _EGLContext *ctx, EGLenum target,
2193                   EGLClientBuffer buffer, const EGLint *attr_list)
2194 {
2195    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2196    return dri2_dpy->vtbl->create_image(disp, ctx, target, buffer,
2197                                        attr_list);
2198 }
2199
2200 _EGLImage *
2201 dri2_create_image_from_dri(_EGLDisplay *disp, __DRIimage *dri_image)
2202 {
2203    struct dri2_egl_image *dri2_img;
2204
2205    if (dri_image == NULL) {
2206       _eglError(EGL_BAD_ALLOC, "dri2_create_image");
2207       return NULL;
2208    }
2209
2210    dri2_img = malloc(sizeof *dri2_img);
2211    if (!dri2_img) {
2212       _eglError(EGL_BAD_ALLOC, "dri2_create_image");
2213       return NULL;
2214    }
2215
2216    _eglInitImage(&dri2_img->base, disp);
2217
2218    dri2_img->dri_image = dri_image;
2219
2220    return &dri2_img->base;
2221 }
2222
2223 /**
2224  * Translate a DRI Image extension error code into an EGL error code.
2225  */
2226 static EGLint
2227 egl_error_from_dri_image_error(int dri_error)
2228 {
2229    switch (dri_error) {
2230    case __DRI_IMAGE_ERROR_SUCCESS:
2231       return EGL_SUCCESS;
2232    case __DRI_IMAGE_ERROR_BAD_ALLOC:
2233       return EGL_BAD_ALLOC;
2234    case __DRI_IMAGE_ERROR_BAD_MATCH:
2235       return EGL_BAD_MATCH;
2236    case __DRI_IMAGE_ERROR_BAD_PARAMETER:
2237       return EGL_BAD_PARAMETER;
2238    case __DRI_IMAGE_ERROR_BAD_ACCESS:
2239       return EGL_BAD_ACCESS;
2240    default:
2241       assert(!"unknown dri_error code");
2242       return EGL_BAD_ALLOC;
2243    }
2244 }
2245
2246 static _EGLImage *
2247 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
2248                                    EGLClientBuffer buffer,
2249                                    const EGLint *attr_list)
2250 {
2251    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2252    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2253    GLuint renderbuffer = (GLuint) (uintptr_t) buffer;
2254    __DRIimage *dri_image;
2255
2256    if (renderbuffer == 0) {
2257       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2258       return EGL_NO_IMAGE_KHR;
2259    }
2260
2261    if (!disp->Extensions.KHR_gl_renderbuffer_image) {
2262       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2263       return EGL_NO_IMAGE_KHR;
2264    }
2265
2266    if (dri2_dpy->image->base.version >= 17 &&
2267        dri2_dpy->image->createImageFromRenderbuffer2) {
2268       unsigned error = ~0;
2269
2270       dri_image = dri2_dpy->image->createImageFromRenderbuffer2(
2271                dri2_ctx->dri_context, renderbuffer, NULL, &error);
2272
2273       assert(!!dri_image == (error == __DRI_IMAGE_ERROR_SUCCESS));
2274
2275       if (!dri_image) {
2276          _eglError(egl_error_from_dri_image_error(error), "dri2_create_image_khr");
2277          return EGL_NO_IMAGE_KHR;
2278       }
2279    } else {
2280       dri_image = dri2_dpy->image->createImageFromRenderbuffer(
2281                dri2_ctx->dri_context, renderbuffer, NULL);
2282       if (!dri_image) {
2283          _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2284          return EGL_NO_IMAGE_KHR;
2285       }
2286    }
2287
2288    return dri2_create_image_from_dri(disp, dri_image);
2289 }
2290
2291 #ifdef HAVE_WAYLAND_PLATFORM
2292
2293 /* This structure describes how a wl_buffer maps to one or more
2294  * __DRIimages.  A wl_drm_buffer stores the wl_drm format code and the
2295  * offsets and strides of the planes in the buffer.  This table maps a
2296  * wl_drm format code to a description of the planes in the buffer
2297  * that lets us create a __DRIimage for each of the planes. */
2298
2299 static const struct wl_drm_components_descriptor {
2300    uint32_t dri_components;
2301    EGLint components;
2302    int nplanes;
2303 } wl_drm_components[] = {
2304    { __DRI_IMAGE_COMPONENTS_RGB, EGL_TEXTURE_RGB, 1 },
2305    { __DRI_IMAGE_COMPONENTS_RGBA, EGL_TEXTURE_RGBA, 1 },
2306    { __DRI_IMAGE_COMPONENTS_Y_U_V, EGL_TEXTURE_Y_U_V_WL, 3 },
2307    { __DRI_IMAGE_COMPONENTS_Y_UV, EGL_TEXTURE_Y_UV_WL, 2 },
2308    { __DRI_IMAGE_COMPONENTS_Y_XUXV, EGL_TEXTURE_Y_XUXV_WL, 2 },
2309 };
2310
2311 static _EGLImage *
2312 dri2_create_image_wayland_wl_buffer(_EGLDisplay *disp, _EGLContext *ctx,
2313                                     EGLClientBuffer _buffer,
2314                                     const EGLint *attr_list)
2315 {
2316    struct wl_drm_buffer *buffer;
2317    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2318    const struct wl_drm_components_descriptor *f;
2319    __DRIimage *dri_image;
2320    _EGLImageAttribs attrs;
2321    int32_t plane;
2322
2323    buffer = wayland_drm_buffer_get(dri2_dpy->wl_server_drm,
2324                                    (struct wl_resource *) _buffer);
2325    if (!buffer)
2326        return NULL;
2327
2328    if (!_eglParseImageAttribList(&attrs, disp, attr_list))
2329       return NULL;
2330
2331    plane = attrs.PlaneWL;
2332    f = buffer->driver_format;
2333    if (plane < 0 || plane >= f->nplanes) {
2334       _eglError(EGL_BAD_PARAMETER,
2335                 "dri2_create_image_wayland_wl_buffer (plane out of bounds)");
2336       return NULL;
2337    }
2338
2339    dri_image = dri2_dpy->image->fromPlanar(buffer->driver_buffer, plane, NULL);
2340    if (dri_image == NULL && plane == 0)
2341       dri_image = dri2_dpy->image->dupImage(buffer->driver_buffer, NULL);
2342    if (dri_image == NULL) {
2343       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_wayland_wl_buffer");
2344       return NULL;
2345    }
2346
2347    return dri2_create_image_from_dri(disp, dri_image);
2348 }
2349 #endif
2350
2351 static EGLBoolean
2352 dri2_get_sync_values_chromium(_EGLDisplay *disp, _EGLSurface *surf,
2353                               EGLuint64KHR *ust, EGLuint64KHR *msc,
2354                               EGLuint64KHR *sbc)
2355 {
2356    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2357    if (!dri2_dpy->vtbl->get_sync_values)
2358       return EGL_FALSE;
2359    return dri2_dpy->vtbl->get_sync_values(disp, surf, ust, msc, sbc);
2360 }
2361
2362 /**
2363  * Set the error code after a call to
2364  * dri2_egl_image::dri_image::createImageFromTexture.
2365  */
2366 static void
2367 dri2_create_image_khr_texture_error(int dri_error)
2368 {
2369    EGLint egl_error = egl_error_from_dri_image_error(dri_error);
2370
2371    if (egl_error != EGL_SUCCESS)
2372       _eglError(egl_error, "dri2_create_image_khr_texture");
2373 }
2374
2375 static _EGLImage *
2376 dri2_create_image_khr_texture(_EGLDisplay *disp, _EGLContext *ctx,
2377                                    EGLenum target,
2378                                    EGLClientBuffer buffer,
2379                                    const EGLint *attr_list)
2380 {
2381    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2382    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2383    struct dri2_egl_image *dri2_img;
2384    GLuint texture = (GLuint) (uintptr_t) buffer;
2385    _EGLImageAttribs attrs;
2386    GLuint depth;
2387    GLenum gl_target;
2388    unsigned error;
2389
2390    if (texture == 0) {
2391       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2392       return EGL_NO_IMAGE_KHR;
2393    }
2394
2395    if (!_eglParseImageAttribList(&attrs, disp, attr_list))
2396       return EGL_NO_IMAGE_KHR;
2397
2398    switch (target) {
2399    case EGL_GL_TEXTURE_2D_KHR:
2400       if (!disp->Extensions.KHR_gl_texture_2D_image) {
2401          _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2402          return EGL_NO_IMAGE_KHR;
2403       }
2404       depth = 0;
2405       gl_target = GL_TEXTURE_2D;
2406       break;
2407    case EGL_GL_TEXTURE_3D_KHR:
2408       if (!disp->Extensions.KHR_gl_texture_3D_image) {
2409          _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2410          return EGL_NO_IMAGE_KHR;
2411       }
2412
2413       depth = attrs.GLTextureZOffset;
2414       gl_target = GL_TEXTURE_3D;
2415       break;
2416    case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
2417    case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
2418    case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
2419    case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
2420    case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
2421    case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
2422       if (!disp->Extensions.KHR_gl_texture_cubemap_image) {
2423          _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2424          return EGL_NO_IMAGE_KHR;
2425       }
2426
2427       depth = target - EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR;
2428       gl_target = GL_TEXTURE_CUBE_MAP;
2429       break;
2430    default:
2431       unreachable("Unexpected target in dri2_create_image_khr_texture()");
2432       return EGL_NO_IMAGE_KHR;
2433    }
2434
2435    dri2_img = malloc(sizeof *dri2_img);
2436    if (!dri2_img) {
2437       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2438       return EGL_NO_IMAGE_KHR;
2439    }
2440
2441    _eglInitImage(&dri2_img->base, disp);
2442
2443    dri2_img->dri_image =
2444       dri2_dpy->image->createImageFromTexture(dri2_ctx->dri_context,
2445                                               gl_target,
2446                                               texture,
2447                                               depth,
2448                                               attrs.GLTextureLevel,
2449                                               &error,
2450                                               NULL);
2451    dri2_create_image_khr_texture_error(error);
2452
2453    if (!dri2_img->dri_image) {
2454       free(dri2_img);
2455       return EGL_NO_IMAGE_KHR;
2456    }
2457    return &dri2_img->base;
2458 }
2459
2460 static EGLBoolean
2461 dri2_query_surface(_EGLDisplay *disp, _EGLSurface *surf,
2462                    EGLint attribute, EGLint *value)
2463 {
2464    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2465    if (!dri2_dpy->vtbl->query_surface)
2466       return _eglQuerySurface(disp, surf, attribute, value);
2467    return dri2_dpy->vtbl->query_surface(disp, surf, attribute, value);
2468 }
2469
2470 static struct wl_buffer*
2471 dri2_create_wayland_buffer_from_image(_EGLDisplay *disp, _EGLImage *img)
2472 {
2473    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2474    if (!dri2_dpy->vtbl->create_wayland_buffer_from_image)
2475       return NULL;
2476    return dri2_dpy->vtbl->create_wayland_buffer_from_image(disp, img);
2477 }
2478
2479 #ifdef HAVE_LIBDRM
2480 static _EGLImage *
2481 dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
2482                                   EGLClientBuffer buffer, const EGLint *attr_list)
2483 {
2484    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2485    EGLint format, name, pitch;
2486    _EGLImageAttribs attrs;
2487    __DRIimage *dri_image;
2488
2489    name = (EGLint) (uintptr_t) buffer;
2490
2491    if (!_eglParseImageAttribList(&attrs, disp, attr_list))
2492       return NULL;
2493
2494    if (attrs.Width <= 0 || attrs.Height <= 0 ||
2495        attrs.DRMBufferStrideMESA <= 0) {
2496       _eglError(EGL_BAD_PARAMETER,
2497                 "bad width, height or stride");
2498       return NULL;
2499    }
2500
2501    switch (attrs.DRMBufferFormatMESA) {
2502    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
2503       format = __DRI_IMAGE_FORMAT_ARGB8888;
2504       pitch = attrs.DRMBufferStrideMESA;
2505       break;
2506    default:
2507       _eglError(EGL_BAD_PARAMETER,
2508                 "dri2_create_image_khr: unsupported pixmap depth");
2509       return NULL;
2510    }
2511
2512    dri_image =
2513       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
2514                                            attrs.Width,
2515                                            attrs.Height,
2516                                            format,
2517                                            name,
2518                                            pitch,
2519                                            NULL);
2520
2521    return dri2_create_image_from_dri(disp, dri_image);
2522 }
2523
2524 static EGLBoolean
2525 dri2_check_dma_buf_attribs(const _EGLImageAttribs *attrs)
2526 {
2527    /**
2528      * The spec says:
2529      *
2530      * "Required attributes and their values are as follows:
2531      *
2532      *  * EGL_WIDTH & EGL_HEIGHT: The logical dimensions of the buffer in pixels
2533      *
2534      *  * EGL_LINUX_DRM_FOURCC_EXT: The pixel format of the buffer, as specified
2535      *    by drm_fourcc.h and used as the pixel_format parameter of the
2536      *    drm_mode_fb_cmd2 ioctl."
2537      *
2538      * and
2539      *
2540      * "* If <target> is EGL_LINUX_DMA_BUF_EXT, and the list of attributes is
2541      *    incomplete, EGL_BAD_PARAMETER is generated."
2542      */
2543    if (attrs->Width <= 0 || attrs->Height <= 0 ||
2544        !attrs->DMABufFourCC.IsPresent)
2545       return _eglError(EGL_BAD_PARAMETER, "attribute(s) missing");
2546
2547    /**
2548     * Also:
2549     *
2550     * "If <target> is EGL_LINUX_DMA_BUF_EXT and one or more of the values
2551     *  specified for a plane's pitch or offset isn't supported by EGL,
2552     *  EGL_BAD_ACCESS is generated."
2553     */
2554    for (unsigned i = 0; i < ARRAY_SIZE(attrs->DMABufPlanePitches); ++i) {
2555       if (attrs->DMABufPlanePitches[i].IsPresent &&
2556           attrs->DMABufPlanePitches[i].Value <= 0)
2557          return _eglError(EGL_BAD_ACCESS, "invalid pitch");
2558    }
2559
2560    /**
2561     * If <target> is EGL_LINUX_DMA_BUF_EXT, both or neither of the following
2562     * attribute values may be given.
2563     *
2564     * This is referring to EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT and
2565     * EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT, and the same for other planes.
2566     */
2567    for (unsigned i = 0; i < DMA_BUF_MAX_PLANES; ++i) {
2568       if (attrs->DMABufPlaneModifiersLo[i].IsPresent !=
2569           attrs->DMABufPlaneModifiersHi[i].IsPresent)
2570          return _eglError(EGL_BAD_PARAMETER, "modifier attribute lo or hi missing");
2571    }
2572
2573    /* Although the EGL_EXT_image_dma_buf_import_modifiers spec doesn't
2574     * mandate it, we only accept the same modifier across all planes. */
2575    for (unsigned i = 1; i < DMA_BUF_MAX_PLANES; ++i) {
2576       if (attrs->DMABufPlaneFds[i].IsPresent) {
2577          if ((attrs->DMABufPlaneModifiersLo[0].IsPresent !=
2578                attrs->DMABufPlaneModifiersLo[i].IsPresent) ||
2579              (attrs->DMABufPlaneModifiersLo[0].Value !=
2580                attrs->DMABufPlaneModifiersLo[i].Value) ||
2581              (attrs->DMABufPlaneModifiersHi[0].Value !=
2582                attrs->DMABufPlaneModifiersHi[i].Value))
2583             return _eglError(EGL_BAD_PARAMETER, "modifier attributes not equal");
2584       }
2585    }
2586
2587    return EGL_TRUE;
2588 }
2589
2590 /* Returns the total number of planes for the format or zero if it isn't a
2591  * valid fourcc format.
2592  */
2593 static unsigned
2594 dri2_num_fourcc_format_planes(EGLint format)
2595 {
2596    switch (format) {
2597    case DRM_FORMAT_R8:
2598    case DRM_FORMAT_RG88:
2599    case DRM_FORMAT_GR88:
2600    case DRM_FORMAT_R16:
2601    case DRM_FORMAT_GR1616:
2602    case DRM_FORMAT_RGB332:
2603    case DRM_FORMAT_BGR233:
2604    case DRM_FORMAT_XRGB4444:
2605    case DRM_FORMAT_XBGR4444:
2606    case DRM_FORMAT_RGBX4444:
2607    case DRM_FORMAT_BGRX4444:
2608    case DRM_FORMAT_ARGB4444:
2609    case DRM_FORMAT_ABGR4444:
2610    case DRM_FORMAT_RGBA4444:
2611    case DRM_FORMAT_BGRA4444:
2612    case DRM_FORMAT_XRGB1555:
2613    case DRM_FORMAT_XBGR1555:
2614    case DRM_FORMAT_RGBX5551:
2615    case DRM_FORMAT_BGRX5551:
2616    case DRM_FORMAT_ARGB1555:
2617    case DRM_FORMAT_ABGR1555:
2618    case DRM_FORMAT_RGBA5551:
2619    case DRM_FORMAT_BGRA5551:
2620    case DRM_FORMAT_RGB565:
2621    case DRM_FORMAT_BGR565:
2622    case DRM_FORMAT_RGB888:
2623    case DRM_FORMAT_BGR888:
2624    case DRM_FORMAT_XRGB8888:
2625    case DRM_FORMAT_XBGR8888:
2626    case DRM_FORMAT_RGBX8888:
2627    case DRM_FORMAT_BGRX8888:
2628    case DRM_FORMAT_ARGB8888:
2629    case DRM_FORMAT_ABGR8888:
2630    case DRM_FORMAT_RGBA8888:
2631    case DRM_FORMAT_BGRA8888:
2632    case DRM_FORMAT_XRGB2101010:
2633    case DRM_FORMAT_XBGR2101010:
2634    case DRM_FORMAT_RGBX1010102:
2635    case DRM_FORMAT_BGRX1010102:
2636    case DRM_FORMAT_ARGB2101010:
2637    case DRM_FORMAT_ABGR2101010:
2638    case DRM_FORMAT_RGBA1010102:
2639    case DRM_FORMAT_BGRA1010102:
2640    case DRM_FORMAT_XBGR16161616F:
2641    case DRM_FORMAT_ABGR16161616F:
2642    case DRM_FORMAT_YUYV:
2643    case DRM_FORMAT_YVYU:
2644    case DRM_FORMAT_UYVY:
2645    case DRM_FORMAT_VYUY:
2646    case DRM_FORMAT_AYUV:
2647    case DRM_FORMAT_XYUV8888:
2648       return 1;
2649
2650    case DRM_FORMAT_NV12:
2651    case DRM_FORMAT_NV21:
2652    case DRM_FORMAT_NV16:
2653    case DRM_FORMAT_NV61:
2654    case DRM_FORMAT_P010:
2655    case DRM_FORMAT_P012:
2656    case DRM_FORMAT_P016:
2657       return 2;
2658
2659    case DRM_FORMAT_YUV410:
2660    case DRM_FORMAT_YVU410:
2661    case DRM_FORMAT_YUV411:
2662    case DRM_FORMAT_YVU411:
2663    case DRM_FORMAT_YUV420:
2664    case DRM_FORMAT_YVU420:
2665    case DRM_FORMAT_YUV422:
2666    case DRM_FORMAT_YVU422:
2667    case DRM_FORMAT_YUV444:
2668    case DRM_FORMAT_YVU444:
2669       return 3;
2670
2671    default:
2672       return 0;
2673    }
2674 }
2675
2676 /* Returns the total number of file descriptors. Zero indicates an error. */
2677 static unsigned
2678 dri2_check_dma_buf_format(const _EGLImageAttribs *attrs)
2679 {
2680    unsigned plane_n = dri2_num_fourcc_format_planes(attrs->DMABufFourCC.Value);
2681    if (plane_n == 0) {
2682       _eglError(EGL_BAD_MATCH, "unknown drm fourcc format");
2683       return 0;
2684    }
2685
2686    for (unsigned i = plane_n; i < DMA_BUF_MAX_PLANES; i++) {
2687       /**
2688        * The modifiers extension spec says:
2689        *
2690        * "Modifiers may modify any attribute of a buffer import, including
2691        *  but not limited to adding extra planes to a format which
2692        *  otherwise does not have those planes. As an example, a modifier
2693        *  may add a plane for an external compression buffer to a
2694        *  single-plane format. The exact meaning and effect of any
2695        *  modifier is canonically defined by drm_fourcc.h, not as part of
2696        *  this extension."
2697        */
2698       if (attrs->DMABufPlaneModifiersLo[i].IsPresent &&
2699           attrs->DMABufPlaneModifiersHi[i].IsPresent) {
2700          plane_n = i + 1;
2701       }
2702    }
2703
2704    /**
2705      * The spec says:
2706      *
2707      * "* If <target> is EGL_LINUX_DMA_BUF_EXT, and the list of attributes is
2708      *    incomplete, EGL_BAD_PARAMETER is generated."
2709      */
2710    for (unsigned i = 0; i < plane_n; ++i) {
2711       if (!attrs->DMABufPlaneFds[i].IsPresent ||
2712           !attrs->DMABufPlaneOffsets[i].IsPresent ||
2713           !attrs->DMABufPlanePitches[i].IsPresent) {
2714          _eglError(EGL_BAD_PARAMETER, "plane attribute(s) missing");
2715          return 0;
2716       }
2717    }
2718
2719    /**
2720     * The spec also says:
2721     *
2722     * "If <target> is EGL_LINUX_DMA_BUF_EXT, and the EGL_LINUX_DRM_FOURCC_EXT
2723     *  attribute indicates a single-plane format, EGL_BAD_ATTRIBUTE is
2724     *  generated if any of the EGL_DMA_BUF_PLANE1_* or EGL_DMA_BUF_PLANE2_*
2725     *  or EGL_DMA_BUF_PLANE3_* attributes are specified."
2726     */
2727    for (unsigned i = plane_n; i < DMA_BUF_MAX_PLANES; ++i) {
2728       if (attrs->DMABufPlaneFds[i].IsPresent ||
2729           attrs->DMABufPlaneOffsets[i].IsPresent ||
2730           attrs->DMABufPlanePitches[i].IsPresent) {
2731          _eglError(EGL_BAD_ATTRIBUTE, "too many plane attributes");
2732          return 0;
2733       }
2734    }
2735
2736    return plane_n;
2737 }
2738
2739 static EGLBoolean
2740 dri2_query_dma_buf_formats(_EGLDisplay *disp, EGLint max,
2741                            EGLint *formats, EGLint *count)
2742 {
2743    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2744    if (max < 0 || (max > 0 && formats == NULL))
2745       return _eglError(EGL_BAD_PARAMETER, "invalid value for max count of formats");
2746
2747    if (dri2_dpy->image->base.version < 15 ||
2748        dri2_dpy->image->queryDmaBufFormats == NULL)
2749       return EGL_FALSE;
2750
2751    if (!dri2_dpy->image->queryDmaBufFormats(dri2_dpy->dri_screen, max,
2752                                             formats, count))
2753       return EGL_FALSE;
2754
2755    if (max > 0) {
2756       /* Assert that all of the formats returned are actually fourcc formats.
2757        * Some day, if we want the internal interface function to be able to
2758        * return the fake fourcc formats defined in dri_interface.h, we'll have
2759        * to do something more clever here to pair the list down to just real
2760        * fourcc formats so that we don't leak the fake internal ones.
2761        */
2762       for (int i = 0; i < *count; i++) {
2763          assert(dri2_num_fourcc_format_planes(formats[i]) > 0);
2764       }
2765    }
2766
2767    return EGL_TRUE;
2768 }
2769
2770 static EGLBoolean
2771 dri2_query_dma_buf_modifiers(_EGLDisplay *disp, EGLint format,
2772                              EGLint max, EGLuint64KHR *modifiers,
2773                              EGLBoolean *external_only, EGLint *count)
2774 {
2775    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2776
2777    if (dri2_num_fourcc_format_planes(format) == 0)
2778       return _eglError(EGL_BAD_PARAMETER, "invalid fourcc format");
2779
2780    if (max < 0)
2781       return _eglError(EGL_BAD_PARAMETER, "invalid value for max count of formats");
2782
2783    if (max > 0 && modifiers == NULL)
2784       return _eglError(EGL_BAD_PARAMETER, "invalid modifiers array");
2785
2786    if (dri2_dpy->image->base.version < 15 ||
2787        dri2_dpy->image->queryDmaBufModifiers == NULL)
2788       return EGL_FALSE;
2789
2790    if (dri2_dpy->image->queryDmaBufModifiers(dri2_dpy->dri_screen, format,
2791                                              max, modifiers,
2792                                              (unsigned int *) external_only,
2793                                              count) == false)
2794       return _eglError(EGL_BAD_PARAMETER, "invalid format");
2795
2796    return EGL_TRUE;
2797 }
2798
2799 /**
2800  * The spec says:
2801  *
2802  * "If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT target, the
2803  *  EGL will take a reference to the dma_buf(s) which it will release at any
2804  *  time while the EGLDisplay is initialized. It is the responsibility of the
2805  *  application to close the dma_buf file descriptors."
2806  *
2807  * Therefore we must never close or otherwise modify the file descriptors.
2808  */
2809 _EGLImage *
2810 dri2_create_image_dma_buf(_EGLDisplay *disp, _EGLContext *ctx,
2811                           EGLClientBuffer buffer, const EGLint *attr_list)
2812 {
2813    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2814    _EGLImage *res;
2815    _EGLImageAttribs attrs;
2816    __DRIimage *dri_image;
2817    unsigned num_fds;
2818    int fds[DMA_BUF_MAX_PLANES];
2819    int pitches[DMA_BUF_MAX_PLANES];
2820    int offsets[DMA_BUF_MAX_PLANES];
2821    uint64_t modifier;
2822    bool has_modifier = false;
2823    unsigned error;
2824
2825    /**
2826     * The spec says:
2827     *
2828     * ""* If <target> is EGL_LINUX_DMA_BUF_EXT and <buffer> is not NULL, the
2829     *     error EGL_BAD_PARAMETER is generated."
2830     */
2831    if (buffer != NULL) {
2832       _eglError(EGL_BAD_PARAMETER, "buffer not NULL");
2833       return NULL;
2834    }
2835
2836    if (!_eglParseImageAttribList(&attrs, disp, attr_list))
2837       return NULL;
2838
2839    if (!dri2_check_dma_buf_attribs(&attrs))
2840       return NULL;
2841
2842    num_fds = dri2_check_dma_buf_format(&attrs);
2843    if (!num_fds)
2844       return NULL;
2845
2846    for (unsigned i = 0; i < num_fds; ++i) {
2847       fds[i] = attrs.DMABufPlaneFds[i].Value;
2848       pitches[i] = attrs.DMABufPlanePitches[i].Value;
2849       offsets[i] = attrs.DMABufPlaneOffsets[i].Value;
2850    }
2851
2852    /* dri2_check_dma_buf_attribs ensures that the modifier, if available,
2853     * will be present in attrs.DMABufPlaneModifiersLo[0] and
2854     * attrs.DMABufPlaneModifiersHi[0] */
2855    if (attrs.DMABufPlaneModifiersLo[0].IsPresent) {
2856       modifier = combine_u32_into_u64(attrs.DMABufPlaneModifiersHi[0].Value,
2857                                       attrs.DMABufPlaneModifiersLo[0].Value);
2858       has_modifier = true;
2859    }
2860
2861    if (attrs.ProtectedContent) {
2862       if (dri2_dpy->image->base.version < 18 ||
2863           dri2_dpy->image->createImageFromDmaBufs3 == NULL) {
2864          _eglError(EGL_BAD_MATCH, "unsupported protected_content attribute");
2865          return EGL_NO_IMAGE_KHR;
2866       }
2867       if (!has_modifier)
2868          modifier = DRM_FORMAT_MOD_INVALID;
2869
2870       dri_image =
2871          dri2_dpy->image->createImageFromDmaBufs3(dri2_dpy->dri_screen,
2872             attrs.Width, attrs.Height, attrs.DMABufFourCC.Value,
2873             modifier, fds, num_fds, pitches, offsets,
2874             attrs.DMABufYuvColorSpaceHint.Value,
2875             attrs.DMABufSampleRangeHint.Value,
2876             attrs.DMABufChromaHorizontalSiting.Value,
2877             attrs.DMABufChromaVerticalSiting.Value,
2878             attrs.ProtectedContent ? __DRI_IMAGE_PROTECTED_CONTENT_FLAG : 0,
2879             &error,
2880             NULL);
2881    }
2882    else if (has_modifier) {
2883       if (dri2_dpy->image->base.version < 15 ||
2884           dri2_dpy->image->createImageFromDmaBufs2 == NULL) {
2885          _eglError(EGL_BAD_MATCH, "unsupported dma_buf format modifier");
2886          return EGL_NO_IMAGE_KHR;
2887       }
2888       dri_image =
2889          dri2_dpy->image->createImageFromDmaBufs2(dri2_dpy->dri_screen,
2890             attrs.Width, attrs.Height, attrs.DMABufFourCC.Value,
2891             modifier, fds, num_fds, pitches, offsets,
2892             attrs.DMABufYuvColorSpaceHint.Value,
2893             attrs.DMABufSampleRangeHint.Value,
2894             attrs.DMABufChromaHorizontalSiting.Value,
2895             attrs.DMABufChromaVerticalSiting.Value,
2896             &error,
2897             NULL);
2898    }
2899    else {
2900       dri_image =
2901          dri2_dpy->image->createImageFromDmaBufs(dri2_dpy->dri_screen,
2902             attrs.Width, attrs.Height, attrs.DMABufFourCC.Value,
2903             fds, num_fds, pitches, offsets,
2904             attrs.DMABufYuvColorSpaceHint.Value,
2905             attrs.DMABufSampleRangeHint.Value,
2906             attrs.DMABufChromaHorizontalSiting.Value,
2907             attrs.DMABufChromaVerticalSiting.Value,
2908             &error,
2909             NULL);
2910    }
2911    dri2_create_image_khr_texture_error(error);
2912
2913    if (!dri_image)
2914       return EGL_NO_IMAGE_KHR;
2915
2916    res = dri2_create_image_from_dri(disp, dri_image);
2917
2918    return res;
2919 }
2920 static _EGLImage *
2921 dri2_create_drm_image_mesa(_EGLDisplay *disp, const EGLint *attr_list)
2922 {
2923    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2924    struct dri2_egl_image *dri2_img;
2925    _EGLImageAttribs attrs;
2926    unsigned int dri_use, valid_mask;
2927    int format;
2928
2929    if (!attr_list) {
2930       _eglError(EGL_BAD_PARAMETER, __func__);
2931       return EGL_NO_IMAGE_KHR;
2932    }
2933
2934    if (!_eglParseImageAttribList(&attrs, disp, attr_list))
2935       return EGL_NO_IMAGE_KHR;
2936
2937    if (attrs.Width <= 0 || attrs.Height <= 0) {
2938       _eglError(EGL_BAD_PARAMETER, __func__);
2939       return EGL_NO_IMAGE_KHR;
2940    }
2941
2942    switch (attrs.DRMBufferFormatMESA) {
2943    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
2944       format = __DRI_IMAGE_FORMAT_ARGB8888;
2945       break;
2946    default:
2947       _eglError(EGL_BAD_PARAMETER, __func__);
2948       return EGL_NO_IMAGE_KHR;
2949    }
2950
2951    valid_mask =
2952       EGL_DRM_BUFFER_USE_SCANOUT_MESA |
2953       EGL_DRM_BUFFER_USE_SHARE_MESA |
2954       EGL_DRM_BUFFER_USE_CURSOR_MESA;
2955    if (attrs.DRMBufferUseMESA & ~valid_mask) {
2956       _eglError(EGL_BAD_PARAMETER, __func__);
2957       return EGL_NO_IMAGE_KHR;
2958    }
2959
2960    dri_use = 0;
2961    if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)
2962       dri_use |= __DRI_IMAGE_USE_SHARE;
2963    if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
2964       dri_use |= __DRI_IMAGE_USE_SCANOUT;
2965    if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_CURSOR_MESA)
2966       dri_use |= __DRI_IMAGE_USE_CURSOR;
2967
2968    dri2_img = malloc(sizeof *dri2_img);
2969    if (!dri2_img) {
2970       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2971       return EGL_NO_IMAGE_KHR;
2972    }
2973
2974    _eglInitImage(&dri2_img->base, disp);
2975
2976    dri2_img->dri_image =
2977       dri2_dpy->image->createImage(dri2_dpy->dri_screen,
2978                                    attrs.Width, attrs.Height,
2979                                    format, dri_use, dri2_img);
2980    if (dri2_img->dri_image == NULL) {
2981       free(dri2_img);
2982        _eglError(EGL_BAD_ALLOC, "dri2_create_drm_image_mesa");
2983       return EGL_NO_IMAGE_KHR;
2984    }
2985
2986    return &dri2_img->base;
2987 }
2988
2989 static EGLBoolean
2990 dri2_export_drm_image_mesa(_EGLDisplay *disp, _EGLImage *img,
2991                           EGLint *name, EGLint *handle, EGLint *stride)
2992 {
2993    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2994    struct dri2_egl_image *dri2_img = dri2_egl_image(img);
2995
2996    if (name && !dri2_dpy->image->queryImage(dri2_img->dri_image,
2997                                             __DRI_IMAGE_ATTRIB_NAME, name))
2998       return _eglError(EGL_BAD_ALLOC, "dri2_export_drm_image_mesa");
2999
3000    if (handle)
3001       dri2_dpy->image->queryImage(dri2_img->dri_image,
3002                                   __DRI_IMAGE_ATTRIB_HANDLE, handle);
3003
3004    if (stride)
3005       dri2_dpy->image->queryImage(dri2_img->dri_image,
3006                                   __DRI_IMAGE_ATTRIB_STRIDE, stride);
3007
3008    return EGL_TRUE;
3009 }
3010
3011 /**
3012  * Checks if we can support EGL_MESA_image_dma_buf_export on this image.
3013
3014  * The spec provides a boolean return for the driver to reject exporting for
3015  * basically any reason, but doesn't specify any particular error cases.  For
3016  * now, we just fail if we don't have a DRM fourcc for the format.
3017  */
3018 static bool
3019 dri2_can_export_dma_buf_image(_EGLDisplay *disp, _EGLImage *img)
3020 {
3021    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3022    struct dri2_egl_image *dri2_img = dri2_egl_image(img);
3023    EGLint fourcc;
3024
3025    if (!dri2_dpy->image->queryImage(dri2_img->dri_image,
3026                                     __DRI_IMAGE_ATTRIB_FOURCC, &fourcc)) {
3027       return false;
3028    }
3029
3030    return true;
3031 }
3032
3033 static EGLBoolean
3034 dri2_export_dma_buf_image_query_mesa(_EGLDisplay *disp, _EGLImage *img,
3035                                      EGLint *fourcc, EGLint *nplanes,
3036                                      EGLuint64KHR *modifiers)
3037 {
3038    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3039    struct dri2_egl_image *dri2_img = dri2_egl_image(img);
3040    int num_planes;
3041
3042    if (!dri2_can_export_dma_buf_image(disp, img))
3043       return EGL_FALSE;
3044
3045    dri2_dpy->image->queryImage(dri2_img->dri_image,
3046                                __DRI_IMAGE_ATTRIB_NUM_PLANES, &num_planes);
3047    if (nplanes)
3048      *nplanes = num_planes;
3049
3050    if (fourcc)
3051       dri2_dpy->image->queryImage(dri2_img->dri_image,
3052                                   __DRI_IMAGE_ATTRIB_FOURCC, fourcc);
3053
3054    if (modifiers) {
3055       int mod_hi, mod_lo;
3056       uint64_t modifier = DRM_FORMAT_MOD_INVALID;
3057       bool query;
3058
3059       query = dri2_dpy->image->queryImage(dri2_img->dri_image,
3060                                           __DRI_IMAGE_ATTRIB_MODIFIER_UPPER,
3061                                           &mod_hi);
3062       query &= dri2_dpy->image->queryImage(dri2_img->dri_image,
3063                                            __DRI_IMAGE_ATTRIB_MODIFIER_LOWER,
3064                                            &mod_lo);
3065       if (query)
3066          modifier = combine_u32_into_u64 (mod_hi, mod_lo);
3067
3068       for (int i = 0; i < num_planes; i++)
3069         modifiers[i] = modifier;
3070    }
3071
3072    return EGL_TRUE;
3073 }
3074
3075 static EGLBoolean
3076 dri2_export_dma_buf_image_mesa(_EGLDisplay *disp, _EGLImage *img,
3077                                int *fds, EGLint *strides, EGLint *offsets)
3078 {
3079    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3080    struct dri2_egl_image *dri2_img = dri2_egl_image(img);
3081    EGLint nplanes;
3082
3083    if (!dri2_can_export_dma_buf_image(disp, img))
3084       return EGL_FALSE;
3085
3086    /* EGL_MESA_image_dma_buf_export spec says:
3087     *    "If the number of fds is less than the number of planes, then
3088     *    subsequent fd slots should contain -1."
3089     */
3090    if (fds) {
3091       /* Query nplanes so that we know how big the given array is. */
3092       dri2_dpy->image->queryImage(dri2_img->dri_image,
3093                                   __DRI_IMAGE_ATTRIB_NUM_PLANES, &nplanes);
3094       memset(fds, -1, nplanes * sizeof(int));
3095    }
3096
3097    /* rework later to provide multiple fds/strides/offsets */
3098    if (fds)
3099       dri2_dpy->image->queryImage(dri2_img->dri_image,
3100                                   __DRI_IMAGE_ATTRIB_FD, fds);
3101
3102    if (strides)
3103       dri2_dpy->image->queryImage(dri2_img->dri_image,
3104                                   __DRI_IMAGE_ATTRIB_STRIDE, strides);
3105
3106    if (offsets) {
3107       int img_offset;
3108       bool ret = dri2_dpy->image->queryImage(dri2_img->dri_image,
3109                      __DRI_IMAGE_ATTRIB_OFFSET, &img_offset);
3110       if (ret)
3111          offsets[0] = img_offset;
3112       else
3113          offsets[0] = 0;
3114    }
3115
3116    return EGL_TRUE;
3117 }
3118
3119 #endif
3120
3121 _EGLImage *
3122 dri2_create_image_khr(_EGLDisplay *disp, _EGLContext *ctx, EGLenum target,
3123                       EGLClientBuffer buffer, const EGLint *attr_list)
3124 {
3125    switch (target) {
3126    case EGL_GL_TEXTURE_2D_KHR:
3127    case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
3128    case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
3129    case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
3130    case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
3131    case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
3132    case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
3133    case EGL_GL_TEXTURE_3D_KHR:
3134       return dri2_create_image_khr_texture(disp, ctx, target, buffer, attr_list);
3135    case EGL_GL_RENDERBUFFER_KHR:
3136       return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
3137 #ifdef HAVE_LIBDRM
3138    case EGL_DRM_BUFFER_MESA:
3139       return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
3140    case EGL_LINUX_DMA_BUF_EXT:
3141       return dri2_create_image_dma_buf(disp, ctx, buffer, attr_list);
3142 #endif
3143 #ifdef HAVE_WAYLAND_PLATFORM
3144    case EGL_WAYLAND_BUFFER_WL:
3145       return dri2_create_image_wayland_wl_buffer(disp, ctx, buffer, attr_list);
3146 #endif
3147    default:
3148       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
3149       return EGL_NO_IMAGE_KHR;
3150    }
3151 }
3152
3153 static EGLBoolean
3154 dri2_destroy_image_khr(_EGLDisplay *disp, _EGLImage *image)
3155 {
3156    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3157    struct dri2_egl_image *dri2_img = dri2_egl_image(image);
3158
3159    dri2_dpy->image->destroyImage(dri2_img->dri_image);
3160    free(dri2_img);
3161
3162    return EGL_TRUE;
3163 }
3164
3165 #ifdef HAVE_WAYLAND_PLATFORM
3166
3167 static void
3168 dri2_wl_reference_buffer(void *user_data, uint32_t name, int fd,
3169                          struct wl_drm_buffer *buffer)
3170 {
3171    _EGLDisplay *disp = user_data;
3172    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3173    __DRIimage *img;
3174    int dri_components = 0;
3175
3176    if (fd == -1)
3177       img = dri2_dpy->image->createImageFromNames(dri2_dpy->dri_screen,
3178                                                   buffer->width,
3179                                                   buffer->height,
3180                                                   buffer->format,
3181                                                   (int*)&name, 1,
3182                                                   buffer->stride,
3183                                                   buffer->offset,
3184                                                   NULL);
3185    else
3186       img = dri2_dpy->image->createImageFromFds(dri2_dpy->dri_screen,
3187                                                 buffer->width,
3188                                                 buffer->height,
3189                                                 buffer->format,
3190                                                 &fd, 1,
3191                                                 buffer->stride,
3192                                                 buffer->offset,
3193                                                 NULL);
3194
3195    if (img == NULL)
3196       return;
3197
3198    dri2_dpy->image->queryImage(img, __DRI_IMAGE_ATTRIB_COMPONENTS, &dri_components);
3199
3200    buffer->driver_format = NULL;
3201    for (int i = 0; i < ARRAY_SIZE(wl_drm_components); i++)
3202       if (wl_drm_components[i].dri_components == dri_components)
3203          buffer->driver_format = &wl_drm_components[i];
3204
3205    if (buffer->driver_format == NULL)
3206       dri2_dpy->image->destroyImage(img);
3207    else
3208       buffer->driver_buffer = img;
3209 }
3210
3211 static void
3212 dri2_wl_release_buffer(void *user_data, struct wl_drm_buffer *buffer)
3213 {
3214    _EGLDisplay *disp = user_data;
3215    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3216
3217    dri2_dpy->image->destroyImage(buffer->driver_buffer);
3218 }
3219
3220 static EGLBoolean
3221 dri2_bind_wayland_display_wl(_EGLDisplay *disp, struct wl_display *wl_dpy)
3222 {
3223    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3224    const struct wayland_drm_callbacks wl_drm_callbacks = {
3225       .authenticate = (int(*)(void *, uint32_t)) dri2_dpy->vtbl->authenticate,
3226       .reference_buffer = dri2_wl_reference_buffer,
3227       .release_buffer = dri2_wl_release_buffer,
3228       .is_format_supported = dri2_wl_is_format_supported
3229    };
3230    int flags = 0;
3231    char *device_name;
3232    uint64_t cap;
3233
3234    if (dri2_dpy->wl_server_drm)
3235            return EGL_FALSE;
3236
3237    device_name = drmGetRenderDeviceNameFromFd(dri2_dpy->fd);
3238    if (!device_name)
3239       device_name = strdup(dri2_dpy->device_name);
3240    if (!device_name)
3241       return EGL_FALSE;
3242
3243    if (drmGetCap(dri2_dpy->fd, DRM_CAP_PRIME, &cap) == 0 &&
3244        cap == (DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT) &&
3245        dri2_dpy->image->base.version >= 7 &&
3246        dri2_dpy->image->createImageFromFds != NULL)
3247       flags |= WAYLAND_DRM_PRIME;
3248
3249    dri2_dpy->wl_server_drm =
3250            wayland_drm_init(wl_dpy, device_name,
3251                             &wl_drm_callbacks, disp, flags);
3252
3253    free(device_name);
3254
3255    if (!dri2_dpy->wl_server_drm)
3256            return EGL_FALSE;
3257
3258 #ifdef HAVE_DRM_PLATFORM
3259    /* We have to share the wl_drm instance with gbm, so gbm can convert
3260     * wl_buffers to gbm bos. */
3261    if (dri2_dpy->gbm_dri)
3262       dri2_dpy->gbm_dri->wl_drm = dri2_dpy->wl_server_drm;
3263 #endif
3264
3265    return EGL_TRUE;
3266 }
3267
3268 static EGLBoolean
3269 dri2_unbind_wayland_display_wl(_EGLDisplay *disp, struct wl_display *wl_dpy)
3270 {
3271    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3272
3273    if (!dri2_dpy->wl_server_drm)
3274            return EGL_FALSE;
3275
3276    wayland_drm_uninit(dri2_dpy->wl_server_drm);
3277    dri2_dpy->wl_server_drm = NULL;
3278
3279    return EGL_TRUE;
3280 }
3281
3282 static EGLBoolean
3283 dri2_query_wayland_buffer_wl(_EGLDisplay *disp, struct wl_resource *buffer_resource,
3284                              EGLint attribute, EGLint *value)
3285 {
3286    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3287    struct wl_drm_buffer *buffer;
3288    const struct wl_drm_components_descriptor *format;
3289
3290    buffer = wayland_drm_buffer_get(dri2_dpy->wl_server_drm, buffer_resource);
3291    if (!buffer)
3292       return EGL_FALSE;
3293
3294    format = buffer->driver_format;
3295    switch (attribute) {
3296    case EGL_TEXTURE_FORMAT:
3297       *value = format->components;
3298       return EGL_TRUE;
3299    case EGL_WIDTH:
3300       *value = buffer->width;
3301       return EGL_TRUE;
3302    case EGL_HEIGHT:
3303       *value = buffer->height;
3304       return EGL_TRUE;
3305    }
3306
3307    return EGL_FALSE;
3308 }
3309 #endif
3310
3311 static void
3312 dri2_egl_ref_sync(struct dri2_egl_sync *sync)
3313 {
3314    p_atomic_inc(&sync->refcount);
3315 }
3316
3317 static void
3318 dri2_egl_unref_sync(struct dri2_egl_display *dri2_dpy,
3319                     struct dri2_egl_sync *dri2_sync)
3320 {
3321    if (p_atomic_dec_zero(&dri2_sync->refcount)) {
3322       switch (dri2_sync->base.Type) {
3323       case EGL_SYNC_REUSABLE_KHR:
3324          cnd_destroy(&dri2_sync->cond);
3325          break;
3326       case EGL_SYNC_NATIVE_FENCE_ANDROID:
3327          if (dri2_sync->base.SyncFd != EGL_NO_NATIVE_FENCE_FD_ANDROID)
3328             close(dri2_sync->base.SyncFd);
3329          break;
3330       default:
3331          break;
3332       }
3333
3334       if (dri2_sync->fence)
3335          dri2_dpy->fence->destroy_fence(dri2_dpy->dri_screen, dri2_sync->fence);
3336
3337       free(dri2_sync);
3338    }
3339 }
3340
3341 static _EGLSync *
3342 dri2_create_sync(_EGLDisplay *disp, EGLenum type, const EGLAttrib *attrib_list)
3343 {
3344    _EGLContext *ctx = _eglGetCurrentContext();
3345    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3346    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
3347    struct dri2_egl_sync *dri2_sync;
3348    EGLint ret;
3349    pthread_condattr_t attr;
3350
3351    dri2_sync = calloc(1, sizeof(struct dri2_egl_sync));
3352    if (!dri2_sync) {
3353       _eglError(EGL_BAD_ALLOC, "eglCreateSyncKHR");
3354       return NULL;
3355    }
3356
3357    if (!_eglInitSync(&dri2_sync->base, disp, type, attrib_list)) {
3358       free(dri2_sync);
3359       return NULL;
3360    }
3361
3362    switch (type) {
3363    case EGL_SYNC_FENCE_KHR:
3364       dri2_sync->fence = dri2_dpy->fence->create_fence(dri2_ctx->dri_context);
3365       if (!dri2_sync->fence) {
3366          /* Why did it fail? DRI doesn't return an error code, so we emit
3367           * a generic EGL error that doesn't communicate user error.
3368           */
3369          _eglError(EGL_BAD_ALLOC, "eglCreateSyncKHR");
3370          free(dri2_sync);
3371          return NULL;
3372       }
3373       break;
3374
3375    case EGL_SYNC_CL_EVENT_KHR:
3376       dri2_sync->fence = dri2_dpy->fence->get_fence_from_cl_event(
3377                                  dri2_dpy->dri_screen,
3378                                  dri2_sync->base.CLEvent);
3379       /* this can only happen if the cl_event passed in is invalid. */
3380       if (!dri2_sync->fence) {
3381          _eglError(EGL_BAD_ATTRIBUTE, "eglCreateSyncKHR");
3382          free(dri2_sync);
3383          return NULL;
3384       }
3385
3386       /* the initial status must be "signaled" if the cl_event is signaled */
3387       if (dri2_dpy->fence->client_wait_sync(dri2_ctx->dri_context,
3388                                             dri2_sync->fence, 0, 0))
3389          dri2_sync->base.SyncStatus = EGL_SIGNALED_KHR;
3390       break;
3391
3392    case EGL_SYNC_REUSABLE_KHR:
3393       /* intialize attr */
3394       ret = pthread_condattr_init(&attr);
3395
3396       if (ret) {
3397          _eglError(EGL_BAD_ACCESS, "eglCreateSyncKHR");
3398          free(dri2_sync);
3399          return NULL;
3400       }
3401
3402       /* change clock attribute to CLOCK_MONOTONIC */
3403       ret = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
3404
3405       if (ret) {
3406          _eglError(EGL_BAD_ACCESS, "eglCreateSyncKHR");
3407          free(dri2_sync);
3408          return NULL;
3409       }
3410
3411       ret = pthread_cond_init(&dri2_sync->cond, &attr);
3412
3413       if (ret) {
3414          _eglError(EGL_BAD_ACCESS, "eglCreateSyncKHR");
3415          free(dri2_sync);
3416          return NULL;
3417       }
3418
3419       /* initial status of reusable sync must be "unsignaled" */
3420       dri2_sync->base.SyncStatus = EGL_UNSIGNALED_KHR;
3421       break;
3422
3423    case EGL_SYNC_NATIVE_FENCE_ANDROID:
3424       if (dri2_dpy->fence->create_fence_fd) {
3425          dri2_sync->fence = dri2_dpy->fence->create_fence_fd(
3426                                     dri2_ctx->dri_context,
3427                                     dri2_sync->base.SyncFd);
3428       }
3429       if (!dri2_sync->fence) {
3430          _eglError(EGL_BAD_ATTRIBUTE, "eglCreateSyncKHR");
3431          free(dri2_sync);
3432          return NULL;
3433       }
3434       break;
3435    }
3436
3437    p_atomic_set(&dri2_sync->refcount, 1);
3438    return &dri2_sync->base;
3439 }
3440
3441 static EGLBoolean
3442 dri2_destroy_sync(_EGLDisplay *disp, _EGLSync *sync)
3443 {
3444    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3445    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
3446    EGLint ret = EGL_TRUE;
3447    EGLint err;
3448
3449    /* if type of sync is EGL_SYNC_REUSABLE_KHR and it is not signaled yet,
3450     * then unlock all threads possibly blocked by the reusable sync before
3451     * destroying it.
3452     */
3453    if (dri2_sync->base.Type == EGL_SYNC_REUSABLE_KHR &&
3454        dri2_sync->base.SyncStatus == EGL_UNSIGNALED_KHR) {
3455       dri2_sync->base.SyncStatus = EGL_SIGNALED_KHR;
3456       /* unblock all threads currently blocked by sync */
3457       err = cnd_broadcast(&dri2_sync->cond);
3458
3459       if (err) {
3460          _eglError(EGL_BAD_ACCESS, "eglDestroySyncKHR");
3461          ret = EGL_FALSE;
3462       }
3463    }
3464
3465    dri2_egl_unref_sync(dri2_dpy, dri2_sync);
3466
3467    return ret;
3468 }
3469
3470 static EGLint
3471 dri2_dup_native_fence_fd(_EGLDisplay *disp, _EGLSync *sync)
3472 {
3473    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3474    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
3475
3476    assert(sync->Type == EGL_SYNC_NATIVE_FENCE_ANDROID);
3477
3478    if (sync->SyncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3479       /* try to retrieve the actual native fence fd.. if rendering is
3480        * not flushed this will just return -1, aka NO_NATIVE_FENCE_FD:
3481        */
3482       sync->SyncFd = dri2_dpy->fence->get_fence_fd(dri2_dpy->dri_screen,
3483                                                    dri2_sync->fence);
3484    }
3485
3486    if (sync->SyncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3487       /* if native fence fd still not created, return an error: */
3488       _eglError(EGL_BAD_PARAMETER, "eglDupNativeFenceFDANDROID");
3489       return EGL_NO_NATIVE_FENCE_FD_ANDROID;
3490    }
3491
3492    return os_dupfd_cloexec(sync->SyncFd);
3493 }
3494
3495 static void
3496 dri2_set_blob_cache_funcs(_EGLDisplay *disp,
3497                           EGLSetBlobFuncANDROID set,
3498                           EGLGetBlobFuncANDROID get)
3499 {
3500    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3501    dri2_dpy->blob->set_cache_funcs(dri2_dpy->dri_screen,
3502                                    disp->BlobCacheSet,
3503                                    disp->BlobCacheGet);
3504 }
3505
3506 static EGLint
3507 dri2_client_wait_sync(_EGLDisplay *disp, _EGLSync *sync,
3508                       EGLint flags, EGLTime timeout)
3509 {
3510    _EGLContext *ctx = _eglGetCurrentContext();
3511    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3512    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
3513    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
3514    unsigned wait_flags = 0;
3515
3516    EGLint ret = EGL_CONDITION_SATISFIED_KHR;
3517
3518    /* The EGL_KHR_fence_sync spec states:
3519     *
3520     *    "If no context is current for the bound API,
3521     *     the EGL_SYNC_FLUSH_COMMANDS_BIT_KHR bit is ignored.
3522     */
3523    if (dri2_ctx && flags & EGL_SYNC_FLUSH_COMMANDS_BIT_KHR)
3524       wait_flags |= __DRI2_FENCE_FLAG_FLUSH_COMMANDS;
3525
3526    /* the sync object should take a reference while waiting */
3527    dri2_egl_ref_sync(dri2_sync);
3528
3529    switch (sync->Type) {
3530    case EGL_SYNC_FENCE_KHR:
3531    case EGL_SYNC_NATIVE_FENCE_ANDROID:
3532    case EGL_SYNC_CL_EVENT_KHR:
3533       if (dri2_dpy->fence->client_wait_sync(dri2_ctx ? dri2_ctx->dri_context : NULL,
3534                                          dri2_sync->fence, wait_flags,
3535                                          timeout))
3536          dri2_sync->base.SyncStatus = EGL_SIGNALED_KHR;
3537       else
3538          ret = EGL_TIMEOUT_EXPIRED_KHR;
3539       break;
3540
3541    case EGL_SYNC_REUSABLE_KHR:
3542       if (dri2_ctx && dri2_sync->base.SyncStatus == EGL_UNSIGNALED_KHR &&
3543           (flags & EGL_SYNC_FLUSH_COMMANDS_BIT_KHR)) {
3544          /* flush context if EGL_SYNC_FLUSH_COMMANDS_BIT_KHR is set */
3545          dri2_gl_flush();
3546       }
3547
3548       /* if timeout is EGL_FOREVER_KHR, it should wait without any timeout.*/
3549       if (timeout == EGL_FOREVER_KHR) {
3550          mtx_lock(&dri2_sync->mutex);
3551          cnd_wait(&dri2_sync->cond, &dri2_sync->mutex);
3552          mtx_unlock(&dri2_sync->mutex);
3553       } else {
3554          /* if reusable sync has not been yet signaled */
3555          if (dri2_sync->base.SyncStatus != EGL_SIGNALED_KHR) {
3556             /* timespecs for cnd_timedwait */
3557             struct timespec current;
3558             struct timespec expire;
3559
3560             /* We override the clock to monotonic when creating the condition
3561              * variable. */
3562             clock_gettime(CLOCK_MONOTONIC, &current);
3563
3564             /* calculating when to expire */
3565             expire.tv_nsec = timeout % 1000000000L;
3566             expire.tv_sec = timeout / 1000000000L;
3567
3568             expire.tv_nsec += current.tv_nsec;
3569             expire.tv_sec += current.tv_sec;
3570
3571             /* expire.nsec now is a number between 0 and 1999999998 */
3572             if (expire.tv_nsec > 999999999L) {
3573                expire.tv_sec++;
3574                expire.tv_nsec -= 1000000000L;
3575             }
3576
3577             mtx_lock(&dri2_sync->mutex);
3578             ret = cnd_timedwait(&dri2_sync->cond, &dri2_sync->mutex, &expire);
3579             mtx_unlock(&dri2_sync->mutex);
3580
3581             if (ret == thrd_busy) {
3582                if (dri2_sync->base.SyncStatus == EGL_UNSIGNALED_KHR) {
3583                   ret = EGL_TIMEOUT_EXPIRED_KHR;
3584                } else {
3585                   _eglError(EGL_BAD_ACCESS, "eglClientWaitSyncKHR");
3586                   ret = EGL_FALSE;
3587                }
3588             }
3589          }
3590       }
3591       break;
3592   }
3593   dri2_egl_unref_sync(dri2_dpy, dri2_sync);
3594
3595   return ret;
3596 }
3597
3598 static EGLBoolean
3599 dri2_signal_sync(_EGLDisplay *disp, _EGLSync *sync, EGLenum mode)
3600 {
3601    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
3602    EGLint ret;
3603
3604    if (sync->Type != EGL_SYNC_REUSABLE_KHR)
3605       return _eglError(EGL_BAD_MATCH, "eglSignalSyncKHR");
3606
3607    if (mode != EGL_SIGNALED_KHR && mode != EGL_UNSIGNALED_KHR)
3608       return _eglError(EGL_BAD_ATTRIBUTE, "eglSignalSyncKHR");
3609
3610    dri2_sync->base.SyncStatus = mode;
3611
3612    if (mode == EGL_SIGNALED_KHR) {
3613       ret = cnd_broadcast(&dri2_sync->cond);
3614
3615       /* fail to broadcast */
3616       if (ret)
3617          return _eglError(EGL_BAD_ACCESS, "eglSignalSyncKHR");
3618    }
3619
3620    return EGL_TRUE;
3621 }
3622
3623 static EGLint
3624 dri2_server_wait_sync(_EGLDisplay *disp, _EGLSync *sync)
3625 {
3626    _EGLContext *ctx = _eglGetCurrentContext();
3627    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3628    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
3629    struct dri2_egl_sync *dri2_sync = dri2_egl_sync(sync);
3630
3631    dri2_dpy->fence->server_wait_sync(dri2_ctx->dri_context,
3632                                      dri2_sync->fence, 0);
3633    return EGL_TRUE;
3634 }
3635
3636 static int
3637 dri2_interop_query_device_info(_EGLDisplay *disp, _EGLContext *ctx,
3638                                struct mesa_glinterop_device_info *out)
3639 {
3640    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3641    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
3642
3643    if (!dri2_dpy->interop)
3644       return MESA_GLINTEROP_UNSUPPORTED;
3645
3646    return dri2_dpy->interop->query_device_info(dri2_ctx->dri_context, out);
3647 }
3648
3649 static int
3650 dri2_interop_export_object(_EGLDisplay *disp, _EGLContext *ctx,
3651                            struct mesa_glinterop_export_in *in,
3652                            struct mesa_glinterop_export_out *out)
3653 {
3654    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
3655    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
3656
3657    if (!dri2_dpy->interop)
3658       return MESA_GLINTEROP_UNSUPPORTED;
3659
3660    return dri2_dpy->interop->export_object(dri2_ctx->dri_context, in, out);
3661 }
3662
3663 const _EGLDriver _eglDriver = {
3664    .Initialize = dri2_initialize,
3665    .Terminate = dri2_terminate,
3666    .CreateContext = dri2_create_context,
3667    .DestroyContext = dri2_destroy_context,
3668    .MakeCurrent = dri2_make_current,
3669    .CreateWindowSurface = dri2_create_window_surface,
3670    .CreatePixmapSurface = dri2_create_pixmap_surface,
3671    .CreatePbufferSurface = dri2_create_pbuffer_surface,
3672    .DestroySurface = dri2_destroy_surface,
3673    .GetProcAddress = dri2_get_proc_address,
3674    .WaitClient = dri2_wait_client,
3675    .WaitNative = dri2_wait_native,
3676    .BindTexImage = dri2_bind_tex_image,
3677    .ReleaseTexImage = dri2_release_tex_image,
3678    .SwapInterval = dri2_swap_interval,
3679    .SwapBuffers = dri2_swap_buffers,
3680    .SwapBuffersWithDamageEXT = dri2_swap_buffers_with_damage,
3681    .SwapBuffersRegionNOK = dri2_swap_buffers_region,
3682    .SetDamageRegion = dri2_set_damage_region,
3683    .PostSubBufferNV = dri2_post_sub_buffer,
3684    .CopyBuffers = dri2_copy_buffers,
3685    .QueryBufferAge = dri2_query_buffer_age,
3686    .CreateImageKHR = dri2_create_image,
3687    .DestroyImageKHR = dri2_destroy_image_khr,
3688    .CreateWaylandBufferFromImageWL = dri2_create_wayland_buffer_from_image,
3689    .QuerySurface = dri2_query_surface,
3690    .QueryDriverName = dri2_query_driver_name,
3691    .QueryDriverConfig = dri2_query_driver_config,
3692 #ifdef HAVE_LIBDRM
3693    .CreateDRMImageMESA = dri2_create_drm_image_mesa,
3694    .ExportDRMImageMESA = dri2_export_drm_image_mesa,
3695    .ExportDMABUFImageQueryMESA = dri2_export_dma_buf_image_query_mesa,
3696    .ExportDMABUFImageMESA = dri2_export_dma_buf_image_mesa,
3697    .QueryDmaBufFormatsEXT = dri2_query_dma_buf_formats,
3698    .QueryDmaBufModifiersEXT = dri2_query_dma_buf_modifiers,
3699 #endif
3700 #ifdef HAVE_WAYLAND_PLATFORM
3701    .BindWaylandDisplayWL = dri2_bind_wayland_display_wl,
3702    .UnbindWaylandDisplayWL = dri2_unbind_wayland_display_wl,
3703    .QueryWaylandBufferWL = dri2_query_wayland_buffer_wl,
3704 #endif
3705    .GetSyncValuesCHROMIUM = dri2_get_sync_values_chromium,
3706    .CreateSyncKHR = dri2_create_sync,
3707    .ClientWaitSyncKHR = dri2_client_wait_sync,
3708    .SignalSyncKHR = dri2_signal_sync,
3709    .WaitSyncKHR = dri2_server_wait_sync,
3710    .DestroySyncKHR = dri2_destroy_sync,
3711    .GLInteropQueryDeviceInfo = dri2_interop_query_device_info,
3712    .GLInteropExportObject = dri2_interop_export_object,
3713    .DupNativeFenceFDANDROID = dri2_dup_native_fence_fd,
3714    .SetBlobCacheFuncsANDROID = dri2_set_blob_cache_funcs,
3715 };