2 * Public EGL API entrypoints
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.
8 * That allows us the option of supporting multiple, simultaneous,
9 * heterogeneous hardware devices in the future.
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.
19 * Notes on naming conventions:
21 * eglFooBar - public EGL function
22 * EGL_FOO_BAR - public EGL token
23 * EGLDatatype - public EGL datatype
25 * _eglFooBar - private EGL function
26 * _EGLDatatype - private EGL datatype, typedef'd struct
27 * _egl_struct - private EGL struct, non-typedef'd
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"
47 * This is typically the first EGL function that an application calls.
48 * We initialize our global vars and create a private _EGLDisplay object.
50 EGLDisplay EGLAPIENTRY
51 eglGetDisplay(NativeDisplayType nativeDisplay)
54 dpy = _eglFindDisplay(nativeDisplay);
56 dpy = _eglNewDisplay(nativeDisplay);
60 return _eglGetDisplayHandle(dpy);
65 * This is typically the second EGL function that an application calls.
66 * Here we load/initialize the actual hardware driver.
68 EGLBoolean EGLAPIENTRY
69 eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
71 _EGLDisplay *disp = _eglLookupDisplay(dpy);
73 EGLint major_int, minor_int;
76 return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
80 drv = _eglOpenDriver(disp);
82 return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
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__);
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);
95 /* update the global notion of supported APIs */
96 _eglGlobal.ClientAPIsMask |= disp->ClientAPIsMask;
100 major_int = disp->APImajor;
101 minor_int = disp->APIminor;
104 /* Update applications version of major and minor if not NULL */
105 if ((major != NULL) && (minor != NULL)) {
114 EGLBoolean EGLAPIENTRY
115 eglTerminate(EGLDisplay dpy)
117 _EGLDisplay *disp = _eglLookupDisplay(dpy);
121 return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
125 drv->API.Terminate(drv, disp);
126 _eglCloseDriver(drv, disp);
135 * A bunch of check functions and declare macros to simply error checking.
137 static INLINE _EGLDriver *
138 _eglCheckDisplay(_EGLDisplay *disp, const char *msg)
141 _eglError(EGL_BAD_DISPLAY, msg);
145 _eglError(EGL_NOT_INITIALIZED, msg);
152 static INLINE _EGLDriver *
153 _eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
155 _EGLDriver *drv = _eglCheckDisplay(disp, msg);
159 _eglError(EGL_BAD_SURFACE, msg);
166 static INLINE _EGLDriver *
167 _eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
169 _EGLDriver *drv = _eglCheckDisplay(disp, msg);
173 _eglError(EGL_BAD_CONTEXT, msg);
180 static INLINE _EGLDriver *
181 _eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
183 _EGLDriver *drv = _eglCheckDisplay(disp, msg);
187 _eglError(EGL_BAD_CONFIG, msg);
194 #define _EGL_DECLARE_DD(dpy) \
195 _EGLDisplay *disp = _eglLookupDisplay(dpy); \
198 drv = _eglCheckDisplay(disp, __FUNCTION__); \
204 #define _EGL_DECLARE_DD_AND_SURFACE(dpy, surface) \
205 _EGLDisplay *disp = _eglLookupDisplay(dpy); \
206 _EGLSurface *surf = _eglLookupSurface((surface), disp); \
209 drv = _eglCheckSurface(disp, surf, __FUNCTION__); \
215 #define _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx) \
216 _EGLDisplay *disp = _eglLookupDisplay(dpy); \
217 _EGLContext *context = _eglLookupContext((ctx), disp); \
220 drv = _eglCheckContext(disp, context, __FUNCTION__); \
226 #ifdef EGL_MESA_screen_surface
229 static INLINE _EGLDriver *
230 _eglCheckScreen(_EGLDisplay *disp, _EGLScreen *scrn, const char *msg)
232 _EGLDriver *drv = _eglCheckDisplay(disp, msg);
236 _eglError(EGL_BAD_SCREEN_MESA, msg);
243 static INLINE _EGLDriver *
244 _eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
246 _EGLDriver *drv = _eglCheckDisplay(disp, msg);
250 _eglError(EGL_BAD_MODE_MESA, msg);
257 #define _EGL_DECLARE_DD_AND_SCREEN(dpy, screen) \
258 _EGLDisplay *disp = _eglLookupDisplay(dpy); \
259 _EGLScreen *scrn = _eglLookupScreen((screen), disp); \
262 drv = _eglCheckScreen(disp, scrn, __FUNCTION__); \
268 #define _EGL_DECLARE_DD_AND_MODE(dpy, mode) \
269 _EGLDisplay *disp = _eglLookupDisplay(dpy); \
270 _EGLMode *m = _eglLookupMode((mode), disp); \
273 drv = _eglCheckMode(disp, m, __FUNCTION__); \
279 #endif /* EGL_MESA_screen_surface */
282 const char * EGLAPIENTRY
283 eglQueryString(EGLDisplay dpy, EGLint name)
285 _EGL_DECLARE_DD(dpy);
286 return drv->API.QueryString(drv, disp, name);
290 EGLBoolean EGLAPIENTRY
291 eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
292 EGLint config_size, EGLint *num_config)
294 _EGL_DECLARE_DD(dpy);
295 return drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
299 EGLBoolean EGLAPIENTRY
300 eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
301 EGLint config_size, EGLint *num_config)
303 _EGL_DECLARE_DD(dpy);
304 return drv->API.ChooseConfig(drv, disp, attrib_list, configs,
305 config_size, num_config);
309 EGLBoolean EGLAPIENTRY
310 eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
311 EGLint attribute, EGLint *value)
313 _EGLDisplay *disp = _eglLookupDisplay(dpy);
314 _EGLConfig *conf = _eglLookupConfig(config, disp);
317 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
321 return drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
325 EGLContext EGLAPIENTRY
326 eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
327 const EGLint *attrib_list)
329 _EGLDisplay *disp = _eglLookupDisplay(dpy);
330 _EGLConfig *conf = _eglLookupConfig(config, disp);
331 _EGLContext *share = _eglLookupContext(share_list, disp);
333 _EGLContext *context;
335 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
337 return EGL_NO_CONTEXT;
338 if (!share && share_list != EGL_NO_CONTEXT) {
339 _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
340 return EGL_NO_CONTEXT;
343 context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
345 return _eglLinkContext(context, disp);
347 return EGL_NO_CONTEXT;
351 EGLBoolean EGLAPIENTRY
352 eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
354 _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
355 _eglUnlinkContext(context);
356 return drv->API.DestroyContext(drv, disp, context);
360 EGLBoolean EGLAPIENTRY
361 eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
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);
370 drv = _eglCheckDisplay(disp, __FUNCTION__);
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__);
379 return drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
383 EGLBoolean EGLAPIENTRY
384 eglQueryContext(EGLDisplay dpy, EGLContext ctx,
385 EGLint attribute, EGLint *value)
387 _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
388 return drv->API.QueryContext(drv, disp, context, attribute, value);
392 EGLSurface EGLAPIENTRY
393 eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
394 NativeWindowType window, const EGLint *attrib_list)
396 _EGLDisplay *disp = _eglLookupDisplay(dpy);
397 _EGLConfig *conf = _eglLookupConfig(config, disp);
401 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
403 return EGL_NO_SURFACE;
405 surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
407 return _eglLinkSurface(surf, disp);
409 return EGL_NO_SURFACE;
413 EGLSurface EGLAPIENTRY
414 eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
415 NativePixmapType pixmap, const EGLint *attrib_list)
417 _EGLDisplay *disp = _eglLookupDisplay(dpy);
418 _EGLConfig *conf = _eglLookupConfig(config, disp);
422 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
424 return EGL_NO_SURFACE;
426 surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
428 return _eglLinkSurface(surf, disp);
430 return EGL_NO_SURFACE;
434 EGLSurface EGLAPIENTRY
435 eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
436 const EGLint *attrib_list)
438 _EGLDisplay *disp = _eglLookupDisplay(dpy);
439 _EGLConfig *conf = _eglLookupConfig(config, disp);
443 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
445 return EGL_NO_SURFACE;
447 surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
449 return _eglLinkSurface(surf, disp);
451 return EGL_NO_SURFACE;
455 EGLBoolean EGLAPIENTRY
456 eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
458 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
459 _eglUnlinkSurface(surf);
460 return drv->API.DestroySurface(drv, disp, surf);
463 EGLBoolean EGLAPIENTRY
464 eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
465 EGLint attribute, EGLint *value)
467 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
468 return drv->API.QuerySurface(drv, disp, surf, attribute, value);
471 EGLBoolean EGLAPIENTRY
472 eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
473 EGLint attribute, EGLint value)
475 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
476 return drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
480 EGLBoolean EGLAPIENTRY
481 eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
483 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
484 return drv->API.BindTexImage(drv, disp, surf, buffer);
488 EGLBoolean EGLAPIENTRY
489 eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
491 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
492 return drv->API.ReleaseTexImage(drv, disp, surf, buffer);
496 EGLBoolean EGLAPIENTRY
497 eglSwapInterval(EGLDisplay dpy, EGLint interval)
499 _EGL_DECLARE_DD(dpy);
500 return drv->API.SwapInterval(drv, disp, interval);
504 EGLBoolean EGLAPIENTRY
505 eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
507 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
508 return drv->API.SwapBuffers(drv, disp, surf);
512 EGLBoolean EGLAPIENTRY
513 eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, NativePixmapType target)
515 _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
516 return drv->API.CopyBuffers(drv, disp, surf, target);
520 EGLBoolean EGLAPIENTRY
523 _EGLDisplay *disp = _eglGetCurrentDisplay();
529 /* a current display is always initialized */
532 return drv->API.WaitGL(drv, disp);
536 EGLBoolean EGLAPIENTRY
537 eglWaitNative(EGLint engine)
539 _EGLDisplay *disp = _eglGetCurrentDisplay();
545 /* a current display is always initialized */
548 return drv->API.WaitNative(drv, disp, engine);
552 EGLDisplay EGLAPIENTRY
553 eglGetCurrentDisplay(void)
555 _EGLDisplay *dpy = _eglGetCurrentDisplay();
556 return _eglGetDisplayHandle(dpy);
560 EGLContext EGLAPIENTRY
561 eglGetCurrentContext(void)
563 _EGLContext *ctx = _eglGetCurrentContext();
564 return _eglGetContextHandle(ctx);
568 EGLSurface EGLAPIENTRY
569 eglGetCurrentSurface(EGLint readdraw)
571 _EGLSurface *s = _eglGetCurrentSurface(readdraw);
572 return _eglGetSurfaceHandle(s);
579 _EGLThreadInfo *t = _eglGetCurrentThread();
580 EGLint e = t->LastError;
581 if (!_eglIsCurrentThreadDummy())
582 t->LastError = EGL_SUCCESS;
587 void (* EGLAPIENTRY eglGetProcAddress(const char *procname))()
589 typedef void (*genericFunc)();
590 struct name_function {
594 static struct name_function egl_functions[] = {
595 /* alphabetical order */
596 { "eglBindTexImage", (_EGLProc) eglBindTexImage },
597 { "eglChooseConfig", (_EGLProc) eglChooseConfig },
598 { "eglCopyBuffers", (_EGLProc) eglCopyBuffers },
599 { "eglCreateContext", (_EGLProc) eglCreateContext },
600 { "eglCreatePbufferSurface", (_EGLProc) eglCreatePbufferSurface },
601 { "eglCreatePixmapSurface", (_EGLProc) eglCreatePixmapSurface },
602 { "eglCreateWindowSurface", (_EGLProc) eglCreateWindowSurface },
603 { "eglDestroyContext", (_EGLProc) eglDestroyContext },
604 { "eglDestroySurface", (_EGLProc) eglDestroySurface },
605 { "eglGetConfigAttrib", (_EGLProc) eglGetConfigAttrib },
606 { "eglGetConfigs", (_EGLProc) eglGetConfigs },
607 { "eglGetCurrentContext", (_EGLProc) eglGetCurrentContext },
608 { "eglGetCurrentDisplay", (_EGLProc) eglGetCurrentDisplay },
609 { "eglGetCurrentSurface", (_EGLProc) eglGetCurrentSurface },
610 { "eglGetDisplay", (_EGLProc) eglGetDisplay },
611 { "eglGetError", (_EGLProc) eglGetError },
612 { "eglGetProcAddress", (_EGLProc) eglGetProcAddress },
613 { "eglInitialize", (_EGLProc) eglInitialize },
614 { "eglMakeCurrent", (_EGLProc) eglMakeCurrent },
615 { "eglQueryContext", (_EGLProc) eglQueryContext },
616 { "eglQueryString", (_EGLProc) eglQueryString },
617 { "eglQuerySurface", (_EGLProc) eglQuerySurface },
618 { "eglReleaseTexImage", (_EGLProc) eglReleaseTexImage },
619 { "eglSurfaceAttrib", (_EGLProc) eglSurfaceAttrib },
620 { "eglSwapBuffers", (_EGLProc) eglSwapBuffers },
621 { "eglSwapInterval", (_EGLProc) eglSwapInterval },
622 { "eglTerminate", (_EGLProc) eglTerminate },
623 { "eglWaitGL", (_EGLProc) eglWaitGL },
624 { "eglWaitNative", (_EGLProc) eglWaitNative },
626 #ifdef EGL_MESA_screen_surface
627 { "eglChooseModeMESA", (_EGLProc) eglChooseModeMESA },
628 { "eglGetModesMESA", (_EGLProc) eglGetModesMESA },
629 { "eglGetModeAttribMESA", (_EGLProc) eglGetModeAttribMESA },
630 { "eglCopyContextMESA", (_EGLProc) eglCopyContextMESA },
631 { "eglGetScreensMESA", (_EGLProc) eglGetScreensMESA },
632 { "eglCreateScreenSurfaceMESA", (_EGLProc) eglCreateScreenSurfaceMESA },
633 { "eglShowScreenSurfaceMESA", (_EGLProc) eglShowScreenSurfaceMESA },
634 { "eglScreenPositionMESA", (_EGLProc) eglScreenPositionMESA },
635 { "eglQueryScreenMESA", (_EGLProc) eglQueryScreenMESA },
636 { "eglQueryScreenSurfaceMESA", (_EGLProc) eglQueryScreenSurfaceMESA },
637 { "eglQueryScreenModeMESA", (_EGLProc) eglQueryScreenModeMESA },
638 { "eglQueryModeStringMESA", (_EGLProc) eglQueryModeStringMESA },
639 #endif /* EGL_MESA_screen_surface */
640 #ifdef EGL_VERSION_1_2
641 { "eglBindAPI", (_EGLProc) eglBindAPI },
642 { "eglCreatePbufferFromClientBuffer", (_EGLProc) eglCreatePbufferFromClientBuffer },
643 { "eglQueryAPI", (_EGLProc) eglQueryAPI },
644 { "eglReleaseThread", (_EGLProc) eglReleaseThread },
645 { "eglWaitClient", (_EGLProc) eglWaitClient },
646 #endif /* EGL_VERSION_1_2 */
650 for (i = 0; egl_functions[i].name; i++) {
651 if (strcmp(egl_functions[i].name, procname) == 0) {
652 return (genericFunc) egl_functions[i].function;
656 /* now loop over drivers to query their procs */
657 for (i = 0; i < _eglGlobal.NumDrivers; i++) {
658 _EGLProc p = _eglGlobal.Drivers[i]->API.GetProcAddress(procname);
668 * EGL_MESA_screen extension
671 EGLBoolean EGLAPIENTRY
672 eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
673 const EGLint *attrib_list, EGLModeMESA *modes,
674 EGLint modes_size, EGLint *num_modes)
676 _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
677 return drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
678 modes, modes_size, num_modes);
682 EGLBoolean EGLAPIENTRY
683 eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
684 EGLint mode_size, EGLint *num_mode)
686 _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
687 return drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
691 EGLBoolean EGLAPIENTRY
692 eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
693 EGLint attribute, EGLint *value)
695 _EGL_DECLARE_DD_AND_MODE(dpy, mode);
696 return drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
700 EGLBoolean EGLAPIENTRY
701 eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
704 _EGLDisplay *disp = _eglLookupDisplay(dpy);
705 _EGLContext *source_context = _eglLookupContext(source, disp);
706 _EGLContext *dest_context = _eglLookupContext(dest, disp);
709 drv = _eglCheckContext(disp, source_context, __FUNCTION__);
710 if (!drv || !dest_context) {
712 _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
716 return drv->API.CopyContextMESA(drv, disp, source_context, dest_context,
722 eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
723 EGLint max_screens, EGLint *num_screens)
725 _EGL_DECLARE_DD(dpy);
726 return drv->API.GetScreensMESA(drv, disp, screens,
727 max_screens, num_screens);
732 eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
733 const EGLint *attrib_list)
735 _EGLDisplay *disp = _eglLookupDisplay(dpy);
736 _EGLConfig *conf = _eglLookupConfig(config, disp);
740 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
742 return EGL_NO_SURFACE;
744 surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
746 return _eglLinkSurface(surf, disp);
748 return EGL_NO_SURFACE;
753 eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
754 EGLSurface surface, EGLModeMESA mode)
756 _EGLDisplay *disp = _eglLookupDisplay(dpy);
757 _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
758 _EGLSurface *surf = _eglLookupSurface(surface, disp);
759 _EGLMode *m = _eglLookupMode(mode, disp);
762 drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
765 if (!surf && surface != EGL_NO_SURFACE)
766 return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
767 if (!m && mode != EGL_NO_MODE_MESA)
768 return _eglError(EGL_BAD_MODE_MESA, __FUNCTION__);
770 return drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
775 eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
777 _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
778 return drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
783 eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
784 EGLint attribute, EGLint *value)
786 _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
787 return drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
792 eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
795 _EGLDisplay *disp = _eglLookupDisplay(dpy);
796 _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
800 drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
804 if (drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf) != EGL_TRUE)
807 *surface = _eglGetSurfaceHandle(surf);
808 return (surf != NULL);
813 eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
815 _EGLDisplay *disp = _eglLookupDisplay(dpy);
816 _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
820 drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
824 if (drv->API.QueryScreenModeMESA(drv, disp, scrn, &m) != EGL_TRUE)
834 eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
836 _EGL_DECLARE_DD_AND_MODE(dpy, mode);
837 return drv->API.QueryModeStringMESA(drv, disp, m);
845 #ifdef EGL_VERSION_1_2
849 * Specify the client API to use for subsequent calls including:
851 * eglGetCurrentContext()
852 * eglGetCurrentDisplay()
853 * eglGetCurrentSurface()
854 * eglMakeCurrent(when the ctx parameter is EGL NO CONTEXT)
857 * See section 3.7 "Rendering Context" in the EGL specification for details.
860 eglBindAPI(EGLenum api)
862 _EGLThreadInfo *t = _eglGetCurrentThread();
864 if (_eglIsCurrentThreadDummy())
865 return _eglError(EGL_BAD_ALLOC, "eglBindAPI");
867 if (!_eglIsApiValid(api))
868 return _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
871 #ifdef EGL_VERSION_1_4
873 if (_eglGlobal.ClientAPIsMask & EGL_OPENGL_BIT) {
874 t->CurrentAPIIndex = _eglConvertApiToIndex(api);
877 _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
880 case EGL_OPENGL_ES_API:
881 if (_eglGlobal.ClientAPIsMask & (EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT)) {
882 t->CurrentAPIIndex = _eglConvertApiToIndex(api);
885 _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
888 if (_eglGlobal.ClientAPIsMask & EGL_OPENVG_BIT) {
889 t->CurrentAPIIndex = _eglConvertApiToIndex(api);
892 _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
902 * Return the last value set with eglBindAPI().
907 /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
908 _EGLThreadInfo *t = _eglGetCurrentThread();
909 return _eglConvertApiFromIndex(t->CurrentAPIIndex);
914 eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
915 EGLClientBuffer buffer, EGLConfig config,
916 const EGLint *attrib_list)
918 _EGLDisplay *disp = _eglLookupDisplay(dpy);
919 _EGLConfig *conf = _eglLookupConfig(config, disp);
923 drv = _eglCheckConfig(disp, conf, __FUNCTION__);
925 return EGL_NO_SURFACE;
927 surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
930 return _eglLinkSurface(surf, disp);
932 return EGL_NO_SURFACE;
937 eglReleaseThread(void)
939 /* unbind current context */
940 if (!_eglIsCurrentThreadDummy()) {
941 _EGLDisplay *disp = _eglGetCurrentDisplay();
945 (void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
949 _eglDestroyCurrentThread();
957 _EGLDisplay *disp = _eglGetCurrentDisplay();
963 /* a current display is always initialized */
966 return drv->API.WaitClient(drv, disp);
970 #endif /* EGL_VERSION_1_2 */