src/egl/main/eglapi.c

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