src/egl/main/eglapi.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   4  * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
   5  * Copyright 2010-2011 LunarG, Inc.
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26  * DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30
  31 /**
  32  * Public EGL API entrypoints
  33  *
  34  * Generally, we use the EGLDisplay parameter as a key to lookup the
  35  * appropriate device driver handle, then jump though the driver's
  36  * dispatch table to handle the function.
  37  *
  38  * That allows us the option of supporting multiple, simultaneous,
  39  * heterogeneous hardware devices in the future.
  40  *
  41  * The EGLDisplay, EGLConfig, EGLContext and EGLSurface types are
  42  * opaque handles. Internal objects are linked to a display to
  43  * create the handles.
  44  *
  45  * For each public API entry point, the opaque handles are looked up
  46  * before being dispatched to the drivers.  When it fails to look up
  47  * a handle, one of
  48  *
  49  * EGL_BAD_DISPLAY
  50  * EGL_BAD_CONFIG
  51  * EGL_BAD_CONTEXT
  52  * EGL_BAD_SURFACE
  53  * EGL_BAD_SCREEN_MESA
  54  * EGL_BAD_MODE_MESA
  55  *
  56  * is generated and the driver function is not called. An
  57  * uninitialized EGLDisplay has no driver associated with it. When
  58  * such display is detected,
  59  *
  60  * EGL_NOT_INITIALIZED
  61  *
  62  * is generated.
  63  *
  64  * Some of the entry points use current display, context, or surface
  65  * implicitly.  For such entry points, the implicit objects are also
  66  * checked before calling the driver function.  Other than the
  67  * errors listed above,
  68  *
  69  * EGL_BAD_CURRENT_SURFACE
  70  *
  71  * may also be generated.
  72  *
  73  * Notes on naming conventions:
  74  *
  75  * eglFooBar    - public EGL function
  76  * EGL_FOO_BAR  - public EGL token
  77  * EGLDatatype  - public EGL datatype
  78  *
  79  * _eglFooBar   - private EGL function
  80  * _EGLDatatype - private EGL datatype, typedef'd struct
  81  * _egl_struct  - private EGL struct, non-typedef'd
  82  *
  83  */
  84
  85
  86 #include <stdio.h>
  87 #include <stdlib.h>
  88 #include <string.h>
  89 #include "c99_compat.h"
  90 #include "c11/threads.h"
  91 #include "eglcompiler.h"
  92
  93 #include "eglglobals.h"
  94 #include "eglcontext.h"
  95 #include "egldisplay.h"
  96 #include "egltypedefs.h"
  97 #include "eglcurrent.h"
  98 #include "egldriver.h"
  99 #include "eglsurface.h"
 100 #include "eglconfig.h"
 101 #include "eglscreen.h"
 102 #include "eglmode.h"
 103 #include "eglimage.h"
 104 #include "eglsync.h"
 105 #include "eglstring.h"
 106
 107
 108 /**
 109  * Macros to help return an API entrypoint.
 110  *
 111  * These macros will unlock the display and record the error code.
 112  */
 113 #define RETURN_EGL_ERROR(disp, err, ret)        \
 114    do {                                         \
 115       if (disp)                                 \
 116          _eglUnlockDisplay(disp);               \
 117       /* EGL error codes are non-zero */        \
 118       if (err)                                  \
 119          _eglError(err, __func__);              \
 120       return ret;                               \
 121    } while (0)
 122
 123 #define RETURN_EGL_SUCCESS(disp, ret) \
 124    RETURN_EGL_ERROR(disp, EGL_SUCCESS, ret)
 125
 126 /* record EGL_SUCCESS only when ret evaluates to true */
 127 #define RETURN_EGL_EVAL(disp, ret) \
 128    RETURN_EGL_ERROR(disp, (ret) ? EGL_SUCCESS : 0, ret)
 129
 130
 131 /*
 132  * A bunch of macros and checks to simplify error checking.
 133  */
 134
 135 #define _EGL_CHECK_DISPLAY(disp, ret, drv)         \
 136    do {                                            \
 137       drv = _eglCheckDisplay(disp, __func__);      \
 138       if (!drv)                                    \
 139          RETURN_EGL_ERROR(disp, 0, ret);           \
 140    } while (0)
 141
 142 #define _EGL_CHECK_OBJECT(disp, type, obj, ret, drv)      \
 143    do {                                                   \
 144       drv = _eglCheck ## type(disp, obj, __func__);       \
 145       if (!drv)                                           \
 146          RETURN_EGL_ERROR(disp, 0, ret);                  \
 147    } while (0)
 148
 149 #define _EGL_CHECK_SURFACE(disp, surf, ret, drv) \
 150    _EGL_CHECK_OBJECT(disp, Surface, surf, ret, drv)
 151
 152 #define _EGL_CHECK_CONTEXT(disp, context, ret, drv) \
 153    _EGL_CHECK_OBJECT(disp, Context, context, ret, drv)
 154
 155 #define _EGL_CHECK_CONFIG(disp, conf, ret, drv) \
 156    _EGL_CHECK_OBJECT(disp, Config, conf, ret, drv)
 157
 158 #define _EGL_CHECK_SCREEN(disp, scrn, ret, drv) \
 159    _EGL_CHECK_OBJECT(disp, Screen, scrn, ret, drv)
 160
 161 #define _EGL_CHECK_MODE(disp, m, ret, drv) \
 162    _EGL_CHECK_OBJECT(disp, Mode, m, ret, drv)
 163
 164 #define _EGL_CHECK_SYNC(disp, s, ret, drv) \
 165    _EGL_CHECK_OBJECT(disp, Sync, s, ret, drv)
 166
 167
 168 static inline _EGLDriver *
 169 _eglCheckDisplay(_EGLDisplay *disp, const char *msg)
 170 {
 171    if (!disp) {
 172       _eglError(EGL_BAD_DISPLAY, msg);
 173       return NULL;
 174    }
 175    if (!disp->Initialized) {
 176       _eglError(EGL_NOT_INITIALIZED, msg);
 177       return NULL;
 178    }
 179    return disp->Driver;
 180 }
 181
 182
 183 static inline _EGLDriver *
 184 _eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
 185 {
 186    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 187    if (!drv)
 188       return NULL;
 189    if (!surf) {
 190       _eglError(EGL_BAD_SURFACE, msg);
 191       return NULL;
 192    }
 193    return drv;
 194 }
 195
 196
 197 static inline _EGLDriver *
 198 _eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
 199 {
 200    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 201    if (!drv)
 202       return NULL;
 203    if (!context) {
 204       _eglError(EGL_BAD_CONTEXT, msg);
 205       return NULL;
 206    }
 207    return drv;
 208 }
 209
 210
 211 static inline _EGLDriver *
 212 _eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
 213 {
 214    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 215    if (!drv)
 216       return NULL;
 217    if (!conf) {
 218       _eglError(EGL_BAD_CONFIG, msg);
 219       return NULL;
 220    }
 221    return drv;
 222 }
 223
 224
 225 static inline _EGLDriver *
 226 _eglCheckSync(_EGLDisplay *disp, _EGLSync *s, const char *msg)
 227 {
 228    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 229    if (!drv)
 230       return NULL;
 231    if (!s) {
 232       _eglError(EGL_BAD_PARAMETER, msg);
 233       return NULL;
 234    }
 235    return drv;
 236 }
 237
 238
 239 #ifdef EGL_MESA_screen_surface
 240
 241
 242 static inline _EGLDriver *
 243 _eglCheckScreen(_EGLDisplay *disp, _EGLScreen *scrn, const char *msg)
 244 {
 245    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 246    if (!drv)
 247       return NULL;
 248    if (!scrn) {
 249       _eglError(EGL_BAD_SCREEN_MESA, msg);
 250       return NULL;
 251    }
 252    return drv;
 253 }
 254
 255
 256 static inline _EGLDriver *
 257 _eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
 258 {
 259    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 260    if (!drv)
 261       return NULL;
 262    if (!m) {
 263       _eglError(EGL_BAD_MODE_MESA, msg);
 264       return NULL;
 265    }
 266    return drv;
 267 }
 268
 269
 270 #endif /* EGL_MESA_screen_surface */
 271
 272
 273 /**
 274  * Lookup and lock a display.
 275  */
 276 static inline _EGLDisplay *
 277 _eglLockDisplay(EGLDisplay display)
 278 {
 279    _EGLDisplay *dpy = _eglLookupDisplay(display);
 280    if (dpy)
 281       mtx_lock(&dpy->Mutex);
 282    return dpy;
 283 }
 284
 285
 286 /**
 287  * Unlock a display.
 288  */
 289 static inline void
 290 _eglUnlockDisplay(_EGLDisplay *dpy)
 291 {
 292    mtx_unlock(&dpy->Mutex);
 293 }
 294
 295
 296 /**
 297  * This is typically the first EGL function that an application calls.
 298  * It associates a private _EGLDisplay object to the native display.
 299  */
 300 EGLDisplay EGLAPIENTRY
 301 eglGetDisplay(EGLNativeDisplayType nativeDisplay)
 302 {
 303    _EGLPlatformType plat;
 304    _EGLDisplay *dpy;
 305    void *native_display_ptr;
 306
 307    STATIC_ASSERT(sizeof(void*) == sizeof(nativeDisplay));
 308    native_display_ptr = (void*) nativeDisplay;
 309
 310    plat = _eglGetNativePlatform(native_display_ptr);
 311    dpy = _eglFindDisplay(plat, native_display_ptr);
 312    return _eglGetDisplayHandle(dpy);
 313 }
 314
 315 EGLDisplay EGLAPIENTRY
 316 eglGetPlatformDisplayEXT(EGLenum platform, void *native_display,
 317                          const EGLint *attrib_list)
 318 {
 319    _EGLDisplay *dpy;
 320
 321    switch (platform) {
 322 #ifdef HAVE_X11_PLATFORM
 323    case EGL_PLATFORM_X11_EXT:
 324       dpy = _eglGetX11Display((Display*) native_display, attrib_list);
 325       break;
 326 #endif
 327 #ifdef HAVE_DRM_PLATFORM
 328    case EGL_PLATFORM_GBM_MESA:
 329       dpy = _eglGetGbmDisplay((struct gbm_device*) native_display,
 330                               attrib_list);
 331       break;
 332 #endif
 333 #ifdef HAVE_WAYLAND_PLATFORM
 334    case EGL_PLATFORM_WAYLAND_EXT:
 335       dpy = _eglGetWaylandDisplay((struct wl_display*) native_display,
 336                                   attrib_list);
 337       break;
 338 #endif
 339    default:
 340       RETURN_EGL_ERROR(NULL, EGL_BAD_PARAMETER, NULL);
 341    }
 342
 343    return _eglGetDisplayHandle(dpy);
 344 }
 345
 346 /**
 347  * Copy the extension into the string and update the string pointer.
 348  */
 349 static EGLint
 350 _eglAppendExtension(char **str, const char *ext)
 351 {
 352    char *s = *str;
 353    size_t len = strlen(ext);
 354
 355    if (s) {
 356       memcpy(s, ext, len);
 357       s[len++] = ' ';
 358       s[len] = '\0';
 359
 360       *str += len;
 361    }
 362    else {
 363       len++;
 364    }
 365
 366    return (EGLint) len;
 367 }
 368
 369 /**
 370  * Examine the individual extension enable/disable flags and recompute
 371  * the driver's Extensions string.
 372  */
 373 static void
 374 _eglCreateExtensionsString(_EGLDisplay *dpy)
 375 {
 376 #define _EGL_CHECK_EXTENSION(ext)                                          \
 377    do {                                                                    \
 378       if (dpy->Extensions.ext) {                                           \
 379          _eglAppendExtension(&exts, "EGL_" #ext);                          \
 380          assert(exts <= dpy->ExtensionsString + _EGL_MAX_EXTENSIONS_LEN);  \
 381       }                                                                    \
 382    } while (0)
 383
 384    char *exts = dpy->ExtensionsString;
 385
 386    _EGL_CHECK_EXTENSION(MESA_screen_surface);
 387    _EGL_CHECK_EXTENSION(MESA_copy_context);
 388    _EGL_CHECK_EXTENSION(MESA_drm_display);
 389    _EGL_CHECK_EXTENSION(MESA_drm_image);
 390    _EGL_CHECK_EXTENSION(MESA_configless_context);
 391
 392    _EGL_CHECK_EXTENSION(WL_bind_wayland_display);
 393    _EGL_CHECK_EXTENSION(WL_create_wayland_buffer_from_image);
 394
 395    _EGL_CHECK_EXTENSION(KHR_image_base);
 396    _EGL_CHECK_EXTENSION(KHR_image_pixmap);
 397    if (dpy->Extensions.KHR_image_base && dpy->Extensions.KHR_image_pixmap)
 398       _eglAppendExtension(&exts, "EGL_KHR_image");
 399
 400    _EGL_CHECK_EXTENSION(KHR_vg_parent_image);
 401    _EGL_CHECK_EXTENSION(KHR_get_all_proc_addresses);
 402    _EGL_CHECK_EXTENSION(KHR_gl_texture_2D_image);
 403    _EGL_CHECK_EXTENSION(KHR_gl_texture_cubemap_image);
 404    _EGL_CHECK_EXTENSION(KHR_gl_texture_3D_image);
 405    _EGL_CHECK_EXTENSION(KHR_gl_renderbuffer_image);
 406
 407    _EGL_CHECK_EXTENSION(KHR_reusable_sync);
 408    _EGL_CHECK_EXTENSION(KHR_fence_sync);
 409
 410    _EGL_CHECK_EXTENSION(KHR_surfaceless_context);
 411    _EGL_CHECK_EXTENSION(KHR_create_context);
 412
 413    _EGL_CHECK_EXTENSION(NOK_swap_region);
 414    _EGL_CHECK_EXTENSION(NOK_texture_from_pixmap);
 415
 416    _EGL_CHECK_EXTENSION(ANDROID_image_native_buffer);
 417
 418    _EGL_CHECK_EXTENSION(CHROMIUM_sync_control);
 419
 420    _EGL_CHECK_EXTENSION(EXT_create_context_robustness);
 421    _EGL_CHECK_EXTENSION(EXT_buffer_age);
 422    _EGL_CHECK_EXTENSION(EXT_swap_buffers_with_damage);
 423    _EGL_CHECK_EXTENSION(EXT_image_dma_buf_import);
 424
 425    _EGL_CHECK_EXTENSION(NV_post_sub_buffer);
 426 #undef _EGL_CHECK_EXTENSION
 427 }
 428
 429 static void
 430 _eglCreateAPIsString(_EGLDisplay *dpy)
 431 {
 432    if (dpy->ClientAPIs & EGL_OPENGL_BIT)
 433       strcat(dpy->ClientAPIsString, "OpenGL ");
 434
 435    if (dpy->ClientAPIs & EGL_OPENGL_ES_BIT)
 436       strcat(dpy->ClientAPIsString, "OpenGL_ES ");
 437
 438    if (dpy->ClientAPIs & EGL_OPENGL_ES2_BIT)
 439       strcat(dpy->ClientAPIsString, "OpenGL_ES2 ");
 440
 441    if (dpy->ClientAPIs & EGL_OPENGL_ES3_BIT_KHR)
 442       strcat(dpy->ClientAPIsString, "OpenGL_ES3 ");
 443
 444    if (dpy->ClientAPIs & EGL_OPENVG_BIT)
 445       strcat(dpy->ClientAPIsString, "OpenVG ");
 446
 447    assert(strlen(dpy->ClientAPIsString) < sizeof(dpy->ClientAPIsString));
 448 }
 449
 450
 451 /**
 452  * This is typically the second EGL function that an application calls.
 453  * Here we load/initialize the actual hardware driver.
 454  */
 455 EGLBoolean EGLAPIENTRY
 456 eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 457 {
 458    _EGLDisplay *disp = _eglLockDisplay(dpy);
 459
 460    if (!disp)
 461       RETURN_EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
 462
 463    if (!disp->Initialized) {
 464       if (!_eglMatchDriver(disp, EGL_FALSE))
 465          RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
 466
 467       /* limit to APIs supported by core */
 468       disp->ClientAPIs &= _EGL_API_ALL_BITS;
 469
 470       /* EGL_KHR_get_all_proc_addresses is a corner-case extension. The spec
 471        * classifies it as an EGL display extension, though conceptually it's an
 472        * EGL client extension.
 473        *
 474        * From the EGL_KHR_get_all_proc_addresses spec:
 475        *
 476        *    The EGL implementation must expose the name
 477        *    EGL_KHR_client_get_all_proc_addresses if and only if it exposes
 478        *    EGL_KHR_get_all_proc_addresses and supports
 479        *    EGL_EXT_client_extensions.
 480        *
 481        * Mesa unconditionally exposes both client extensions mentioned above,
 482        * so the spec requires that each EGLDisplay unconditionally expose
 483        * EGL_KHR_get_all_proc_addresses also.
 484        */
 485       disp->Extensions.KHR_get_all_proc_addresses = EGL_TRUE;
 486
 487       _eglCreateExtensionsString(disp);
 488       _eglCreateAPIsString(disp);
 489       _eglsnprintf(disp->VersionString, sizeof(disp->VersionString),
 490               "%d.%d (%s)", disp->VersionMajor, disp->VersionMinor,
 491               disp->Driver->Name);
 492    }
 493
 494    /* Update applications version of major and minor if not NULL */
 495    if ((major != NULL) && (minor != NULL)) {
 496       *major = disp->VersionMajor;
 497       *minor = disp->VersionMinor;
 498    }
 499
 500    RETURN_EGL_SUCCESS(disp, EGL_TRUE);
 501 }
 502
 503
 504 EGLBoolean EGLAPIENTRY
 505 eglTerminate(EGLDisplay dpy)
 506 {
 507    _EGLDisplay *disp = _eglLockDisplay(dpy);
 508
 509    if (!disp)
 510       RETURN_EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
 511
 512    if (disp->Initialized) {
 513       _EGLDriver *drv = disp->Driver;
 514
 515       drv->API.Terminate(drv, disp);
 516       /* do not reset disp->Driver */
 517       disp->Initialized = EGL_FALSE;
 518    }
 519
 520    RETURN_EGL_SUCCESS(disp, EGL_TRUE);
 521 }
 522
 523
 524 const char * EGLAPIENTRY
 525 eglQueryString(EGLDisplay dpy, EGLint name)
 526 {
 527    _EGLDisplay *disp;
 528    _EGLDriver *drv;
 529    const char *ret;
 530
 531    if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) {
 532       RETURN_EGL_SUCCESS(NULL, _eglGlobal.ClientExtensionString);
 533    }
 534
 535    disp = _eglLockDisplay(dpy);
 536    _EGL_CHECK_DISPLAY(disp, NULL, drv);
 537    ret = drv->API.QueryString(drv, disp, name);
 538
 539    RETURN_EGL_EVAL(disp, ret);
 540 }
 541
 542
 543 EGLBoolean EGLAPIENTRY
 544 eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
 545               EGLint config_size, EGLint *num_config)
 546 {
 547    _EGLDisplay *disp = _eglLockDisplay(dpy);
 548    _EGLDriver *drv;
 549    EGLBoolean ret;
 550
 551    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
 552    ret = drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
 553
 554    RETURN_EGL_EVAL(disp, ret);
 555 }
 556
 557
 558 EGLBoolean EGLAPIENTRY
 559 eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
 560                 EGLint config_size, EGLint *num_config)
 561 {
 562    _EGLDisplay *disp = _eglLockDisplay(dpy);
 563    _EGLDriver *drv;
 564    EGLBoolean ret;
 565
 566    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
 567    ret = drv->API.ChooseConfig(drv, disp, attrib_list, configs,
 568                                 config_size, num_config);
 569
 570    RETURN_EGL_EVAL(disp, ret);
 571 }
 572
 573
 574 EGLBoolean EGLAPIENTRY
 575 eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
 576                    EGLint attribute, EGLint *value)
 577 {
 578    _EGLDisplay *disp = _eglLockDisplay(dpy);
 579    _EGLConfig *conf = _eglLookupConfig(config, disp);
 580    _EGLDriver *drv;
 581    EGLBoolean ret;
 582
 583    _EGL_CHECK_CONFIG(disp, conf, EGL_FALSE, drv);
 584    ret = drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
 585
 586    RETURN_EGL_EVAL(disp, ret);
 587 }
 588
 589
 590 EGLContext EGLAPIENTRY
 591 eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
 592                  const EGLint *attrib_list)
 593 {
 594    _EGLDisplay *disp = _eglLockDisplay(dpy);
 595    _EGLConfig *conf = _eglLookupConfig(config, disp);
 596    _EGLContext *share = _eglLookupContext(share_list, disp);
 597    _EGLDriver *drv;
 598    _EGLContext *context;
 599    EGLContext ret;
 600
 601    _EGL_CHECK_DISPLAY(disp, EGL_NO_CONTEXT, drv);
 602
 603    if (!config && !disp->Extensions.MESA_configless_context)
 604       RETURN_EGL_ERROR(disp, EGL_BAD_CONFIG, EGL_NO_CONTEXT);
 605
 606    if (!share && share_list != EGL_NO_CONTEXT)
 607       RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
 608
 609    context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
 610    ret = (context) ? _eglLinkContext(context) : EGL_NO_CONTEXT;
 611
 612    RETURN_EGL_EVAL(disp, ret);
 613 }
 614
 615
 616 EGLBoolean EGLAPIENTRY
 617 eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 618 {
 619    _EGLDisplay *disp = _eglLockDisplay(dpy);
 620    _EGLContext *context = _eglLookupContext(ctx, disp);
 621    _EGLDriver *drv;
 622    EGLBoolean ret;
 623
 624    _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
 625    _eglUnlinkContext(context);
 626    ret = drv->API.DestroyContext(drv, disp, context);
 627
 628    RETURN_EGL_EVAL(disp, ret);
 629 }
 630
 631
 632 EGLBoolean EGLAPIENTRY
 633 eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
 634                EGLContext ctx)
 635 {
 636    _EGLDisplay *disp = _eglLockDisplay(dpy);
 637    _EGLContext *context = _eglLookupContext(ctx, disp);
 638    _EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
 639    _EGLSurface *read_surf = _eglLookupSurface(read, disp);
 640    _EGLDriver *drv;
 641    EGLBoolean ret;
 642
 643    if (!disp)
 644       RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
 645    drv = disp->Driver;
 646
 647    /* display is allowed to be uninitialized under certain condition */
 648    if (!disp->Initialized) {
 649       if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE ||
 650           ctx != EGL_NO_CONTEXT)
 651          RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
 652    }
 653    if (!drv)
 654       RETURN_EGL_SUCCESS(disp, EGL_TRUE);
 655
 656    if (!context && ctx != EGL_NO_CONTEXT)
 657       RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
 658    if (!draw_surf || !read_surf) {
 659       /* From the EGL 1.4 (20130211) spec:
 660        *
 661        *    To release the current context without assigning a new one, set ctx
 662        *    to EGL_NO_CONTEXT and set draw and read to EGL_NO_SURFACE.
 663        */
 664       if (!disp->Extensions.KHR_surfaceless_context && ctx != EGL_NO_CONTEXT)
 665          RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 666
 667       if ((!draw_surf && draw != EGL_NO_SURFACE) ||
 668           (!read_surf && read != EGL_NO_SURFACE))
 669          RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 670       if (draw_surf || read_surf)
 671          RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_FALSE);
 672    }
 673
 674    ret = drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
 675
 676    RETURN_EGL_EVAL(disp, ret);
 677 }
 678
 679
 680 EGLBoolean EGLAPIENTRY
 681 eglQueryContext(EGLDisplay dpy, EGLContext ctx,
 682                 EGLint attribute, EGLint *value)
 683 {
 684    _EGLDisplay *disp = _eglLockDisplay(dpy);
 685    _EGLContext *context = _eglLookupContext(ctx, disp);
 686    _EGLDriver *drv;
 687    EGLBoolean ret;
 688
 689    _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
 690    ret = drv->API.QueryContext(drv, disp, context, attribute, value);
 691
 692    RETURN_EGL_EVAL(disp, ret);
 693 }
 694
 695
 696 static EGLSurface
 697 _eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
 698                               void *native_window, const EGLint *attrib_list)
 699 {
 700    _EGLConfig *conf = _eglLookupConfig(config, disp);
 701    _EGLDriver *drv;
 702    _EGLSurface *surf;
 703    EGLSurface ret;
 704
 705    _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
 706
 707    if (native_window == NULL)
 708       RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
 709
 710    surf = drv->API.CreateWindowSurface(drv, disp, conf, native_window,
 711                                        attrib_list);
 712    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
 713
 714    RETURN_EGL_EVAL(disp, ret);
 715 }
 716
 717
 718 EGLSurface EGLAPIENTRY
 719 eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
 720                        EGLNativeWindowType window, const EGLint *attrib_list)
 721 {
 722    _EGLDisplay *disp = _eglLockDisplay(dpy);
 723    STATIC_ASSERT(sizeof(void*) == sizeof(window));
 724    return _eglCreateWindowSurfaceCommon(disp, config, (void*) window,
 725                                         attrib_list);
 726 }
 727
 728
 729 EGLSurface EGLAPIENTRY
 730 eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config,
 731                                   void *native_window,
 732                                   const EGLint *attrib_list)
 733 {
 734    _EGLDisplay *disp = _eglLockDisplay(dpy);
 735
 736 #ifdef HAVE_X11_PLATFORM
 737    if (disp->Platform == _EGL_PLATFORM_X11 && native_window != NULL) {
 738       /* The `native_window` parameter for the X11 platform differs between
 739        * eglCreateWindowSurface() and eglCreatePlatformPixmapSurfaceEXT(). In
 740        * eglCreateWindowSurface(), the type of `native_window` is an Xlib
 741        * `Window`. In eglCreatePlatformWindowSurfaceEXT(), the type is
 742        * `Window*`.  Convert `Window*` to `Window` because that's what
 743        * dri2_x11_create_window_surface() expects.
 744        */
 745       native_window = (void*) (* (Window*) native_window);
 746    }
 747 #endif
 748
 749    return _eglCreateWindowSurfaceCommon(disp, config, native_window,
 750                                         attrib_list);
 751 }
 752
 753
 754 static EGLSurface
 755 _eglCreatePixmapSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
 756                               void *native_pixmap, const EGLint *attrib_list)
 757 {
 758    _EGLConfig *conf = _eglLookupConfig(config, disp);
 759    _EGLDriver *drv;
 760    _EGLSurface *surf;
 761    EGLSurface ret;
 762
 763    _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
 764    surf = drv->API.CreatePixmapSurface(drv, disp, conf, native_pixmap,
 765                                        attrib_list);
 766    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
 767
 768    RETURN_EGL_EVAL(disp, ret);
 769 }
 770
 771
 772 EGLSurface EGLAPIENTRY
 773 eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
 774                        EGLNativePixmapType pixmap, const EGLint *attrib_list)
 775 {
 776    _EGLDisplay *disp = _eglLockDisplay(dpy);
 777    STATIC_ASSERT(sizeof(void*) == sizeof(pixmap));
 778    return _eglCreatePixmapSurfaceCommon(disp, config, (void*) pixmap,
 779                                          attrib_list);
 780 }
 781
 782 EGLSurface EGLAPIENTRY
 783 eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config,
 784                                    void *native_pixmap,
 785                                    const EGLint *attrib_list)
 786 {
 787    _EGLDisplay *disp = _eglLockDisplay(dpy);
 788
 789 #ifdef HAVE_X11_PLATFORM
 790       /* The `native_pixmap` parameter for the X11 platform differs between
 791        * eglCreatePixmapSurface() and eglCreatePlatformPixmapSurfaceEXT(). In
 792        * eglCreatePixmapSurface(), the type of `native_pixmap` is an Xlib
 793        * `Pixmap`. In eglCreatePlatformPixmapSurfaceEXT(), the type is
 794        * `Pixmap*`.  Convert `Pixmap*` to `Pixmap` because that's what
 795        * dri2_x11_create_pixmap_surface() expects.
 796        */
 797    if (disp->Platform == _EGL_PLATFORM_X11 && native_pixmap != NULL) {
 798       native_pixmap = (void*) (* (Pixmap*) native_pixmap);
 799    }
 800 #endif
 801
 802    return _eglCreatePixmapSurfaceCommon(disp, config, native_pixmap,
 803                                         attrib_list);
 804 }
 805
 806
 807 EGLSurface EGLAPIENTRY
 808 eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
 809                         const EGLint *attrib_list)
 810 {
 811    _EGLDisplay *disp = _eglLockDisplay(dpy);
 812    _EGLConfig *conf = _eglLookupConfig(config, disp);
 813    _EGLDriver *drv;
 814    _EGLSurface *surf;
 815    EGLSurface ret;
 816
 817    _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
 818
 819    surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
 820    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
 821
 822    RETURN_EGL_EVAL(disp, ret);
 823 }
 824
 825
 826 EGLBoolean EGLAPIENTRY
 827 eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 828 {
 829    _EGLDisplay *disp = _eglLockDisplay(dpy);
 830    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 831    _EGLDriver *drv;
 832    EGLBoolean ret;
 833
 834    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 835    _eglUnlinkSurface(surf);
 836    ret = drv->API.DestroySurface(drv, disp, surf);
 837
 838    RETURN_EGL_EVAL(disp, ret);
 839 }
 840
 841 EGLBoolean EGLAPIENTRY
 842 eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
 843                 EGLint attribute, EGLint *value)
 844 {
 845    _EGLDisplay *disp = _eglLockDisplay(dpy);
 846    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 847    _EGLDriver *drv;
 848    EGLBoolean ret;
 849
 850    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 851    ret = drv->API.QuerySurface(drv, disp, surf, attribute, value);
 852
 853    RETURN_EGL_EVAL(disp, ret);
 854 }
 855
 856 EGLBoolean EGLAPIENTRY
 857 eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
 858                  EGLint attribute, EGLint value)
 859 {
 860    _EGLDisplay *disp = _eglLockDisplay(dpy);
 861    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 862    _EGLDriver *drv;
 863    EGLBoolean ret;
 864
 865    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 866    ret = drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
 867
 868    RETURN_EGL_EVAL(disp, ret);
 869 }
 870
 871
 872 EGLBoolean EGLAPIENTRY
 873 eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 874 {
 875    _EGLDisplay *disp = _eglLockDisplay(dpy);
 876    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 877    _EGLDriver *drv;
 878    EGLBoolean ret;
 879
 880    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 881    ret = drv->API.BindTexImage(drv, disp, surf, buffer);
 882
 883    RETURN_EGL_EVAL(disp, ret);
 884 }
 885
 886
 887 EGLBoolean EGLAPIENTRY
 888 eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 889 {
 890    _EGLDisplay *disp = _eglLockDisplay(dpy);
 891    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 892    _EGLDriver *drv;
 893    EGLBoolean ret;
 894
 895    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 896    ret = drv->API.ReleaseTexImage(drv, disp, surf, buffer);
 897
 898    RETURN_EGL_EVAL(disp, ret);
 899 }
 900
 901
 902 EGLBoolean EGLAPIENTRY
 903 eglSwapInterval(EGLDisplay dpy, EGLint interval)
 904 {
 905    _EGLDisplay *disp = _eglLockDisplay(dpy);
 906    _EGLContext *ctx = _eglGetCurrentContext();
 907    _EGLSurface *surf;
 908    _EGLDriver *drv;
 909    EGLBoolean ret;
 910
 911    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
 912
 913    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
 914        ctx->Resource.Display != disp)
 915       RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
 916
 917    surf = ctx->DrawSurface;
 918    if (_eglGetSurfaceHandle(surf) == EGL_NO_SURFACE)
 919       RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 920
 921    ret = drv->API.SwapInterval(drv, disp, surf, interval);
 922
 923    RETURN_EGL_EVAL(disp, ret);
 924 }
 925
 926
 927 EGLBoolean EGLAPIENTRY
 928 eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 929 {
 930    _EGLContext *ctx = _eglGetCurrentContext();
 931    _EGLDisplay *disp = _eglLockDisplay(dpy);
 932    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 933    _EGLDriver *drv;
 934    EGLBoolean ret;
 935
 936    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 937
 938    /* surface must be bound to current context in EGL 1.4 */
 939    #ifndef _EGL_BUILT_IN_DRIVER_HAIKU
 940    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
 941        surf != ctx->DrawSurface)
 942       RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 943    #endif
 944
 945    ret = drv->API.SwapBuffers(drv, disp, surf);
 946
 947    RETURN_EGL_EVAL(disp, ret);
 948 }
 949
 950
 951 #ifdef EGL_EXT_swap_buffers_with_damage
 952
 953 EGLBoolean EGLAPIENTRY
 954 eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface,
 955                             EGLint *rects, EGLint n_rects)
 956 {
 957    _EGLContext *ctx = _eglGetCurrentContext();
 958    _EGLDisplay *disp = _eglLockDisplay(dpy);
 959    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 960    _EGLDriver *drv;
 961    EGLBoolean ret;
 962
 963    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 964
 965    /* surface must be bound to current context in EGL 1.4 */
 966    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
 967        surf != ctx->DrawSurface)
 968       RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 969
 970    if ((n_rects > 0 && rects == NULL) || n_rects < 0)
 971       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 972
 973    ret = drv->API.SwapBuffersWithDamageEXT(drv, disp, surf, rects, n_rects);
 974
 975    RETURN_EGL_EVAL(disp, ret);
 976 }
 977
 978 #endif /* EGL_EXT_swap_buffers_with_damage */
 979
 980 EGLBoolean EGLAPIENTRY
 981 eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
 982 {
 983    _EGLDisplay *disp = _eglLockDisplay(dpy);
 984    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 985    _EGLDriver *drv;
 986    EGLBoolean ret;
 987    void *native_pixmap_ptr;
 988
 989    STATIC_ASSERT(sizeof(void*) == sizeof(target));
 990    native_pixmap_ptr = (void*) target;
 991
 992    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
 993    if (disp->Platform != _eglGetNativePlatform(disp->PlatformDisplay))
 994       RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_FALSE);
 995    ret = drv->API.CopyBuffers(drv, disp, surf, native_pixmap_ptr);
 996
 997    RETURN_EGL_EVAL(disp, ret);
 998 }
 999
1000
1001 EGLBoolean EGLAPIENTRY
1002 eglWaitClient(void)
1003 {
1004    _EGLContext *ctx = _eglGetCurrentContext();
1005    _EGLDisplay *disp;
1006    _EGLDriver *drv;
1007    EGLBoolean ret;
1008
1009    if (!ctx)
1010       RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
1011
1012    disp = ctx->Resource.Display;
1013    mtx_lock(&disp->Mutex);
1014
1015    /* let bad current context imply bad current surface */
1016    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
1017        _eglGetSurfaceHandle(ctx->DrawSurface) == EGL_NO_SURFACE)
1018       RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
1019
1020    /* a valid current context implies an initialized current display */
1021    assert(disp->Initialized);
1022    drv = disp->Driver;
1023    ret = drv->API.WaitClient(drv, disp, ctx);
1024
1025    RETURN_EGL_EVAL(disp, ret);
1026 }
1027
1028
1029 EGLBoolean EGLAPIENTRY
1030 eglWaitGL(void)
1031 {
1032    _EGLThreadInfo *t = _eglGetCurrentThread();
1033    EGLint api_index = t->CurrentAPIIndex;
1034    EGLint es_index = _eglConvertApiToIndex(EGL_OPENGL_ES_API);
1035    EGLBoolean ret;
1036
1037    if (api_index != es_index && _eglIsCurrentThreadDummy())
1038       RETURN_EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
1039
1040    t->CurrentAPIIndex = es_index;
1041    ret = eglWaitClient();
1042    t->CurrentAPIIndex = api_index;
1043    return ret;
1044 }
1045
1046
1047 EGLBoolean EGLAPIENTRY
1048 eglWaitNative(EGLint engine)
1049 {
1050    _EGLContext *ctx = _eglGetCurrentContext();
1051    _EGLDisplay *disp;
1052    _EGLDriver *drv;
1053    EGLBoolean ret;
1054
1055    if (!ctx)
1056       RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
1057
1058    disp = ctx->Resource.Display;
1059    mtx_lock(&disp->Mutex);
1060
1061    /* let bad current context imply bad current surface */
1062    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
1063        _eglGetSurfaceHandle(ctx->DrawSurface) == EGL_NO_SURFACE)
1064       RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
1065
1066    /* a valid current context implies an initialized current display */
1067    assert(disp->Initialized);
1068    drv = disp->Driver;
1069    ret = drv->API.WaitNative(drv, disp, engine);
1070
1071    RETURN_EGL_EVAL(disp, ret);
1072 }
1073
1074
1075 EGLDisplay EGLAPIENTRY
1076 eglGetCurrentDisplay(void)
1077 {
1078    _EGLContext *ctx = _eglGetCurrentContext();
1079    EGLDisplay ret;
1080
1081    ret = (ctx) ? _eglGetDisplayHandle(ctx->Resource.Display) : EGL_NO_DISPLAY;
1082
1083    RETURN_EGL_SUCCESS(NULL, ret);
1084 }
1085
1086
1087 EGLContext EGLAPIENTRY
1088 eglGetCurrentContext(void)
1089 {
1090    _EGLContext *ctx = _eglGetCurrentContext();
1091    EGLContext ret;
1092
1093    ret = _eglGetContextHandle(ctx);
1094
1095    RETURN_EGL_SUCCESS(NULL, ret);
1096 }
1097
1098
1099 EGLSurface EGLAPIENTRY
1100 eglGetCurrentSurface(EGLint readdraw)
1101 {
1102    _EGLContext *ctx = _eglGetCurrentContext();
1103    EGLint err = EGL_SUCCESS;
1104    _EGLSurface *surf;
1105    EGLSurface ret;
1106
1107    if (!ctx)
1108       RETURN_EGL_SUCCESS(NULL, EGL_NO_SURFACE);
1109
1110    switch (readdraw) {
1111    case EGL_DRAW:
1112       surf = ctx->DrawSurface;
1113       break;
1114    case EGL_READ:
1115       surf = ctx->ReadSurface;
1116       break;
1117    default:
1118       surf = NULL;
1119       err = EGL_BAD_PARAMETER;
1120       break;
1121    }
1122
1123    ret = _eglGetSurfaceHandle(surf);
1124
1125    RETURN_EGL_ERROR(NULL, err, ret);
1126 }
1127
1128
1129 EGLint EGLAPIENTRY
1130 eglGetError(void)
1131 {
1132    _EGLThreadInfo *t = _eglGetCurrentThread();
1133    EGLint e = t->LastError;
1134    if (!_eglIsCurrentThreadDummy())
1135       t->LastError = EGL_SUCCESS;
1136    return e;
1137 }
1138
1139
1140 __eglMustCastToProperFunctionPointerType EGLAPIENTRY
1141 eglGetProcAddress(const char *procname)
1142 {
1143    static const struct {
1144       const char *name;
1145       _EGLProc function;
1146    } egl_functions[] = {
1147       /* core functions should not be queryable, but, well... */
1148 #ifdef _EGL_GET_CORE_ADDRESSES
1149       /* alphabetical order */
1150       { "eglBindAPI", (_EGLProc) eglBindAPI },
1151       { "eglBindTexImage", (_EGLProc) eglBindTexImage },
1152       { "eglChooseConfig", (_EGLProc) eglChooseConfig },
1153       { "eglCopyBuffers", (_EGLProc) eglCopyBuffers },
1154       { "eglCreateContext", (_EGLProc) eglCreateContext },
1155       { "eglCreatePbufferFromClientBuffer", (_EGLProc) eglCreatePbufferFromClientBuffer },
1156       { "eglCreatePbufferSurface", (_EGLProc) eglCreatePbufferSurface },
1157       { "eglCreatePixmapSurface", (_EGLProc) eglCreatePixmapSurface },
1158       { "eglCreateWindowSurface", (_EGLProc) eglCreateWindowSurface },
1159       { "eglDestroyContext", (_EGLProc) eglDestroyContext },
1160       { "eglDestroySurface", (_EGLProc) eglDestroySurface },
1161       { "eglGetConfigAttrib", (_EGLProc) eglGetConfigAttrib },
1162       { "eglGetConfigs", (_EGLProc) eglGetConfigs },
1163       { "eglGetCurrentContext", (_EGLProc) eglGetCurrentContext },
1164       { "eglGetCurrentDisplay", (_EGLProc) eglGetCurrentDisplay },
1165       { "eglGetCurrentSurface", (_EGLProc) eglGetCurrentSurface },
1166       { "eglGetDisplay", (_EGLProc) eglGetDisplay },
1167       { "eglGetError", (_EGLProc) eglGetError },
1168       { "eglGetProcAddress", (_EGLProc) eglGetProcAddress },
1169       { "eglInitialize", (_EGLProc) eglInitialize },
1170       { "eglMakeCurrent", (_EGLProc) eglMakeCurrent },
1171       { "eglQueryAPI", (_EGLProc) eglQueryAPI },
1172       { "eglQueryContext", (_EGLProc) eglQueryContext },
1173       { "eglQueryString", (_EGLProc) eglQueryString },
1174       { "eglQuerySurface", (_EGLProc) eglQuerySurface },
1175       { "eglReleaseTexImage", (_EGLProc) eglReleaseTexImage },
1176       { "eglReleaseThread", (_EGLProc) eglReleaseThread },
1177       { "eglSurfaceAttrib", (_EGLProc) eglSurfaceAttrib },
1178       { "eglSwapBuffers", (_EGLProc) eglSwapBuffers },
1179       { "eglSwapInterval", (_EGLProc) eglSwapInterval },
1180       { "eglTerminate", (_EGLProc) eglTerminate },
1181       { "eglWaitClient", (_EGLProc) eglWaitClient },
1182       { "eglWaitGL", (_EGLProc) eglWaitGL },
1183       { "eglWaitNative", (_EGLProc) eglWaitNative },
1184 #endif /* _EGL_GET_CORE_ADDRESSES */
1185 #ifdef EGL_MESA_screen_surface
1186       { "eglChooseModeMESA", (_EGLProc) eglChooseModeMESA },
1187       { "eglGetModesMESA", (_EGLProc) eglGetModesMESA },
1188       { "eglGetModeAttribMESA", (_EGLProc) eglGetModeAttribMESA },
1189       { "eglCopyContextMESA", (_EGLProc) eglCopyContextMESA },
1190       { "eglGetScreensMESA", (_EGLProc) eglGetScreensMESA },
1191       { "eglCreateScreenSurfaceMESA", (_EGLProc) eglCreateScreenSurfaceMESA },
1192       { "eglShowScreenSurfaceMESA", (_EGLProc) eglShowScreenSurfaceMESA },
1193       { "eglScreenPositionMESA", (_EGLProc) eglScreenPositionMESA },
1194       { "eglQueryScreenMESA", (_EGLProc) eglQueryScreenMESA },
1195       { "eglQueryScreenSurfaceMESA", (_EGLProc) eglQueryScreenSurfaceMESA },
1196       { "eglQueryScreenModeMESA", (_EGLProc) eglQueryScreenModeMESA },
1197       { "eglQueryModeStringMESA", (_EGLProc) eglQueryModeStringMESA },
1198 #endif /* EGL_MESA_screen_surface */
1199 #ifdef EGL_MESA_drm_display
1200       { "eglGetDRMDisplayMESA", (_EGLProc) eglGetDRMDisplayMESA },
1201 #endif
1202       { "eglCreateImageKHR", (_EGLProc) eglCreateImageKHR },
1203       { "eglDestroyImageKHR", (_EGLProc) eglDestroyImageKHR },
1204       { "eglCreateSyncKHR", (_EGLProc) eglCreateSyncKHR },
1205       { "eglDestroySyncKHR", (_EGLProc) eglDestroySyncKHR },
1206       { "eglClientWaitSyncKHR", (_EGLProc) eglClientWaitSyncKHR },
1207       { "eglSignalSyncKHR", (_EGLProc) eglSignalSyncKHR },
1208       { "eglGetSyncAttribKHR", (_EGLProc) eglGetSyncAttribKHR },
1209 #ifdef EGL_NOK_swap_region
1210       { "eglSwapBuffersRegionNOK", (_EGLProc) eglSwapBuffersRegionNOK },
1211 #endif
1212 #ifdef EGL_MESA_drm_image
1213       { "eglCreateDRMImageMESA", (_EGLProc) eglCreateDRMImageMESA },
1214       { "eglExportDRMImageMESA", (_EGLProc) eglExportDRMImageMESA },
1215 #endif
1216 #ifdef EGL_WL_bind_wayland_display
1217       { "eglBindWaylandDisplayWL", (_EGLProc) eglBindWaylandDisplayWL },
1218       { "eglUnbindWaylandDisplayWL", (_EGLProc) eglUnbindWaylandDisplayWL },
1219       { "eglQueryWaylandBufferWL", (_EGLProc) eglQueryWaylandBufferWL },
1220 #endif
1221 #ifdef EGL_WL_create_wayland_buffer_from_image
1222       { "eglCreateWaylandBufferFromImageWL", (_EGLProc) eglCreateWaylandBufferFromImageWL },
1223 #endif
1224       { "eglPostSubBufferNV", (_EGLProc) eglPostSubBufferNV },
1225 #ifdef EGL_EXT_swap_buffers_with_damage
1226       { "eglSwapBuffersWithDamageEXT", (_EGLProc) eglSwapBuffersWithDamageEXT },
1227 #endif
1228       { "eglGetPlatformDisplayEXT", (_EGLProc) eglGetPlatformDisplayEXT },
1229       { "eglCreatePlatformWindowSurfaceEXT", (_EGLProc) eglCreatePlatformWindowSurfaceEXT },
1230       { "eglCreatePlatformPixmapSurfaceEXT", (_EGLProc) eglCreatePlatformPixmapSurfaceEXT },
1231       { "eglGetSyncValuesCHROMIUM", (_EGLProc) eglGetSyncValuesCHROMIUM },
1232       { NULL, NULL }
1233    };
1234    EGLint i;
1235    _EGLProc ret;
1236
1237    if (!procname)
1238       RETURN_EGL_SUCCESS(NULL, NULL);
1239
1240    ret = NULL;
1241    if (strncmp(procname, "egl", 3) == 0) {
1242       for (i = 0; egl_functions[i].name; i++) {
1243          if (strcmp(egl_functions[i].name, procname) == 0) {
1244             ret = egl_functions[i].function;
1245             break;
1246          }
1247       }
1248    }
1249    if (!ret)
1250       ret = _eglGetDriverProc(procname);
1251
1252    RETURN_EGL_SUCCESS(NULL, ret);
1253 }
1254
1255
1256 #ifdef EGL_MESA_screen_surface
1257
1258
1259 /*
1260  * EGL_MESA_screen extension
1261  */
1262
1263 EGLBoolean EGLAPIENTRY
1264 eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
1265                   const EGLint *attrib_list, EGLModeMESA *modes,
1266                   EGLint modes_size, EGLint *num_modes)
1267 {
1268    _EGLDisplay *disp = _eglLockDisplay(dpy);
1269    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
1270    _EGLDriver *drv;
1271    EGLBoolean ret;
1272
1273    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1274    ret = drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
1275          modes, modes_size, num_modes);
1276
1277    RETURN_EGL_EVAL(disp, ret);
1278 }
1279
1280
1281 EGLBoolean EGLAPIENTRY
1282 eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
1283                 EGLint mode_size, EGLint *num_mode)
1284 {
1285    _EGLDisplay *disp = _eglLockDisplay(dpy);
1286    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
1287    _EGLDriver *drv;
1288    EGLBoolean ret;
1289
1290    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1291    ret = drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
1292
1293    RETURN_EGL_EVAL(disp, ret);
1294 }
1295
1296
1297 EGLBoolean EGLAPIENTRY
1298 eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
1299                      EGLint attribute, EGLint *value)
1300 {
1301    _EGLDisplay *disp = _eglLockDisplay(dpy);
1302    _EGLMode *m = _eglLookupMode(mode, disp);
1303    _EGLDriver *drv;
1304    EGLBoolean ret;
1305
1306    _EGL_CHECK_MODE(disp, m, EGL_FALSE, drv);
1307    ret = drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
1308
1309    RETURN_EGL_EVAL(disp, ret);
1310 }
1311
1312
1313 EGLBoolean EGLAPIENTRY
1314 eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
1315                    EGLint mask)
1316 {
1317    _EGLDisplay *disp = _eglLockDisplay(dpy);
1318    _EGLContext *source_context = _eglLookupContext(source, disp);
1319    _EGLContext *dest_context = _eglLookupContext(dest, disp);
1320    _EGLDriver *drv;
1321    EGLBoolean ret;
1322
1323    _EGL_CHECK_CONTEXT(disp, source_context, EGL_FALSE, drv);
1324    if (!dest_context)
1325       RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
1326
1327    ret = drv->API.CopyContextMESA(drv, disp,
1328          source_context, dest_context, mask);
1329
1330    RETURN_EGL_EVAL(disp, ret);
1331 }
1332
1333
1334 EGLBoolean EGLAPIENTRY
1335 eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
1336                   EGLint max_screens, EGLint *num_screens)
1337 {
1338    _EGLDisplay *disp = _eglLockDisplay(dpy);
1339    _EGLDriver *drv;
1340    EGLBoolean ret;
1341
1342    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
1343    ret = drv->API.GetScreensMESA(drv, disp, screens, max_screens, num_screens);
1344
1345    RETURN_EGL_EVAL(disp, ret);
1346 }
1347
1348
1349 EGLSurface EGLAPIENTRY
1350 eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
1351                            const EGLint *attrib_list)
1352 {
1353    _EGLDisplay *disp = _eglLockDisplay(dpy);
1354    _EGLConfig *conf = _eglLookupConfig(config, disp);
1355    _EGLDriver *drv;
1356    _EGLSurface *surf;
1357    EGLSurface ret;
1358
1359    _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
1360
1361    surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
1362    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
1363
1364    RETURN_EGL_EVAL(disp, ret);
1365 }
1366
1367
1368 EGLBoolean EGLAPIENTRY
1369 eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
1370                          EGLSurface surface, EGLModeMESA mode)
1371 {
1372    _EGLDisplay *disp = _eglLockDisplay(dpy);
1373    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
1374    _EGLSurface *surf = _eglLookupSurface(surface, disp);
1375    _EGLMode *m = _eglLookupMode(mode, disp);
1376    _EGLDriver *drv;
1377    EGLBoolean ret;
1378
1379    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1380    if (!surf && surface != EGL_NO_SURFACE)
1381       RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
1382    if (!m && mode != EGL_NO_MODE_MESA)
1383       RETURN_EGL_ERROR(disp, EGL_BAD_MODE_MESA, EGL_FALSE);
1384
1385    ret = drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
1386
1387    RETURN_EGL_EVAL(disp, ret);
1388 }
1389
1390
1391 EGLBoolean EGLAPIENTRY
1392 eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
1393 {
1394    _EGLDisplay *disp = _eglLockDisplay(dpy);
1395    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
1396    _EGLDriver *drv;
1397    EGLBoolean ret;
1398
1399    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1400    ret = drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
1401
1402    RETURN_EGL_EVAL(disp, ret);
1403 }
1404
1405
1406 EGLBoolean EGLAPIENTRY
1407 eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
1408                    EGLint attribute, EGLint *value)
1409 {
1410    _EGLDisplay *disp = _eglLockDisplay(dpy);
1411    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
1412    _EGLDriver *drv;
1413    EGLBoolean ret;
1414
1415    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1416    ret = drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
1417
1418    RETURN_EGL_EVAL(disp, ret);
1419 }
1420
1421
1422 EGLBoolean EGLAPIENTRY
1423 eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
1424                           EGLSurface *surface)
1425 {
1426    _EGLDisplay *disp = _eglLockDisplay(dpy);
1427    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
1428    _EGLDriver *drv;
1429    _EGLSurface *surf;
1430    EGLBoolean ret;
1431
1432    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1433    ret = drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf);
1434    if (ret && surface)
1435       *surface = _eglGetSurfaceHandle(surf);
1436
1437    RETURN_EGL_EVAL(disp, ret);
1438 }
1439
1440
1441 EGLBoolean EGLAPIENTRY
1442 eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
1443 {
1444    _EGLDisplay *disp = _eglLockDisplay(dpy);
1445    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
1446    _EGLDriver *drv;
1447    _EGLMode *m;
1448    EGLBoolean ret;
1449
1450    _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
1451    ret = drv->API.QueryScreenModeMESA(drv, disp, scrn, &m);
1452    if (ret && mode)
1453       *mode = m->Handle;
1454
1455    RETURN_EGL_EVAL(disp, ret);
1456 }
1457
1458
1459 const char * EGLAPIENTRY
1460 eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
1461 {
1462    _EGLDisplay *disp = _eglLockDisplay(dpy);
1463    _EGLMode *m = _eglLookupMode(mode, disp);
1464    _EGLDriver *drv;
1465    const char *ret;
1466
1467    _EGL_CHECK_MODE(disp, m, NULL, drv);
1468    ret = drv->API.QueryModeStringMESA(drv, disp, m);
1469
1470    RETURN_EGL_EVAL(disp, ret);
1471 }
1472
1473
1474 #endif /* EGL_MESA_screen_surface */
1475
1476
1477 #ifdef EGL_MESA_drm_display
1478
1479 EGLDisplay EGLAPIENTRY
1480 eglGetDRMDisplayMESA(int fd)
1481 {
1482    _EGLDisplay *dpy = _eglFindDisplay(_EGL_PLATFORM_DRM, (void *) (intptr_t) fd);
1483    return _eglGetDisplayHandle(dpy);
1484 }
1485
1486 #endif /* EGL_MESA_drm_display */
1487
1488 /**
1489  ** EGL 1.2
1490  **/
1491
1492 /**
1493  * Specify the client API to use for subsequent calls including:
1494  *  eglCreateContext()
1495  *  eglGetCurrentContext()
1496  *  eglGetCurrentDisplay()
1497  *  eglGetCurrentSurface()
1498  *  eglMakeCurrent(when the ctx parameter is EGL NO CONTEXT)
1499  *  eglWaitClient()
1500  *  eglWaitNative()
1501  * See section 3.7 "Rendering Context" in the EGL specification for details.
1502  */
1503 EGLBoolean EGLAPIENTRY
1504 eglBindAPI(EGLenum api)
1505 {
1506    _EGLThreadInfo *t = _eglGetCurrentThread();
1507
1508    if (_eglIsCurrentThreadDummy())
1509       RETURN_EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
1510
1511    if (!_eglIsApiValid(api))
1512       RETURN_EGL_ERROR(NULL, EGL_BAD_PARAMETER, EGL_FALSE);
1513
1514    t->CurrentAPIIndex = _eglConvertApiToIndex(api);
1515
1516    RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
1517 }
1518
1519
1520 /**
1521  * Return the last value set with eglBindAPI().
1522  */
1523 EGLenum EGLAPIENTRY
1524 eglQueryAPI(void)
1525 {
1526    _EGLThreadInfo *t = _eglGetCurrentThread();
1527    EGLenum ret;
1528
1529    /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
1530    ret = _eglConvertApiFromIndex(t->CurrentAPIIndex);
1531
1532    RETURN_EGL_SUCCESS(NULL, ret);
1533 }
1534
1535
1536 EGLSurface EGLAPIENTRY
1537 eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
1538                                  EGLClientBuffer buffer, EGLConfig config,
1539                                  const EGLint *attrib_list)
1540 {
1541    _EGLDisplay *disp = _eglLockDisplay(dpy);
1542    _EGLConfig *conf = _eglLookupConfig(config, disp);
1543    _EGLDriver *drv;
1544    _EGLSurface *surf;
1545    EGLSurface ret;
1546
1547    _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
1548
1549    surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
1550                                                  conf, attrib_list);
1551    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
1552
1553    RETURN_EGL_EVAL(disp, ret);
1554 }
1555
1556
1557 EGLBoolean EGLAPIENTRY
1558 eglReleaseThread(void)
1559 {
1560    /* unbind current contexts */
1561    if (!_eglIsCurrentThreadDummy()) {
1562       _EGLThreadInfo *t = _eglGetCurrentThread();
1563       EGLint api_index = t->CurrentAPIIndex;
1564       EGLint i;
1565
1566       for (i = 0; i < _EGL_API_NUM_APIS; i++) {
1567          _EGLContext *ctx = t->CurrentContexts[i];
1568          if (ctx) {
1569             _EGLDisplay *disp = ctx->Resource.Display;
1570             _EGLDriver *drv;
1571
1572             t->CurrentAPIIndex = i;
1573
1574             mtx_lock(&disp->Mutex);
1575             drv = disp->Driver;
1576             (void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
1577             mtx_unlock(&disp->Mutex);
1578          }
1579       }
1580
1581       t->CurrentAPIIndex = api_index;
1582    }
1583
1584    _eglDestroyCurrentThread();
1585
1586    RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
1587 }
1588
1589
1590 EGLImageKHR EGLAPIENTRY
1591 eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1592                   EGLClientBuffer buffer, const EGLint *attr_list)
1593 {
1594    _EGLDisplay *disp = _eglLockDisplay(dpy);
1595    _EGLContext *context = _eglLookupContext(ctx, disp);
1596    _EGLDriver *drv;
1597    _EGLImage *img;
1598    EGLImageKHR ret;
1599
1600    _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
1601    if (!disp->Extensions.KHR_image_base)
1602       RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
1603    if (!context && ctx != EGL_NO_CONTEXT)
1604       RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
1605    /* "If <target> is EGL_LINUX_DMA_BUF_EXT, <dpy> must be a valid display,
1606     *  <ctx> must be EGL_NO_CONTEXT..."
1607     */
1608    if (ctx != EGL_NO_CONTEXT && target == EGL_LINUX_DMA_BUF_EXT)
1609       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
1610
1611    img = drv->API.CreateImageKHR(drv,
1612          disp, context, target, buffer, attr_list);
1613    ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
1614
1615    RETURN_EGL_EVAL(disp, ret);
1616 }
1617
1618
1619 EGLBoolean EGLAPIENTRY
1620 eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
1621 {
1622    _EGLDisplay *disp = _eglLockDisplay(dpy);
1623    _EGLImage *img = _eglLookupImage(image, disp);
1624    _EGLDriver *drv;
1625    EGLBoolean ret;
1626
1627    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
1628    if (!disp->Extensions.KHR_image_base)
1629       RETURN_EGL_EVAL(disp, EGL_FALSE);
1630    if (!img)
1631       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1632
1633    _eglUnlinkImage(img);
1634    ret = drv->API.DestroyImageKHR(drv, disp, img);
1635
1636    RETURN_EGL_EVAL(disp, ret);
1637 }
1638
1639
1640 EGLSyncKHR EGLAPIENTRY
1641 eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
1642 {
1643    _EGLDisplay *disp = _eglLockDisplay(dpy);
1644    _EGLDriver *drv;
1645    _EGLSync *sync;
1646    EGLSyncKHR ret;
1647
1648    _EGL_CHECK_DISPLAY(disp, EGL_NO_SYNC_KHR, drv);
1649    if (!disp->Extensions.KHR_reusable_sync)
1650       RETURN_EGL_EVAL(disp, EGL_NO_SYNC_KHR);
1651
1652    sync = drv->API.CreateSyncKHR(drv, disp, type, attrib_list);
1653    ret = (sync) ? _eglLinkSync(sync) : EGL_NO_SYNC_KHR;
1654
1655    RETURN_EGL_EVAL(disp, ret);
1656 }
1657
1658
1659 EGLBoolean EGLAPIENTRY
1660 eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
1661 {
1662    _EGLDisplay *disp = _eglLockDisplay(dpy);
1663    _EGLSync *s = _eglLookupSync(sync, disp);
1664    _EGLDriver *drv;
1665    EGLBoolean ret;
1666
1667    _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
1668    assert(disp->Extensions.KHR_reusable_sync);
1669
1670    _eglUnlinkSync(s);
1671    ret = drv->API.DestroySyncKHR(drv, disp, s);
1672
1673    RETURN_EGL_EVAL(disp, ret);
1674 }
1675
1676
1677 EGLint EGLAPIENTRY
1678 eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
1679 {
1680    _EGLDisplay *disp = _eglLockDisplay(dpy);
1681    _EGLSync *s = _eglLookupSync(sync, disp);
1682    _EGLDriver *drv;
1683    EGLint ret;
1684
1685    _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
1686    assert(disp->Extensions.KHR_reusable_sync);
1687    ret = drv->API.ClientWaitSyncKHR(drv, disp, s, flags, timeout);
1688
1689    RETURN_EGL_EVAL(disp, ret);
1690 }
1691
1692
1693 EGLBoolean EGLAPIENTRY
1694 eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode)
1695 {
1696    _EGLDisplay *disp = _eglLockDisplay(dpy);
1697    _EGLSync *s = _eglLookupSync(sync, disp);
1698    _EGLDriver *drv;
1699    EGLBoolean ret;
1700
1701    _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
1702    assert(disp->Extensions.KHR_reusable_sync);
1703    ret = drv->API.SignalSyncKHR(drv, disp, s, mode);
1704
1705    RETURN_EGL_EVAL(disp, ret);
1706 }
1707
1708
1709 EGLBoolean EGLAPIENTRY
1710 eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)
1711 {
1712    _EGLDisplay *disp = _eglLockDisplay(dpy);
1713    _EGLSync *s = _eglLookupSync(sync, disp);
1714    _EGLDriver *drv;
1715    EGLBoolean ret;
1716
1717    _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
1718    assert(disp->Extensions.KHR_reusable_sync);
1719    ret = drv->API.GetSyncAttribKHR(drv, disp, s, attribute, value);
1720
1721    RETURN_EGL_EVAL(disp, ret);
1722 }
1723
1724
1725 #ifdef EGL_NOK_swap_region
1726
1727 EGLBoolean EGLAPIENTRY
1728 eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface,
1729                         EGLint numRects, const EGLint *rects)
1730 {
1731    _EGLContext *ctx = _eglGetCurrentContext();
1732    _EGLDisplay *disp = _eglLockDisplay(dpy);
1733    _EGLSurface *surf = _eglLookupSurface(surface, disp);
1734    _EGLDriver *drv;
1735    EGLBoolean ret;
1736
1737    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
1738
1739    if (!disp->Extensions.NOK_swap_region)
1740       RETURN_EGL_EVAL(disp, EGL_FALSE);
1741
1742    /* surface must be bound to current context in EGL 1.4 */
1743    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
1744        surf != ctx->DrawSurface)
1745       RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
1746
1747    ret = drv->API.SwapBuffersRegionNOK(drv, disp, surf, numRects, rects);
1748
1749    RETURN_EGL_EVAL(disp, ret);
1750 }
1751
1752 #endif /* EGL_NOK_swap_region */
1753
1754
1755 #ifdef EGL_MESA_drm_image
1756
1757 EGLImageKHR EGLAPIENTRY
1758 eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *attr_list)
1759 {
1760    _EGLDisplay *disp = _eglLockDisplay(dpy);
1761    _EGLDriver *drv;
1762    _EGLImage *img;
1763    EGLImageKHR ret;
1764
1765    _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
1766    if (!disp->Extensions.MESA_drm_image)
1767       RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
1768
1769    img = drv->API.CreateDRMImageMESA(drv, disp, attr_list);
1770    ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
1771
1772    RETURN_EGL_EVAL(disp, ret);
1773 }
1774
1775 EGLBoolean EGLAPIENTRY
1776 eglExportDRMImageMESA(EGLDisplay dpy, EGLImageKHR image,
1777                       EGLint *name, EGLint *handle, EGLint *stride)
1778 {
1779    _EGLDisplay *disp = _eglLockDisplay(dpy);
1780    _EGLImage *img = _eglLookupImage(image, disp);
1781    _EGLDriver *drv;
1782    EGLBoolean ret;
1783
1784    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
1785    assert(disp->Extensions.MESA_drm_image);
1786
1787    if (!img)
1788       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1789
1790    ret = drv->API.ExportDRMImageMESA(drv, disp, img, name, handle, stride);
1791
1792    RETURN_EGL_EVAL(disp, ret);
1793 }
1794
1795 #endif
1796
1797 #ifdef EGL_WL_bind_wayland_display
1798 struct wl_display;
1799
1800 EGLBoolean EGLAPIENTRY
1801 eglBindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display)
1802 {
1803    _EGLDisplay *disp = _eglLockDisplay(dpy);
1804    _EGLDriver *drv;
1805    EGLBoolean ret;
1806
1807    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
1808    assert(disp->Extensions.WL_bind_wayland_display);
1809
1810    if (!display)
1811       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1812
1813    ret = drv->API.BindWaylandDisplayWL(drv, disp, display);
1814
1815    RETURN_EGL_EVAL(disp, ret);
1816 }
1817
1818 EGLBoolean EGLAPIENTRY
1819 eglUnbindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display)
1820 {
1821    _EGLDisplay *disp = _eglLockDisplay(dpy);
1822    _EGLDriver *drv;
1823    EGLBoolean ret;
1824
1825    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
1826    assert(disp->Extensions.WL_bind_wayland_display);
1827
1828    if (!display)
1829       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1830
1831    ret = drv->API.UnbindWaylandDisplayWL(drv, disp, display);
1832
1833    RETURN_EGL_EVAL(disp, ret);
1834 }
1835
1836 EGLBoolean EGLAPIENTRY
1837 eglQueryWaylandBufferWL(EGLDisplay dpy, struct wl_resource *buffer,
1838                         EGLint attribute, EGLint *value)
1839 {
1840    _EGLDisplay *disp = _eglLockDisplay(dpy);
1841    _EGLDriver *drv;
1842    EGLBoolean ret;
1843
1844    _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
1845    assert(disp->Extensions.WL_bind_wayland_display);
1846
1847    if (!buffer)
1848       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1849
1850    ret = drv->API.QueryWaylandBufferWL(drv, disp, buffer, attribute, value);
1851
1852    RETURN_EGL_EVAL(disp, ret);
1853 }
1854 #endif
1855
1856 #ifdef EGL_WL_create_wayland_buffer_from_image
1857 struct wl_buffer * EGLAPIENTRY
1858 eglCreateWaylandBufferFromImageWL(EGLDisplay dpy, EGLImageKHR image)
1859 {
1860    _EGLDisplay *disp = _eglLockDisplay(dpy);
1861    _EGLImage *img;
1862    _EGLDriver *drv;
1863    struct wl_buffer *ret;
1864
1865    _EGL_CHECK_DISPLAY(disp, NULL, drv);
1866    assert(disp->Extensions.WL_create_wayland_buffer_from_image);
1867
1868    img = _eglLookupImage(image, disp);
1869
1870    if (!img)
1871       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
1872
1873    ret = drv->API.CreateWaylandBufferFromImageWL(drv, disp, img);
1874
1875    RETURN_EGL_EVAL(disp, ret);
1876 }
1877 #endif
1878
1879 EGLBoolean EGLAPIENTRY
1880 eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface,
1881                    EGLint x, EGLint y, EGLint width, EGLint height)
1882 {
1883    _EGLDisplay *disp = _eglLockDisplay(dpy);
1884    _EGLSurface *surf = _eglLookupSurface(surface, disp);
1885    _EGLDriver *drv;
1886    EGLBoolean ret;
1887
1888    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
1889
1890    if (!disp->Extensions.NV_post_sub_buffer)
1891       RETURN_EGL_EVAL(disp, EGL_FALSE);
1892
1893    ret = drv->API.PostSubBufferNV(drv, disp, surf, x, y, width, height);
1894
1895    RETURN_EGL_EVAL(disp, ret);
1896 }
1897
1898 EGLBoolean EGLAPIENTRY
1899 eglGetSyncValuesCHROMIUM(EGLDisplay display, EGLSurface surface,
1900                          EGLuint64KHR *ust, EGLuint64KHR *msc,
1901                          EGLuint64KHR *sbc)
1902 {
1903    _EGLDisplay *disp = _eglLockDisplay(display);
1904    _EGLSurface *surf = _eglLookupSurface(surface, disp);
1905    _EGLDriver *drv;
1906    EGLBoolean ret;
1907
1908    _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
1909    if (!disp->Extensions.CHROMIUM_sync_control)
1910       RETURN_EGL_EVAL(disp, EGL_FALSE);
1911
1912    if (!ust || !msc || !sbc)
1913       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
1914
1915    ret = drv->API.GetSyncValuesCHROMIUM(disp, surf, ust, msc, sbc);
1916
1917    RETURN_EGL_EVAL(disp, ret);
1918 }