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