src/egl/main/eglapi.c

   1 /**
   2  * Public EGL API entrypoints
   3  *
   4  * Generally, we use the EGLDisplay parameter as a key to lookup the
   5  * appropriate device driver handle, then jump though the driver's
   6  * dispatch table to handle the function.
   7  *
   8  * That allows us the option of supporting multiple, simultaneous,
   9  * heterogeneous hardware devices in the future.
  10  *
  11  * The EGLDisplay, EGLConfig, EGLContext and EGLSurface types are
  12  * opaque handles implemented with 32-bit unsigned integers.
  13  * It's up to the driver function or fallback function to look up the
  14  * handle and get an object.
  15  * By using opaque handles, we leave open the possibility of having
  16  * indirect rendering in the future, like GLX.
  17  *
  18  *
  19  * Notes on naming conventions:
  20  *
  21  * eglFooBar    - public EGL function
  22  * EGL_FOO_BAR  - public EGL token
  23  * EGLDatatype  - public EGL datatype
  24  *
  25  * _eglFooBar   - private EGL function
  26  * _EGLDatatype - private EGL datatype, typedef'd struct
  27  * _egl_struct  - private EGL struct, non-typedef'd
  28  *
  29  */
  30
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include "eglcontext.h"
  36 #include "egldisplay.h"
  37 #include "egltypedefs.h"
  38 #include "eglglobals.h"
  39 #include "egldriver.h"
  40 #include "eglsurface.h"
  41 #include "eglconfig.h"
  42 #include "eglscreen.h"
  43 #include "eglmode.h"
  44
  45
  46 /**
  47  * This is typically the first EGL function that an application calls.
  48  * We initialize our global vars and create a private _EGLDisplay object.
  49  */
  50 EGLDisplay EGLAPIENTRY
  51 eglGetDisplay(NativeDisplayType nativeDisplay)
  52 {
  53    _EGLDisplay *dpy;
  54    dpy = _eglFindDisplay(nativeDisplay);
  55    if (!dpy) {
  56       dpy = _eglNewDisplay(nativeDisplay);
  57       if (dpy)
  58          _eglLinkDisplay(dpy);
  59    }
  60    return _eglGetDisplayHandle(dpy);
  61 }
  62
  63
  64 /**
  65  * This is typically the second EGL function that an application calls.
  66  * Here we load/initialize the actual hardware driver.
  67  */
  68 EGLBoolean EGLAPIENTRY
  69 eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
  70 {
  71    _EGLDisplay *disp = _eglLookupDisplay(dpy);
  72    _EGLDriver *drv;
  73    EGLint major_int, minor_int;
  74
  75    if (!disp)
  76       return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
  77
  78    drv = disp->Driver;
  79    if (!drv) {
  80       drv = _eglOpenDriver(disp);
  81       if (!drv)
  82          return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
  83
  84       /* Initialize the particular display now */
  85       if (!drv->API.Initialize(drv, disp, &major_int, &minor_int)) {
  86          _eglCloseDriver(drv, disp);
  87          return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
  88       }
  89
  90       disp->APImajor = major_int;
  91       disp->APIminor = minor_int;
  92       snprintf(disp->Version, sizeof(disp->Version),
  93                "%d.%d (%s)", major_int, minor_int, drv->Name);
  94
  95       /* limit to APIs supported by core */
  96       disp->ClientAPIsMask &= _EGL_API_ALL_BITS;
  97
  98       disp->Driver = drv;
  99    } else {
 100       major_int = disp->APImajor;
 101       minor_int = disp->APIminor;
 102    }
 103
 104    /* Update applications version of major and minor if not NULL */
 105    if ((major != NULL) && (minor != NULL)) {
 106       *major = major_int;
 107       *minor = minor_int;
 108    }
 109
 110    return EGL_TRUE;
 111 }
 112
 113
 114 EGLBoolean EGLAPIENTRY
 115 eglTerminate(EGLDisplay dpy)
 116 {
 117    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 118    _EGLDriver *drv;
 119
 120    if (!disp)
 121       return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
 122
 123    drv = disp->Driver;
 124    if (drv) {
 125       drv->API.Terminate(drv, disp);
 126       _eglCloseDriver(drv, disp);
 127       disp->Driver = NULL;
 128    }
 129
 130    return EGL_TRUE;
 131 }
 132
 133
 134 /**
 135  * A bunch of check functions and declare macros to simply error checking.
 136  */
 137 static INLINE _EGLDriver *
 138 _eglCheckDisplay(_EGLDisplay *disp, const char *msg)
 139 {
 140    if (!disp) {
 141       _eglError(EGL_BAD_DISPLAY, msg);
 142       return NULL;
 143    }
 144    if (!disp->Driver) {
 145       _eglError(EGL_NOT_INITIALIZED, msg);
 146       return NULL;
 147    }
 148    return disp->Driver;
 149 }
 150
 151
 152 static INLINE _EGLDriver *
 153 _eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
 154 {
 155    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 156    if (!drv)
 157       return NULL;
 158    if (!surf) {
 159       _eglError(EGL_BAD_SURFACE, msg);
 160       return NULL;
 161    }
 162    return drv;
 163 }
 164
 165
 166 static INLINE _EGLDriver *
 167 _eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
 168 {
 169    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 170    if (!drv)
 171       return NULL;
 172    if (!context) {
 173       _eglError(EGL_BAD_CONTEXT, msg);
 174       return NULL;
 175    }
 176    return drv;
 177 }
 178
 179
 180 static INLINE _EGLDriver *
 181 _eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
 182 {
 183    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 184    if (!drv)
 185       return NULL;
 186    if (!conf) {
 187       _eglError(EGL_BAD_CONFIG, msg);
 188       return NULL;
 189    }
 190    return drv;
 191 }
 192
 193
 194 #define _EGL_DECLARE_DD(dpy)                                   \
 195    _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
 196    _EGLDriver *drv;                                            \
 197    do {                                                        \
 198       drv = _eglCheckDisplay(disp, __FUNCTION__);              \
 199       if (!drv)                                                \
 200          return EGL_FALSE;                                     \
 201    } while (0)
 202
 203
 204 #define _EGL_DECLARE_DD_AND_SURFACE(dpy, surface)              \
 205    _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
 206    _EGLSurface *surf = _eglLookupSurface((surface), disp);     \
 207    _EGLDriver *drv;                                            \
 208    do {                                                        \
 209       drv = _eglCheckSurface(disp, surf, __FUNCTION__);        \
 210       if (!drv)                                                \
 211          return EGL_FALSE;                                     \
 212    } while (0)
 213
 214
 215 #define _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx)                  \
 216    _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
 217    _EGLContext *context = _eglLookupContext((ctx), disp);      \
 218    _EGLDriver *drv;                                            \
 219    do {                                                        \
 220       drv = _eglCheckContext(disp, context, __FUNCTION__);     \
 221       if (!drv)                                                \
 222          return EGL_FALSE;                                     \
 223    } while (0)
 224
 225
 226 #ifdef EGL_MESA_screen_surface
 227
 228
 229 static INLINE _EGLDriver *
 230 _eglCheckScreen(_EGLDisplay *disp, _EGLScreen *scrn, const char *msg)
 231 {
 232    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 233    if (!drv)
 234       return NULL;
 235    if (!scrn) {
 236       _eglError(EGL_BAD_SCREEN_MESA, msg);
 237       return NULL;
 238    }
 239    return drv;
 240 }
 241
 242
 243 static INLINE _EGLDriver *
 244 _eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
 245 {
 246    _EGLDriver *drv = _eglCheckDisplay(disp, msg);
 247    if (!drv)
 248       return NULL;
 249    if (!m) {
 250       _eglError(EGL_BAD_MODE_MESA, msg);
 251       return NULL;
 252    }
 253    return drv;
 254 }
 255
 256
 257 #define _EGL_DECLARE_DD_AND_SCREEN(dpy, screen)                \
 258    _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
 259    _EGLScreen *scrn = _eglLookupScreen((screen), disp);        \
 260    _EGLDriver *drv;                                            \
 261    do {                                                        \
 262       drv = _eglCheckScreen(disp, scrn, __FUNCTION__);         \
 263       if (!drv)                                                \
 264          return EGL_FALSE;                                     \
 265    } while (0)
 266
 267
 268 #define _EGL_DECLARE_DD_AND_MODE(dpy, mode)                    \
 269    _EGLDisplay *disp = _eglLookupDisplay(dpy);                 \
 270    _EGLMode *m = _eglLookupMode((mode), disp);                 \
 271    _EGLDriver *drv;                                            \
 272    do {                                                        \
 273       drv = _eglCheckMode(disp, m, __FUNCTION__);              \
 274       if (!drv)                                                \
 275          return EGL_FALSE;                                     \
 276    } while (0)
 277
 278
 279 #endif /* EGL_MESA_screen_surface */
 280
 281
 282 const char * EGLAPIENTRY
 283 eglQueryString(EGLDisplay dpy, EGLint name)
 284 {
 285    _EGL_DECLARE_DD(dpy);
 286    return drv->API.QueryString(drv, disp, name);
 287 }
 288
 289
 290 EGLBoolean EGLAPIENTRY
 291 eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
 292               EGLint config_size, EGLint *num_config)
 293 {
 294    _EGL_DECLARE_DD(dpy);
 295    return drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
 296 }
 297
 298
 299 EGLBoolean EGLAPIENTRY
 300 eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
 301                 EGLint config_size, EGLint *num_config)
 302 {
 303    _EGL_DECLARE_DD(dpy);
 304    return drv->API.ChooseConfig(drv, disp, attrib_list, configs,
 305                                 config_size, num_config);
 306 }
 307
 308
 309 EGLBoolean EGLAPIENTRY
 310 eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
 311                    EGLint attribute, EGLint *value)
 312 {
 313    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 314    _EGLConfig *conf = _eglLookupConfig(config, disp);
 315    _EGLDriver *drv;
 316
 317    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 318    if (!drv)
 319       return EGL_FALSE;
 320
 321    return drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
 322 }
 323
 324
 325 EGLContext EGLAPIENTRY
 326 eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
 327                  const EGLint *attrib_list)
 328 {
 329    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 330    _EGLConfig *conf = _eglLookupConfig(config, disp);
 331    _EGLContext *share = _eglLookupContext(share_list, disp);
 332    _EGLDriver *drv;
 333    _EGLContext *context;
 334
 335    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 336    if (!drv)
 337       return EGL_NO_CONTEXT;
 338    if (!share && share_list != EGL_NO_CONTEXT) {
 339       _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
 340       return EGL_NO_CONTEXT;
 341    }
 342
 343    context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
 344    if (context)
 345       return _eglLinkContext(context, disp);
 346    else
 347       return EGL_NO_CONTEXT;
 348 }
 349
 350
 351 EGLBoolean EGLAPIENTRY
 352 eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 353 {
 354    _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
 355    _eglUnlinkContext(context);
 356    return drv->API.DestroyContext(drv, disp, context);
 357 }
 358
 359
 360 EGLBoolean EGLAPIENTRY
 361 eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
 362                EGLContext ctx)
 363 {
 364    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 365    _EGLContext *context = _eglLookupContext(ctx, disp);
 366    _EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
 367    _EGLSurface *read_surf = _eglLookupSurface(read, disp);
 368    _EGLDriver *drv;
 369
 370    drv = _eglCheckDisplay(disp, __FUNCTION__);
 371    if (!drv)
 372       return EGL_FALSE;
 373    if (!context && ctx != EGL_NO_CONTEXT)
 374       return _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
 375    if ((!draw_surf && draw != EGL_NO_SURFACE) ||
 376        (!read_surf && read != EGL_NO_SURFACE))
 377       return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
 378
 379    return drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
 380 }
 381
 382
 383 EGLBoolean EGLAPIENTRY
 384 eglQueryContext(EGLDisplay dpy, EGLContext ctx,
 385                 EGLint attribute, EGLint *value)
 386 {
 387    _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
 388    return drv->API.QueryContext(drv, disp, context, attribute, value);
 389 }
 390
 391
 392 EGLSurface EGLAPIENTRY
 393 eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
 394                        NativeWindowType window, const EGLint *attrib_list)
 395 {
 396    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 397    _EGLConfig *conf = _eglLookupConfig(config, disp);
 398    _EGLDriver *drv;
 399    _EGLSurface *surf;
 400
 401    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 402    if (!drv)
 403       return EGL_NO_SURFACE;
 404
 405    surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
 406    if (surf)
 407       return _eglLinkSurface(surf, disp);
 408    else
 409       return EGL_NO_SURFACE;
 410 }
 411
 412
 413 EGLSurface EGLAPIENTRY
 414 eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
 415                        NativePixmapType pixmap, const EGLint *attrib_list)
 416 {
 417    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 418    _EGLConfig *conf = _eglLookupConfig(config, disp);
 419    _EGLDriver *drv;
 420    _EGLSurface *surf;
 421
 422    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 423    if (!drv)
 424       return EGL_NO_SURFACE;
 425
 426    surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
 427    if (surf)
 428       return _eglLinkSurface(surf, disp);
 429    else
 430       return EGL_NO_SURFACE;
 431 }
 432
 433
 434 EGLSurface EGLAPIENTRY
 435 eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
 436                         const EGLint *attrib_list)
 437 {
 438    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 439    _EGLConfig *conf = _eglLookupConfig(config, disp);
 440    _EGLDriver *drv;
 441    _EGLSurface *surf;
 442
 443    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 444    if (!drv)
 445       return EGL_NO_SURFACE;
 446
 447    surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
 448    if (surf)
 449       return _eglLinkSurface(surf, disp);
 450    else
 451       return EGL_NO_SURFACE;
 452 }
 453
 454
 455 EGLBoolean EGLAPIENTRY
 456 eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 457 {
 458    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 459    _eglUnlinkSurface(surf);
 460    return drv->API.DestroySurface(drv, disp, surf);
 461 }
 462
 463 EGLBoolean EGLAPIENTRY
 464 eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
 465                 EGLint attribute, EGLint *value)
 466 {
 467    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 468    return drv->API.QuerySurface(drv, disp, surf, attribute, value);
 469 }
 470
 471 EGLBoolean EGLAPIENTRY
 472 eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
 473                  EGLint attribute, EGLint value)
 474 {
 475    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 476    return drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
 477 }
 478
 479
 480 EGLBoolean EGLAPIENTRY
 481 eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 482 {
 483    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 484    return drv->API.BindTexImage(drv, disp, surf, buffer);
 485 }
 486
 487
 488 EGLBoolean EGLAPIENTRY
 489 eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 490 {
 491    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 492    return drv->API.ReleaseTexImage(drv, disp, surf, buffer);
 493 }
 494
 495
 496 EGLBoolean EGLAPIENTRY
 497 eglSwapInterval(EGLDisplay dpy, EGLint interval)
 498 {
 499    _EGL_DECLARE_DD(dpy);
 500    return drv->API.SwapInterval(drv, disp, interval);
 501 }
 502
 503
 504 EGLBoolean EGLAPIENTRY
 505 eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 506 {
 507    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 508    return drv->API.SwapBuffers(drv, disp, surf);
 509 }
 510
 511
 512 EGLBoolean EGLAPIENTRY
 513 eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, NativePixmapType target)
 514 {
 515    _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
 516    return drv->API.CopyBuffers(drv, disp, surf, target);
 517 }
 518
 519
 520 EGLBoolean EGLAPIENTRY
 521 eglWaitGL(void)
 522 {
 523    _EGLDisplay *disp = _eglGetCurrentDisplay();
 524    _EGLDriver *drv;
 525
 526    if (!disp)
 527       return EGL_TRUE;
 528
 529    /* a current display is always initialized */
 530    drv = disp->Driver;
 531
 532    return drv->API.WaitGL(drv, disp);
 533 }
 534
 535
 536 EGLBoolean EGLAPIENTRY
 537 eglWaitNative(EGLint engine)
 538 {
 539    _EGLDisplay *disp = _eglGetCurrentDisplay();
 540    _EGLDriver *drv;
 541
 542    if (!disp)
 543       return EGL_TRUE;
 544
 545    /* a current display is always initialized */
 546    drv = disp->Driver;
 547
 548    return drv->API.WaitNative(drv, disp, engine);
 549 }
 550
 551
 552 EGLDisplay EGLAPIENTRY
 553 eglGetCurrentDisplay(void)
 554 {
 555    _EGLDisplay *dpy = _eglGetCurrentDisplay();
 556    return _eglGetDisplayHandle(dpy);
 557 }
 558
 559
 560 EGLContext EGLAPIENTRY
 561 eglGetCurrentContext(void)
 562 {
 563    _EGLContext *ctx = _eglGetCurrentContext();
 564    return _eglGetContextHandle(ctx);
 565 }
 566
 567
 568 EGLSurface EGLAPIENTRY
 569 eglGetCurrentSurface(EGLint readdraw)
 570 {
 571    _EGLSurface *s = _eglGetCurrentSurface(readdraw);
 572    return _eglGetSurfaceHandle(s);
 573 }
 574
 575
 576 EGLint EGLAPIENTRY
 577 eglGetError(void)
 578 {
 579    _EGLThreadInfo *t = _eglGetCurrentThread();
 580    EGLint e = t->LastError;
 581    if (!_eglIsCurrentThreadDummy())
 582       t->LastError = EGL_SUCCESS;
 583    return e;
 584 }
 585
 586
 587 void (* EGLAPIENTRY eglGetProcAddress(const char *procname))()
 588 {
 589    static const struct {
 590       const char *name;
 591       _EGLProc function;
 592    } egl_functions[] = {
 593       /* extensions only */
 594 #ifdef EGL_MESA_screen_surface
 595       { "eglChooseModeMESA", (_EGLProc) eglChooseModeMESA },
 596       { "eglGetModesMESA", (_EGLProc) eglGetModesMESA },
 597       { "eglGetModeAttribMESA", (_EGLProc) eglGetModeAttribMESA },
 598       { "eglCopyContextMESA", (_EGLProc) eglCopyContextMESA },
 599       { "eglGetScreensMESA", (_EGLProc) eglGetScreensMESA },
 600       { "eglCreateScreenSurfaceMESA", (_EGLProc) eglCreateScreenSurfaceMESA },
 601       { "eglShowScreenSurfaceMESA", (_EGLProc) eglShowScreenSurfaceMESA },
 602       { "eglScreenPositionMESA", (_EGLProc) eglScreenPositionMESA },
 603       { "eglQueryScreenMESA", (_EGLProc) eglQueryScreenMESA },
 604       { "eglQueryScreenSurfaceMESA", (_EGLProc) eglQueryScreenSurfaceMESA },
 605       { "eglQueryScreenModeMESA", (_EGLProc) eglQueryScreenModeMESA },
 606       { "eglQueryModeStringMESA", (_EGLProc) eglQueryModeStringMESA },
 607 #endif /* EGL_MESA_screen_surface */
 608       { NULL, NULL }
 609    };
 610    EGLint i;
 611
 612    if (!procname)
 613       return NULL;
 614    if (strncmp(procname, "egl", 3) == 0) {
 615       for (i = 0; egl_functions[i].name; i++) {
 616          if (strcmp(egl_functions[i].name, procname) == 0)
 617             return egl_functions[i].function;
 618       }
 619    }
 620
 621    /* preload a driver if there isn't one */
 622    if (!_eglGlobal.NumDrivers)
 623       _eglPreloadDriver(NULL);
 624
 625    /* now loop over drivers to query their procs */
 626    for (i = 0; i < _eglGlobal.NumDrivers; i++) {
 627       _EGLProc p = _eglGlobal.Drivers[i]->API.GetProcAddress(procname);
 628       if (p)
 629          return p;
 630    }
 631
 632    return NULL;
 633 }
 634
 635
 636 #ifdef EGL_MESA_screen_surface
 637
 638
 639 /*
 640  * EGL_MESA_screen extension
 641  */
 642
 643 EGLBoolean EGLAPIENTRY
 644 eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
 645                   const EGLint *attrib_list, EGLModeMESA *modes,
 646                   EGLint modes_size, EGLint *num_modes)
 647 {
 648    _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
 649    return drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
 650                                   modes, modes_size, num_modes);
 651 }
 652
 653
 654 EGLBoolean EGLAPIENTRY
 655 eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
 656                 EGLint mode_size, EGLint *num_mode)
 657 {
 658    _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
 659    return drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
 660 }
 661
 662
 663 EGLBoolean EGLAPIENTRY
 664 eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
 665                      EGLint attribute, EGLint *value)
 666 {
 667    _EGL_DECLARE_DD_AND_MODE(dpy, mode);
 668    return drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
 669 }
 670
 671
 672 EGLBoolean EGLAPIENTRY
 673 eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
 674                    EGLint mask)
 675 {
 676    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 677    _EGLContext *source_context = _eglLookupContext(source, disp);
 678    _EGLContext *dest_context = _eglLookupContext(dest, disp);
 679    _EGLDriver *drv;
 680
 681    drv = _eglCheckContext(disp, source_context, __FUNCTION__);
 682    if (!drv || !dest_context) {
 683       if (drv)
 684          _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
 685       return EGL_FALSE;
 686    }
 687
 688    return drv->API.CopyContextMESA(drv, disp, source_context, dest_context,
 689                                    mask);
 690 }
 691
 692
 693 EGLBoolean
 694 eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
 695                   EGLint max_screens, EGLint *num_screens)
 696 {
 697    _EGL_DECLARE_DD(dpy);
 698    return drv->API.GetScreensMESA(drv, disp, screens,
 699                                   max_screens, num_screens);
 700 }
 701
 702
 703 EGLSurface
 704 eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
 705                            const EGLint *attrib_list)
 706 {
 707    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 708    _EGLConfig *conf = _eglLookupConfig(config, disp);
 709    _EGLDriver *drv;
 710    _EGLSurface *surf;
 711
 712    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 713    if (!drv)
 714       return EGL_NO_SURFACE;
 715
 716    surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
 717    if (surf)
 718       return _eglLinkSurface(surf, disp);
 719    else
 720       return EGL_NO_SURFACE;
 721 }
 722
 723
 724 EGLBoolean
 725 eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
 726                          EGLSurface surface, EGLModeMESA mode)
 727 {
 728    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 729    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
 730    _EGLSurface *surf = _eglLookupSurface(surface, disp);
 731    _EGLMode *m = _eglLookupMode(mode, disp);
 732    _EGLDriver *drv;
 733
 734    drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
 735    if (!drv)
 736       return EGL_FALSE;
 737    if (!surf && surface != EGL_NO_SURFACE)
 738       return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
 739    if (!m && mode != EGL_NO_MODE_MESA)
 740       return _eglError(EGL_BAD_MODE_MESA, __FUNCTION__);
 741
 742    return drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
 743 }
 744
 745
 746 EGLBoolean
 747 eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
 748 {
 749    _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
 750    return drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
 751 }
 752
 753
 754 EGLBoolean
 755 eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
 756                    EGLint attribute, EGLint *value)
 757 {
 758    _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
 759    return drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
 760 }
 761
 762
 763 EGLBoolean
 764 eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
 765                           EGLSurface *surface)
 766 {
 767    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 768    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
 769    _EGLDriver *drv;
 770    _EGLSurface *surf;
 771
 772    drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
 773    if (!drv)
 774       return EGL_FALSE;
 775
 776    if (drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf) != EGL_TRUE)
 777       surf = NULL;
 778    if (surface)
 779       *surface = _eglGetSurfaceHandle(surf);
 780    return (surf != NULL);
 781 }
 782
 783
 784 EGLBoolean
 785 eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
 786 {
 787    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 788    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
 789    _EGLDriver *drv;
 790    _EGLMode *m;
 791
 792    drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
 793    if (!drv)
 794       return EGL_FALSE;
 795
 796    if (drv->API.QueryScreenModeMESA(drv, disp, scrn, &m) != EGL_TRUE)
 797       m = NULL;
 798    if (mode)
 799       *mode = m->Handle;
 800
 801    return (m != NULL);
 802 }
 803
 804
 805 const char *
 806 eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
 807 {
 808    _EGL_DECLARE_DD_AND_MODE(dpy, mode);
 809    return drv->API.QueryModeStringMESA(drv, disp, m);
 810 }
 811
 812
 813 #endif /* EGL_MESA_screen_surface */
 814
 815
 816 /**
 817  ** EGL 1.2
 818  **/
 819
 820 #ifdef EGL_VERSION_1_2
 821
 822
 823 /**
 824  * Specify the client API to use for subsequent calls including:
 825  *  eglCreateContext()
 826  *  eglGetCurrentContext()
 827  *  eglGetCurrentDisplay()
 828  *  eglGetCurrentSurface()
 829  *  eglMakeCurrent(when the ctx parameter is EGL NO CONTEXT)
 830  *  eglWaitClient()
 831  *  eglWaitNative()
 832  * See section 3.7 "Rendering Context" in the EGL specification for details.
 833  */
 834 EGLBoolean
 835 eglBindAPI(EGLenum api)
 836 {
 837    _EGLThreadInfo *t = _eglGetCurrentThread();
 838
 839    if (_eglIsCurrentThreadDummy())
 840       return _eglError(EGL_BAD_ALLOC, "eglBindAPI");
 841
 842    if (!_eglIsApiValid(api))
 843       return _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
 844
 845    t->CurrentAPIIndex = _eglConvertApiToIndex(api);
 846    return EGL_TRUE;
 847 }
 848
 849
 850 /**
 851  * Return the last value set with eglBindAPI().
 852  */
 853 EGLenum
 854 eglQueryAPI(void)
 855 {
 856    /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
 857    _EGLThreadInfo *t = _eglGetCurrentThread();
 858    return _eglConvertApiFromIndex(t->CurrentAPIIndex);
 859 }
 860
 861
 862 EGLSurface
 863 eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
 864                                  EGLClientBuffer buffer, EGLConfig config,
 865                                  const EGLint *attrib_list)
 866 {
 867    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 868    _EGLConfig *conf = _eglLookupConfig(config, disp);
 869    _EGLDriver *drv;
 870    _EGLSurface *surf;
 871
 872    drv = _eglCheckConfig(disp, conf, __FUNCTION__);
 873    if (!drv)
 874       return EGL_NO_SURFACE;
 875
 876    surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
 877                                                  conf, attrib_list);
 878    if (surf)
 879       return _eglLinkSurface(surf, disp);
 880    else
 881       return EGL_NO_SURFACE;
 882 }
 883
 884
 885 EGLBoolean
 886 eglReleaseThread(void)
 887 {
 888    /* unbind current context */
 889    if (!_eglIsCurrentThreadDummy()) {
 890       _EGLDisplay *disp = _eglGetCurrentDisplay();
 891       _EGLDriver *drv;
 892       if (disp) {
 893          drv = disp->Driver;
 894          (void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
 895       }
 896    }
 897
 898    _eglDestroyCurrentThread();
 899    return EGL_TRUE;
 900 }
 901
 902
 903 EGLBoolean
 904 eglWaitClient(void)
 905 {
 906    _EGLDisplay *disp = _eglGetCurrentDisplay();
 907    _EGLDriver *drv;
 908
 909    if (!disp)
 910       return EGL_TRUE;
 911
 912    /* a current display is always initialized */
 913    drv = disp->Driver;
 914
 915    return drv->API.WaitClient(drv, disp);
 916 }
 917
 918
 919 #endif /* EGL_VERSION_1_2 */