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