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 /* limit to APIs supported by core */
96 disp
->ClientAPIsMask
&= _EGL_API_ALL_BITS
;
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 static const struct {
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 */
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
;
621 /* preload a driver if there isn't one */
622 if (!_eglGlobal
.NumDrivers
)
623 _eglPreloadDriver(NULL
);
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
);
636 #ifdef EGL_MESA_screen_surface
640 * EGL_MESA_screen extension
643 EGLBoolean EGLAPIENTRY
644 eglChooseModeMESA(EGLDisplay dpy
, EGLScreenMESA screen
,
645 const EGLint
*attrib_list
, EGLModeMESA
*modes
,
646 EGLint modes_size
, EGLint
*num_modes
)
648 _EGL_DECLARE_DD_AND_SCREEN(dpy
, screen
);
649 return drv
->API
.ChooseModeMESA(drv
, disp
, scrn
, attrib_list
,
650 modes
, modes_size
, num_modes
);
654 EGLBoolean EGLAPIENTRY
655 eglGetModesMESA(EGLDisplay dpy
, EGLScreenMESA screen
, EGLModeMESA
*modes
,
656 EGLint mode_size
, EGLint
*num_mode
)
658 _EGL_DECLARE_DD_AND_SCREEN(dpy
, screen
);
659 return drv
->API
.GetModesMESA(drv
, disp
, scrn
, modes
, mode_size
, num_mode
);
663 EGLBoolean EGLAPIENTRY
664 eglGetModeAttribMESA(EGLDisplay dpy
, EGLModeMESA mode
,
665 EGLint attribute
, EGLint
*value
)
667 _EGL_DECLARE_DD_AND_MODE(dpy
, mode
);
668 return drv
->API
.GetModeAttribMESA(drv
, disp
, m
, attribute
, value
);
672 EGLBoolean EGLAPIENTRY
673 eglCopyContextMESA(EGLDisplay dpy
, EGLContext source
, EGLContext dest
,
676 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
677 _EGLContext
*source_context
= _eglLookupContext(source
, disp
);
678 _EGLContext
*dest_context
= _eglLookupContext(dest
, disp
);
681 drv
= _eglCheckContext(disp
, source_context
, __FUNCTION__
);
682 if (!drv
|| !dest_context
) {
684 _eglError(EGL_BAD_CONTEXT
, __FUNCTION__
);
688 return drv
->API
.CopyContextMESA(drv
, disp
, source_context
, dest_context
,
694 eglGetScreensMESA(EGLDisplay dpy
, EGLScreenMESA
*screens
,
695 EGLint max_screens
, EGLint
*num_screens
)
697 _EGL_DECLARE_DD(dpy
);
698 return drv
->API
.GetScreensMESA(drv
, disp
, screens
,
699 max_screens
, num_screens
);
704 eglCreateScreenSurfaceMESA(EGLDisplay dpy
, EGLConfig config
,
705 const EGLint
*attrib_list
)
707 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
708 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
712 drv
= _eglCheckConfig(disp
, conf
, __FUNCTION__
);
714 return EGL_NO_SURFACE
;
716 surf
= drv
->API
.CreateScreenSurfaceMESA(drv
, disp
, conf
, attrib_list
);
718 return _eglLinkSurface(surf
, disp
);
720 return EGL_NO_SURFACE
;
725 eglShowScreenSurfaceMESA(EGLDisplay dpy
, EGLint screen
,
726 EGLSurface surface
, EGLModeMESA mode
)
728 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
729 _EGLScreen
*scrn
= _eglLookupScreen((EGLScreenMESA
) screen
, disp
);
730 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
731 _EGLMode
*m
= _eglLookupMode(mode
, disp
);
734 drv
= _eglCheckScreen(disp
, scrn
, __FUNCTION__
);
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__
);
742 return drv
->API
.ShowScreenSurfaceMESA(drv
, disp
, scrn
, surf
, m
);
747 eglScreenPositionMESA(EGLDisplay dpy
, EGLScreenMESA screen
, EGLint x
, EGLint y
)
749 _EGL_DECLARE_DD_AND_SCREEN(dpy
, screen
);
750 return drv
->API
.ScreenPositionMESA(drv
, disp
, scrn
, x
, y
);
755 eglQueryScreenMESA(EGLDisplay dpy
, EGLScreenMESA screen
,
756 EGLint attribute
, EGLint
*value
)
758 _EGL_DECLARE_DD_AND_SCREEN(dpy
, screen
);
759 return drv
->API
.QueryScreenMESA(drv
, disp
, scrn
, attribute
, value
);
764 eglQueryScreenSurfaceMESA(EGLDisplay dpy
, EGLScreenMESA screen
,
767 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
768 _EGLScreen
*scrn
= _eglLookupScreen((EGLScreenMESA
) screen
, disp
);
772 drv
= _eglCheckScreen(disp
, scrn
, __FUNCTION__
);
776 if (drv
->API
.QueryScreenSurfaceMESA(drv
, disp
, scrn
, &surf
) != EGL_TRUE
)
779 *surface
= _eglGetSurfaceHandle(surf
);
780 return (surf
!= NULL
);
785 eglQueryScreenModeMESA(EGLDisplay dpy
, EGLScreenMESA screen
, EGLModeMESA
*mode
)
787 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
788 _EGLScreen
*scrn
= _eglLookupScreen((EGLScreenMESA
) screen
, disp
);
792 drv
= _eglCheckScreen(disp
, scrn
, __FUNCTION__
);
796 if (drv
->API
.QueryScreenModeMESA(drv
, disp
, scrn
, &m
) != EGL_TRUE
)
806 eglQueryModeStringMESA(EGLDisplay dpy
, EGLModeMESA mode
)
808 _EGL_DECLARE_DD_AND_MODE(dpy
, mode
);
809 return drv
->API
.QueryModeStringMESA(drv
, disp
, m
);
813 #endif /* EGL_MESA_screen_surface */
820 #ifdef EGL_VERSION_1_2
824 * Specify the client API to use for subsequent calls including:
826 * eglGetCurrentContext()
827 * eglGetCurrentDisplay()
828 * eglGetCurrentSurface()
829 * eglMakeCurrent(when the ctx parameter is EGL NO CONTEXT)
832 * See section 3.7 "Rendering Context" in the EGL specification for details.
835 eglBindAPI(EGLenum api
)
837 _EGLThreadInfo
*t
= _eglGetCurrentThread();
839 if (_eglIsCurrentThreadDummy())
840 return _eglError(EGL_BAD_ALLOC
, "eglBindAPI");
842 if (!_eglIsApiValid(api
))
843 return _eglError(EGL_BAD_PARAMETER
, "eglBindAPI");
845 t
->CurrentAPIIndex
= _eglConvertApiToIndex(api
);
851 * Return the last value set with eglBindAPI().
856 /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
857 _EGLThreadInfo
*t
= _eglGetCurrentThread();
858 return _eglConvertApiFromIndex(t
->CurrentAPIIndex
);
863 eglCreatePbufferFromClientBuffer(EGLDisplay dpy
, EGLenum buftype
,
864 EGLClientBuffer buffer
, EGLConfig config
,
865 const EGLint
*attrib_list
)
867 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
868 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
872 drv
= _eglCheckConfig(disp
, conf
, __FUNCTION__
);
874 return EGL_NO_SURFACE
;
876 surf
= drv
->API
.CreatePbufferFromClientBuffer(drv
, disp
, buftype
, buffer
,
879 return _eglLinkSurface(surf
, disp
);
881 return EGL_NO_SURFACE
;
886 eglReleaseThread(void)
888 /* unbind current context */
889 if (!_eglIsCurrentThreadDummy()) {
890 _EGLDisplay
*disp
= _eglGetCurrentDisplay();
894 (void) drv
->API
.MakeCurrent(drv
, disp
, NULL
, NULL
, NULL
);
898 _eglDestroyCurrentThread();
906 _EGLDisplay
*disp
= _eglGetCurrentDisplay();
912 /* a current display is always initialized */
915 return drv
->API
.WaitClient(drv
, disp
);
919 #endif /* EGL_VERSION_1_2 */