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. Internal objects are linked to a display to
15 * For each public API entry point, the opaque handles are looked up
16 * before being dispatched to the drivers. When it fails to look up
26 * is generated and the driver function is not called. An
27 * uninitialized EGLDisplay has no driver associated with it. When
28 * such display is detected,
34 * Some of the entry points use current display, context, or surface
35 * implicitly. For such entry points, the implicit objects are also
36 * checked before calling the driver function. Other than the
37 * errors listed above,
39 * EGL_BAD_CURRENT_SURFACE
41 * may also be generated.
43 * Notes on naming conventions:
45 * eglFooBar - public EGL function
46 * EGL_FOO_BAR - public EGL token
47 * EGLDatatype - public EGL datatype
49 * _eglFooBar - private EGL function
50 * _EGLDatatype - private EGL datatype, typedef'd struct
51 * _egl_struct - private EGL struct, non-typedef'd
59 #include "eglcontext.h"
60 #include "egldisplay.h"
61 #include "egltypedefs.h"
62 #include "eglglobals.h"
63 #include "eglcurrent.h"
64 #include "egldriver.h"
65 #include "eglsurface.h"
66 #include "eglconfig.h"
67 #include "eglscreen.h"
73 * Macros to help return an API entrypoint.
75 #define _EGL_ERROR(disp, err, ret) \
77 /* EGL error codes are non-zero */ \
79 _eglError(err, __FUNCTION__); \
82 #define _EGL_SUCCESS(disp, ret) _EGL_ERROR(disp, EGL_SUCCESS, ret)
83 /* record EGL_SUCCESS only when ret evaluates to true */
84 #define _EGL_EVAL(disp, ret) _EGL_ERROR(disp, (ret) ? EGL_SUCCESS : 0, ret)
88 * A bunch of macros and checks to simplify error checking.
90 #define _EGL_CHECK_DISPLAY(disp, ret) \
92 _EGLDriver *__drv = _eglCheckDisplay(disp, __FUNCTION__); \
94 return _EGL_ERROR(disp, 0, ret); \
99 #define _EGL_CHECK_OBJECT(disp, type, obj, ret) \
101 _EGLDriver *__drv = _eglCheck ## type(disp, obj, __FUNCTION__); \
103 return _EGL_ERROR(disp, 0, ret); \
106 #define _EGL_CHECK_SURFACE(disp, surf, ret) \
107 _EGL_CHECK_OBJECT(disp, Surface, surf, ret)
108 #define _EGL_CHECK_CONTEXT(disp, context, ret) \
109 _EGL_CHECK_OBJECT(disp, Context, context, ret)
110 #define _EGL_CHECK_CONFIG(disp, conf, ret) \
111 _EGL_CHECK_OBJECT(disp, Config, conf, ret)
112 #define _EGL_CHECK_SCREEN(disp, scrn, ret) \
113 _EGL_CHECK_OBJECT(disp, Screen, scrn, ret)
114 #define _EGL_CHECK_MODE(disp, m, ret) \
115 _EGL_CHECK_OBJECT(disp, Mode, m, ret)
118 static INLINE _EGLDriver
*
119 _eglCheckDisplay(_EGLDisplay
*disp
, const char *msg
)
122 _eglError(EGL_BAD_DISPLAY
, msg
);
125 if (!disp
->Initialized
) {
126 _eglError(EGL_NOT_INITIALIZED
, msg
);
133 static INLINE _EGLDriver
*
134 _eglCheckSurface(_EGLDisplay
*disp
, _EGLSurface
*surf
, const char *msg
)
136 _EGLDriver
*drv
= _eglCheckDisplay(disp
, msg
);
140 _eglError(EGL_BAD_SURFACE
, msg
);
147 static INLINE _EGLDriver
*
148 _eglCheckContext(_EGLDisplay
*disp
, _EGLContext
*context
, const char *msg
)
150 _EGLDriver
*drv
= _eglCheckDisplay(disp
, msg
);
154 _eglError(EGL_BAD_CONTEXT
, msg
);
161 static INLINE _EGLDriver
*
162 _eglCheckConfig(_EGLDisplay
*disp
, _EGLConfig
*conf
, const char *msg
)
164 _EGLDriver
*drv
= _eglCheckDisplay(disp
, msg
);
168 _eglError(EGL_BAD_CONFIG
, msg
);
175 #ifdef EGL_MESA_screen_surface
178 static INLINE _EGLDriver
*
179 _eglCheckScreen(_EGLDisplay
*disp
, _EGLScreen
*scrn
, const char *msg
)
181 _EGLDriver
*drv
= _eglCheckDisplay(disp
, msg
);
185 _eglError(EGL_BAD_SCREEN_MESA
, msg
);
192 static INLINE _EGLDriver
*
193 _eglCheckMode(_EGLDisplay
*disp
, _EGLMode
*m
, const char *msg
)
195 _EGLDriver
*drv
= _eglCheckDisplay(disp
, msg
);
199 _eglError(EGL_BAD_MODE_MESA
, msg
);
206 #endif /* EGL_MESA_screen_surface */
210 * This is typically the first EGL function that an application calls.
211 * We initialize our global vars and create a private _EGLDisplay object.
213 EGLDisplay EGLAPIENTRY
214 eglGetDisplay(EGLNativeDisplayType nativeDisplay
)
217 dpy
= _eglFindDisplay(nativeDisplay
);
219 dpy
= _eglNewDisplay(nativeDisplay
);
221 _eglLinkDisplay(dpy
);
223 return _eglGetDisplayHandle(dpy
);
228 * This is typically the second EGL function that an application calls.
229 * Here we load/initialize the actual hardware driver.
231 EGLBoolean EGLAPIENTRY
232 eglInitialize(EGLDisplay dpy
, EGLint
*major
, EGLint
*minor
)
234 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
235 EGLint major_int
, minor_int
;
238 return _EGL_ERROR(NULL
, EGL_BAD_DISPLAY
, EGL_FALSE
);
240 if (!disp
->Initialized
) {
241 _EGLDriver
*drv
= disp
->Driver
;
244 _eglPreloadDrivers();
245 drv
= _eglMatchDriver(disp
);
247 return _EGL_ERROR(disp
, EGL_NOT_INITIALIZED
, EGL_FALSE
);
250 /* Initialize the particular display now */
251 if (!drv
->API
.Initialize(drv
, disp
, &major_int
, &minor_int
))
252 return _EGL_ERROR(disp
, EGL_NOT_INITIALIZED
, EGL_FALSE
);
254 disp
->APImajor
= major_int
;
255 disp
->APIminor
= minor_int
;
256 snprintf(disp
->Version
, sizeof(disp
->Version
),
257 "%d.%d (%s)", major_int
, minor_int
, drv
->Name
);
259 /* limit to APIs supported by core */
260 disp
->ClientAPIsMask
&= _EGL_API_ALL_BITS
;
263 disp
->Initialized
= EGL_TRUE
;
265 major_int
= disp
->APImajor
;
266 minor_int
= disp
->APIminor
;
269 /* Update applications version of major and minor if not NULL */
270 if ((major
!= NULL
) && (minor
!= NULL
)) {
275 return _EGL_SUCCESS(disp
, EGL_TRUE
);
279 EGLBoolean EGLAPIENTRY
280 eglTerminate(EGLDisplay dpy
)
282 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
285 return _EGL_ERROR(NULL
, EGL_BAD_DISPLAY
, EGL_FALSE
);
287 if (disp
->Initialized
) {
288 _EGLDriver
*drv
= disp
->Driver
;
290 drv
->API
.Terminate(drv
, disp
);
291 /* do not reset disp->Driver */
292 disp
->Initialized
= EGL_FALSE
;
295 return _EGL_SUCCESS(disp
, EGL_TRUE
);
299 const char * EGLAPIENTRY
300 eglQueryString(EGLDisplay dpy
, EGLint name
)
302 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
306 drv
= _EGL_CHECK_DISPLAY(disp
, NULL
);
307 ret
= drv
->API
.QueryString(drv
, disp
, name
);
309 return _EGL_EVAL(disp
, ret
);
313 EGLBoolean EGLAPIENTRY
314 eglGetConfigs(EGLDisplay dpy
, EGLConfig
*configs
,
315 EGLint config_size
, EGLint
*num_config
)
317 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
321 drv
= _EGL_CHECK_DISPLAY(disp
, EGL_FALSE
);
322 ret
= drv
->API
.GetConfigs(drv
, disp
, configs
, config_size
, num_config
);
324 return _EGL_EVAL(disp
, ret
);
328 EGLBoolean EGLAPIENTRY
329 eglChooseConfig(EGLDisplay dpy
, const EGLint
*attrib_list
, EGLConfig
*configs
,
330 EGLint config_size
, EGLint
*num_config
)
332 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
336 drv
= _EGL_CHECK_DISPLAY(disp
, EGL_FALSE
);
337 ret
= drv
->API
.ChooseConfig(drv
, disp
, attrib_list
, configs
,
338 config_size
, num_config
);
340 return _EGL_EVAL(disp
, ret
);
344 EGLBoolean EGLAPIENTRY
345 eglGetConfigAttrib(EGLDisplay dpy
, EGLConfig config
,
346 EGLint attribute
, EGLint
*value
)
348 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
349 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
353 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_FALSE
);
354 ret
= drv
->API
.GetConfigAttrib(drv
, disp
, conf
, attribute
, value
);
356 return _EGL_EVAL(disp
, ret
);
360 EGLContext EGLAPIENTRY
361 eglCreateContext(EGLDisplay dpy
, EGLConfig config
, EGLContext share_list
,
362 const EGLint
*attrib_list
)
364 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
365 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
366 _EGLContext
*share
= _eglLookupContext(share_list
, disp
);
368 _EGLContext
*context
;
371 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_NO_CONTEXT
);
372 if (!share
&& share_list
!= EGL_NO_CONTEXT
)
373 return _EGL_ERROR(disp
, EGL_BAD_CONTEXT
, EGL_NO_CONTEXT
);
375 context
= drv
->API
.CreateContext(drv
, disp
, conf
, share
, attrib_list
);
376 ret
= (context
) ? _eglLinkContext(context
, disp
) : EGL_NO_CONTEXT
;
378 return _EGL_EVAL(disp
, ret
);
382 EGLBoolean EGLAPIENTRY
383 eglDestroyContext(EGLDisplay dpy
, EGLContext ctx
)
385 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
386 _EGLContext
*context
= _eglLookupContext(ctx
, disp
);
390 drv
= _EGL_CHECK_CONTEXT(disp
, context
, EGL_FALSE
);
391 _eglUnlinkContext(context
);
392 ret
= drv
->API
.DestroyContext(drv
, disp
, context
);
394 return _EGL_EVAL(disp
, ret
);
398 EGLBoolean EGLAPIENTRY
399 eglMakeCurrent(EGLDisplay dpy
, EGLSurface draw
, EGLSurface read
,
402 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
403 _EGLContext
*context
= _eglLookupContext(ctx
, disp
);
404 _EGLSurface
*draw_surf
= _eglLookupSurface(draw
, disp
);
405 _EGLSurface
*read_surf
= _eglLookupSurface(read
, disp
);
410 return _EGL_ERROR(disp
, EGL_BAD_DISPLAY
, EGL_FALSE
);
413 /* display is allowed to be uninitialized under certain condition */
414 if (!disp
->Initialized
) {
415 if (draw
!= EGL_NO_SURFACE
|| read
!= EGL_NO_SURFACE
||
416 ctx
!= EGL_NO_CONTEXT
)
417 return _EGL_ERROR(disp
, EGL_BAD_DISPLAY
, EGL_FALSE
);
420 return _EGL_SUCCESS(disp
, EGL_TRUE
);
422 if (!context
&& ctx
!= EGL_NO_CONTEXT
)
423 return _EGL_ERROR(disp
, EGL_BAD_CONTEXT
, EGL_FALSE
);
424 if ((!draw_surf
&& draw
!= EGL_NO_SURFACE
) ||
425 (!read_surf
&& read
!= EGL_NO_SURFACE
))
426 return _EGL_ERROR(disp
, EGL_BAD_SURFACE
, EGL_FALSE
);
428 ret
= drv
->API
.MakeCurrent(drv
, disp
, draw_surf
, read_surf
, context
);
430 return _EGL_EVAL(disp
, ret
);
434 EGLBoolean EGLAPIENTRY
435 eglQueryContext(EGLDisplay dpy
, EGLContext ctx
,
436 EGLint attribute
, EGLint
*value
)
438 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
439 _EGLContext
*context
= _eglLookupContext(ctx
, disp
);
443 drv
= _EGL_CHECK_CONTEXT(disp
, context
, EGL_FALSE
);
444 ret
= drv
->API
.QueryContext(drv
, disp
, context
, attribute
, value
);
446 return _EGL_EVAL(disp
, ret
);
450 EGLSurface EGLAPIENTRY
451 eglCreateWindowSurface(EGLDisplay dpy
, EGLConfig config
,
452 EGLNativeWindowType window
, const EGLint
*attrib_list
)
454 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
455 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
460 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_NO_SURFACE
);
462 surf
= drv
->API
.CreateWindowSurface(drv
, disp
, conf
, window
, attrib_list
);
463 ret
= (surf
) ? _eglLinkSurface(surf
, disp
) : EGL_NO_SURFACE
;
465 return _EGL_EVAL(disp
, ret
);
469 EGLSurface EGLAPIENTRY
470 eglCreatePixmapSurface(EGLDisplay dpy
, EGLConfig config
,
471 EGLNativePixmapType pixmap
, const EGLint
*attrib_list
)
473 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
474 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
479 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_NO_SURFACE
);
481 surf
= drv
->API
.CreatePixmapSurface(drv
, disp
, conf
, pixmap
, attrib_list
);
482 ret
= (surf
) ? _eglLinkSurface(surf
, disp
) : EGL_NO_SURFACE
;
484 return _EGL_EVAL(disp
, ret
);
488 EGLSurface EGLAPIENTRY
489 eglCreatePbufferSurface(EGLDisplay dpy
, EGLConfig config
,
490 const EGLint
*attrib_list
)
492 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
493 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
498 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_NO_SURFACE
);
500 surf
= drv
->API
.CreatePbufferSurface(drv
, disp
, conf
, attrib_list
);
501 ret
= (surf
) ? _eglLinkSurface(surf
, disp
) : EGL_NO_SURFACE
;
503 return _EGL_EVAL(disp
, ret
);
507 EGLBoolean EGLAPIENTRY
508 eglDestroySurface(EGLDisplay dpy
, EGLSurface surface
)
510 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
511 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
515 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
516 _eglUnlinkSurface(surf
);
517 ret
= drv
->API
.DestroySurface(drv
, disp
, surf
);
519 return _EGL_EVAL(disp
, ret
);
522 EGLBoolean EGLAPIENTRY
523 eglQuerySurface(EGLDisplay dpy
, EGLSurface surface
,
524 EGLint attribute
, EGLint
*value
)
526 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
527 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
531 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
532 ret
= drv
->API
.QuerySurface(drv
, disp
, surf
, attribute
, value
);
534 return _EGL_EVAL(disp
, ret
);
537 EGLBoolean EGLAPIENTRY
538 eglSurfaceAttrib(EGLDisplay dpy
, EGLSurface surface
,
539 EGLint attribute
, EGLint value
)
541 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
542 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
546 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
547 ret
= drv
->API
.SurfaceAttrib(drv
, disp
, surf
, attribute
, value
);
549 return _EGL_EVAL(disp
, ret
);
553 EGLBoolean EGLAPIENTRY
554 eglBindTexImage(EGLDisplay dpy
, EGLSurface surface
, EGLint buffer
)
556 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
557 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
561 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
562 ret
= drv
->API
.BindTexImage(drv
, disp
, surf
, buffer
);
564 return _EGL_EVAL(disp
, ret
);
568 EGLBoolean EGLAPIENTRY
569 eglReleaseTexImage(EGLDisplay dpy
, EGLSurface surface
, EGLint buffer
)
571 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
572 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
576 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
577 ret
= drv
->API
.ReleaseTexImage(drv
, disp
, surf
, buffer
);
579 return _EGL_EVAL(disp
, ret
);
583 EGLBoolean EGLAPIENTRY
584 eglSwapInterval(EGLDisplay dpy
, EGLint interval
)
586 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
587 _EGLContext
*ctx
= _eglGetCurrentContext();
592 drv
= _EGL_CHECK_DISPLAY(disp
, EGL_FALSE
);
594 if (!ctx
|| !_eglIsContextLinked(ctx
) || ctx
->Resource
.Display
!= disp
)
595 return _EGL_ERROR(disp
, EGL_BAD_CONTEXT
, EGL_FALSE
);
597 surf
= ctx
->DrawSurface
;
598 if (!_eglIsSurfaceLinked(surf
))
599 return _EGL_ERROR(disp
, EGL_BAD_SURFACE
, EGL_FALSE
);
601 ret
= drv
->API
.SwapInterval(drv
, disp
, surf
, interval
);
603 return _EGL_EVAL(disp
, ret
);
607 EGLBoolean EGLAPIENTRY
608 eglSwapBuffers(EGLDisplay dpy
, EGLSurface surface
)
610 _EGLContext
*ctx
= _eglGetCurrentContext();
611 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
612 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
616 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
618 /* surface must be bound to current context in EGL 1.4 */
619 if (!ctx
|| !_eglIsContextLinked(ctx
) || surf
!= ctx
->DrawSurface
)
620 return _EGL_ERROR(disp
, EGL_BAD_SURFACE
, EGL_FALSE
);
622 ret
= drv
->API
.SwapBuffers(drv
, disp
, surf
);
624 return _EGL_EVAL(disp
, ret
);
628 EGLBoolean EGLAPIENTRY
629 eglCopyBuffers(EGLDisplay dpy
, EGLSurface surface
, EGLNativePixmapType target
)
631 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
632 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
636 drv
= _EGL_CHECK_SURFACE(disp
, surf
, EGL_FALSE
);
637 ret
= drv
->API
.CopyBuffers(drv
, disp
, surf
, target
);
639 return _EGL_EVAL(disp
, ret
);
643 EGLBoolean EGLAPIENTRY
646 _EGLContext
*ctx
= _eglGetCurrentContext();
652 return _EGL_SUCCESS(NULL
, EGL_TRUE
);
653 /* let bad current context imply bad current surface */
654 if (!_eglIsContextLinked(ctx
) || !_eglIsSurfaceLinked(ctx
->DrawSurface
))
655 return _EGL_ERROR(NULL
, EGL_BAD_CURRENT_SURFACE
, EGL_FALSE
);
657 disp
= ctx
->Resource
.Display
;
659 /* a valid current context implies an initialized current display */
660 assert(disp
->Initialized
);
662 ret
= drv
->API
.WaitClient(drv
, disp
, ctx
);
664 return _EGL_EVAL(NULL
, ret
);
668 EGLBoolean EGLAPIENTRY
671 #ifdef EGL_VERSION_1_2
672 _EGLThreadInfo
*t
= _eglGetCurrentThread();
673 EGLint api_index
= t
->CurrentAPIIndex
;
674 EGLint es_index
= _eglConvertApiToIndex(EGL_OPENGL_ES_API
);
677 if (api_index
!= es_index
&& _eglIsCurrentThreadDummy())
678 return _EGL_ERROR(NULL
, EGL_BAD_ALLOC
, EGL_FALSE
);
680 t
->CurrentAPIIndex
= es_index
;
681 ret
= eglWaitClient();
682 t
->CurrentAPIIndex
= api_index
;
685 return eglWaitClient();
690 EGLBoolean EGLAPIENTRY
691 eglWaitNative(EGLint engine
)
693 _EGLContext
*ctx
= _eglGetCurrentContext();
699 return _EGL_SUCCESS(NULL
, EGL_TRUE
);
701 /* let bad current context imply bad current surface */
702 if (!_eglIsContextLinked(ctx
) || !_eglIsSurfaceLinked(ctx
->DrawSurface
))
703 return _EGL_ERROR(NULL
, EGL_BAD_CURRENT_SURFACE
, EGL_FALSE
);
705 disp
= ctx
->Resource
.Display
;
707 /* a valid current context implies an initialized current display */
708 assert(disp
->Initialized
);
710 ret
= drv
->API
.WaitNative(drv
, disp
, engine
);
712 return _EGL_EVAL(NULL
, ret
);
716 EGLDisplay EGLAPIENTRY
717 eglGetCurrentDisplay(void)
719 _EGLContext
*ctx
= _eglGetCurrentContext();
722 ret
= (ctx
) ? _eglGetDisplayHandle(ctx
->Resource
.Display
) : EGL_NO_DISPLAY
;
724 return _EGL_SUCCESS(NULL
, ret
);
728 EGLContext EGLAPIENTRY
729 eglGetCurrentContext(void)
731 _EGLContext
*ctx
= _eglGetCurrentContext();
734 ret
= _eglGetContextHandle(ctx
);
736 return _EGL_SUCCESS(NULL
, ret
);
740 EGLSurface EGLAPIENTRY
741 eglGetCurrentSurface(EGLint readdraw
)
743 _EGLContext
*ctx
= _eglGetCurrentContext();
744 EGLint err
= EGL_SUCCESS
;
749 return _EGL_SUCCESS(NULL
, EGL_NO_SURFACE
);
753 surf
= ctx
->DrawSurface
;
756 surf
= ctx
->ReadSurface
;
760 err
= EGL_BAD_PARAMETER
;
764 ret
= _eglGetSurfaceHandle(surf
);
766 return _EGL_ERROR(NULL
, err
, ret
);
773 _EGLThreadInfo
*t
= _eglGetCurrentThread();
774 EGLint e
= t
->LastError
;
775 if (!_eglIsCurrentThreadDummy())
776 t
->LastError
= EGL_SUCCESS
;
781 __eglMustCastToProperFunctionPointerType EGLAPIENTRY
782 eglGetProcAddress(const char *procname
)
784 static const struct {
787 } egl_functions
[] = {
788 /* extensions only */
789 #ifdef EGL_MESA_screen_surface
790 { "eglChooseModeMESA", (_EGLProc
) eglChooseModeMESA
},
791 { "eglGetModesMESA", (_EGLProc
) eglGetModesMESA
},
792 { "eglGetModeAttribMESA", (_EGLProc
) eglGetModeAttribMESA
},
793 { "eglCopyContextMESA", (_EGLProc
) eglCopyContextMESA
},
794 { "eglGetScreensMESA", (_EGLProc
) eglGetScreensMESA
},
795 { "eglCreateScreenSurfaceMESA", (_EGLProc
) eglCreateScreenSurfaceMESA
},
796 { "eglShowScreenSurfaceMESA", (_EGLProc
) eglShowScreenSurfaceMESA
},
797 { "eglScreenPositionMESA", (_EGLProc
) eglScreenPositionMESA
},
798 { "eglQueryScreenMESA", (_EGLProc
) eglQueryScreenMESA
},
799 { "eglQueryScreenSurfaceMESA", (_EGLProc
) eglQueryScreenSurfaceMESA
},
800 { "eglQueryScreenModeMESA", (_EGLProc
) eglQueryScreenModeMESA
},
801 { "eglQueryModeStringMESA", (_EGLProc
) eglQueryModeStringMESA
},
802 #endif /* EGL_MESA_screen_surface */
803 #ifdef EGL_KHR_image_base
804 { "eglCreateImageKHR", (_EGLProc
) eglCreateImageKHR
},
805 { "eglDestroyImageKHR", (_EGLProc
) eglDestroyImageKHR
},
806 #endif /* EGL_KHR_image_base */
813 return _EGL_SUCCESS(NULL
, NULL
);
816 if (strncmp(procname
, "egl", 3) == 0) {
817 for (i
= 0; egl_functions
[i
].name
; i
++) {
818 if (strcmp(egl_functions
[i
].name
, procname
) == 0) {
819 ret
= egl_functions
[i
].function
;
825 return _EGL_SUCCESS(NULL
, ret
);
827 _eglPreloadDrivers();
829 /* now loop over drivers to query their procs */
830 for (i
= 0; i
< _eglGlobal
.NumDrivers
; i
++) {
831 _EGLDriver
*drv
= _eglGlobal
.Drivers
[i
];
832 ret
= drv
->API
.GetProcAddress(drv
, procname
);
837 return _EGL_SUCCESS(NULL
, ret
);
841 #ifdef EGL_MESA_screen_surface
845 * EGL_MESA_screen extension
848 EGLBoolean EGLAPIENTRY
849 eglChooseModeMESA(EGLDisplay dpy
, EGLScreenMESA screen
,
850 const EGLint
*attrib_list
, EGLModeMESA
*modes
,
851 EGLint modes_size
, EGLint
*num_modes
)
853 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
854 _EGLScreen
*scrn
= _eglLookupScreen(screen
, disp
);
858 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
859 ret
= drv
->API
.ChooseModeMESA(drv
, disp
, scrn
, attrib_list
,
860 modes
, modes_size
, num_modes
);
862 return _EGL_EVAL(disp
, ret
);
866 EGLBoolean EGLAPIENTRY
867 eglGetModesMESA(EGLDisplay dpy
, EGLScreenMESA screen
, EGLModeMESA
*modes
,
868 EGLint mode_size
, EGLint
*num_mode
)
870 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
871 _EGLScreen
*scrn
= _eglLookupScreen(screen
, disp
);
875 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
876 ret
= drv
->API
.GetModesMESA(drv
, disp
, scrn
, modes
, mode_size
, num_mode
);
878 return _EGL_EVAL(disp
, ret
);
882 EGLBoolean EGLAPIENTRY
883 eglGetModeAttribMESA(EGLDisplay dpy
, EGLModeMESA mode
,
884 EGLint attribute
, EGLint
*value
)
886 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
887 _EGLMode
*m
= _eglLookupMode(mode
, disp
);
891 drv
= _EGL_CHECK_MODE(disp
, m
, EGL_FALSE
);
892 ret
= drv
->API
.GetModeAttribMESA(drv
, disp
, m
, attribute
, value
);
894 return _EGL_EVAL(disp
, ret
);
898 EGLBoolean EGLAPIENTRY
899 eglCopyContextMESA(EGLDisplay dpy
, EGLContext source
, EGLContext dest
,
902 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
903 _EGLContext
*source_context
= _eglLookupContext(source
, disp
);
904 _EGLContext
*dest_context
= _eglLookupContext(dest
, disp
);
908 drv
= _EGL_CHECK_CONTEXT(disp
, source_context
, EGL_FALSE
);
910 return _EGL_ERROR(disp
, EGL_BAD_CONTEXT
, EGL_FALSE
);
912 ret
= drv
->API
.CopyContextMESA(drv
, disp
,
913 source_context
, dest_context
, mask
);
915 return _EGL_EVAL(disp
, ret
);
920 eglGetScreensMESA(EGLDisplay dpy
, EGLScreenMESA
*screens
,
921 EGLint max_screens
, EGLint
*num_screens
)
923 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
927 drv
= _EGL_CHECK_DISPLAY(disp
, EGL_FALSE
);
928 ret
= drv
->API
.GetScreensMESA(drv
, disp
, screens
, max_screens
, num_screens
);
930 return _EGL_EVAL(disp
, ret
);
935 eglCreateScreenSurfaceMESA(EGLDisplay dpy
, EGLConfig config
,
936 const EGLint
*attrib_list
)
938 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
939 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
944 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_NO_SURFACE
);
946 surf
= drv
->API
.CreateScreenSurfaceMESA(drv
, disp
, conf
, attrib_list
);
947 ret
= (surf
) ? _eglLinkSurface(surf
, disp
) : EGL_NO_SURFACE
;
949 return _EGL_EVAL(disp
, ret
);
954 eglShowScreenSurfaceMESA(EGLDisplay dpy
, EGLint screen
,
955 EGLSurface surface
, EGLModeMESA mode
)
957 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
958 _EGLScreen
*scrn
= _eglLookupScreen((EGLScreenMESA
) screen
, disp
);
959 _EGLSurface
*surf
= _eglLookupSurface(surface
, disp
);
960 _EGLMode
*m
= _eglLookupMode(mode
, disp
);
964 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
965 if (!surf
&& surface
!= EGL_NO_SURFACE
)
966 return _EGL_ERROR(disp
, EGL_BAD_SURFACE
, EGL_FALSE
);
967 if (!m
&& mode
!= EGL_NO_MODE_MESA
)
968 return _EGL_ERROR(disp
, EGL_BAD_MODE_MESA
, EGL_FALSE
);
970 ret
= drv
->API
.ShowScreenSurfaceMESA(drv
, disp
, scrn
, surf
, m
);
972 return _EGL_EVAL(disp
, ret
);
977 eglScreenPositionMESA(EGLDisplay dpy
, EGLScreenMESA screen
, EGLint x
, EGLint y
)
979 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
980 _EGLScreen
*scrn
= _eglLookupScreen(screen
, disp
);
984 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
985 ret
= drv
->API
.ScreenPositionMESA(drv
, disp
, scrn
, x
, y
);
987 return _EGL_EVAL(disp
, ret
);
992 eglQueryScreenMESA(EGLDisplay dpy
, EGLScreenMESA screen
,
993 EGLint attribute
, EGLint
*value
)
995 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
996 _EGLScreen
*scrn
= _eglLookupScreen(screen
, disp
);
1000 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
1001 ret
= drv
->API
.QueryScreenMESA(drv
, disp
, scrn
, attribute
, value
);
1003 return _EGL_EVAL(disp
, ret
);
1008 eglQueryScreenSurfaceMESA(EGLDisplay dpy
, EGLScreenMESA screen
,
1009 EGLSurface
*surface
)
1011 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
1012 _EGLScreen
*scrn
= _eglLookupScreen((EGLScreenMESA
) screen
, disp
);
1017 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
1018 ret
= drv
->API
.QueryScreenSurfaceMESA(drv
, disp
, scrn
, &surf
);
1020 *surface
= _eglGetSurfaceHandle(surf
);
1022 return _EGL_EVAL(disp
, ret
);
1027 eglQueryScreenModeMESA(EGLDisplay dpy
, EGLScreenMESA screen
, EGLModeMESA
*mode
)
1029 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
1030 _EGLScreen
*scrn
= _eglLookupScreen((EGLScreenMESA
) screen
, disp
);
1035 drv
= _EGL_CHECK_SCREEN(disp
, scrn
, EGL_FALSE
);
1036 ret
= drv
->API
.QueryScreenModeMESA(drv
, disp
, scrn
, &m
);
1040 return _EGL_EVAL(disp
, ret
);
1045 eglQueryModeStringMESA(EGLDisplay dpy
, EGLModeMESA mode
)
1047 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
1048 _EGLMode
*m
= _eglLookupMode(mode
, disp
);
1052 drv
= _EGL_CHECK_MODE(disp
, m
, NULL
);
1053 ret
= drv
->API
.QueryModeStringMESA(drv
, disp
, m
);
1055 return _EGL_EVAL(disp
, ret
);
1059 #endif /* EGL_MESA_screen_surface */
1066 #ifdef EGL_VERSION_1_2
1070 * Specify the client API to use for subsequent calls including:
1071 * eglCreateContext()
1072 * eglGetCurrentContext()
1073 * eglGetCurrentDisplay()
1074 * eglGetCurrentSurface()
1075 * eglMakeCurrent(when the ctx parameter is EGL NO CONTEXT)
1078 * See section 3.7 "Rendering Context" in the EGL specification for details.
1081 eglBindAPI(EGLenum api
)
1083 _EGLThreadInfo
*t
= _eglGetCurrentThread();
1085 if (_eglIsCurrentThreadDummy())
1086 return _EGL_ERROR(NULL
, EGL_BAD_ALLOC
, EGL_FALSE
);
1088 if (!_eglIsApiValid(api
))
1089 return _EGL_ERROR(NULL
, EGL_BAD_PARAMETER
, EGL_FALSE
);
1091 t
->CurrentAPIIndex
= _eglConvertApiToIndex(api
);
1093 return _EGL_SUCCESS(NULL
, EGL_TRUE
);
1098 * Return the last value set with eglBindAPI().
1103 _EGLThreadInfo
*t
= _eglGetCurrentThread();
1106 /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
1107 ret
= _eglConvertApiFromIndex(t
->CurrentAPIIndex
);
1109 return _EGL_SUCCESS(NULL
, ret
);
1114 eglCreatePbufferFromClientBuffer(EGLDisplay dpy
, EGLenum buftype
,
1115 EGLClientBuffer buffer
, EGLConfig config
,
1116 const EGLint
*attrib_list
)
1118 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
1119 _EGLConfig
*conf
= _eglLookupConfig(config
, disp
);
1124 drv
= _EGL_CHECK_CONFIG(disp
, conf
, EGL_NO_SURFACE
);
1126 surf
= drv
->API
.CreatePbufferFromClientBuffer(drv
, disp
, buftype
, buffer
,
1128 ret
= (surf
) ? _eglLinkSurface(surf
, disp
) : EGL_NO_SURFACE
;
1130 return _EGL_EVAL(disp
, ret
);
1135 eglReleaseThread(void)
1137 /* unbind current contexts */
1138 if (!_eglIsCurrentThreadDummy()) {
1139 _EGLThreadInfo
*t
= _eglGetCurrentThread();
1140 EGLint api_index
= t
->CurrentAPIIndex
;
1143 for (i
= 0; i
< _EGL_API_NUM_APIS
; i
++) {
1144 _EGLContext
*ctx
= t
->CurrentContexts
[i
];
1146 _EGLDisplay
*disp
= ctx
->Resource
.Display
;
1147 _EGLDriver
*drv
= disp
->Driver
;
1148 t
->CurrentAPIIndex
= i
;
1149 (void) drv
->API
.MakeCurrent(drv
, disp
, NULL
, NULL
, NULL
);
1153 t
->CurrentAPIIndex
= api_index
;
1156 _eglDestroyCurrentThread();
1158 return _EGL_SUCCESS(NULL
, EGL_TRUE
);
1162 #endif /* EGL_VERSION_1_2 */
1165 #ifdef EGL_KHR_image_base
1169 eglCreateImageKHR(EGLDisplay dpy
, EGLContext ctx
, EGLenum target
,
1170 EGLClientBuffer buffer
, const EGLint
*attr_list
)
1172 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
1173 _EGLContext
*context
= _eglLookupContext(ctx
, disp
);
1178 drv
= _EGL_CHECK_DISPLAY(disp
, EGL_NO_IMAGE_KHR
);
1179 if (!context
&& ctx
!= EGL_NO_CONTEXT
)
1180 return _EGL_ERROR(disp
, EGL_BAD_CONTEXT
, EGL_NO_IMAGE_KHR
);
1182 img
= drv
->API
.CreateImageKHR(drv
,
1183 disp
, context
, target
, buffer
, attr_list
);
1184 ret
= (img
) ? _eglLinkImage(img
, disp
) : EGL_NO_IMAGE_KHR
;
1186 return _EGL_EVAL(disp
, ret
);
1191 eglDestroyImageKHR(EGLDisplay dpy
, EGLImageKHR image
)
1193 _EGLDisplay
*disp
= _eglLookupDisplay(dpy
);
1194 _EGLImage
*img
= _eglLookupImage(image
, disp
);
1198 drv
= _EGL_CHECK_DISPLAY(disp
, EGL_FALSE
);
1200 return _EGL_ERROR(disp
, EGL_BAD_PARAMETER
, EGL_FALSE
);
1202 _eglUnlinkImage(img
);
1203 ret
= drv
->API
.DestroyImageKHR(drv
, disp
, img
);
1205 return _EGL_EVAL(disp
, ret
);
1209 #endif /* EGL_KHR_image_base */