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