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 */