summaryrefslogtreecommitdiff
path: root/src/egl/main
diff options
context:
space:
mode:
Diffstat (limited to 'src/egl/main')
-rw-r--r--src/egl/main/eglapi.c811
-rw-r--r--src/egl/main/eglapi.h1
-rw-r--r--src/egl/main/eglcompiler.h5
-rw-r--r--src/egl/main/eglconfig.c8
-rw-r--r--src/egl/main/eglconfig.h17
-rw-r--r--src/egl/main/eglcurrent.c9
-rw-r--r--src/egl/main/egldisplay.c96
-rw-r--r--src/egl/main/egldisplay.h53
-rw-r--r--src/egl/main/egldriver.c23
-rw-r--r--src/egl/main/eglglobals.h1
-rw-r--r--src/egl/main/eglscreen.c11
-rw-r--r--src/egl/main/eglscreen.h4
-rw-r--r--src/egl/main/egltypedefs.h2
13 files changed, 557 insertions, 484 deletions
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 364ad9c458..647be65220 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -70,98 +70,63 @@
/**
- * This is typically the first EGL function that an application calls.
- * We initialize our global vars and create a private _EGLDisplay object.
- */
-EGLDisplay EGLAPIENTRY
-eglGetDisplay(EGLNativeDisplayType nativeDisplay)
-{
- _EGLDisplay *dpy;
- dpy = _eglFindDisplay(nativeDisplay);
- if (!dpy) {
- dpy = _eglNewDisplay(nativeDisplay);
- if (dpy)
- _eglLinkDisplay(dpy);
- }
- return _eglGetDisplayHandle(dpy);
-}
-
-
-/**
- * This is typically the second EGL function that an application calls.
- * Here we load/initialize the actual hardware driver.
+ * Macros to help return an API entrypoint.
+ *
+ * These macros will unlock the display and record the error code.
*/
-EGLBoolean EGLAPIENTRY
-eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
-{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
- EGLint major_int, minor_int;
-
- if (!disp)
- return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
-
- if (!disp->Initialized) {
- _EGLDriver *drv = disp->Driver;
-
- if (!drv) {
- _eglPreloadDrivers();
- drv = _eglMatchDriver(disp);
- if (!drv)
- return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
- }
+#define RETURN_EGL_ERROR(disp, err, ret) \
+ do { \
+ if (disp) \
+ _eglUnlockDisplay(disp); \
+ /* EGL error codes are non-zero */ \
+ if (err) \
+ _eglError(err, __FUNCTION__); \
+ return ret; \
+ } while (0)
- /* Initialize the particular display now */
- if (!drv->API.Initialize(drv, disp, &major_int, &minor_int))
- return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
+#define RETURN_EGL_SUCCESS(disp, ret) \
+ RETURN_EGL_ERROR(disp, EGL_SUCCESS, ret)
- disp->APImajor = major_int;
- disp->APIminor = minor_int;
- snprintf(disp->Version, sizeof(disp->Version),
- "%d.%d (%s)", major_int, minor_int, drv->Name);
+/* record EGL_SUCCESS only when ret evaluates to true */
+#define RETURN_EGL_EVAL(disp, ret) \
+ RETURN_EGL_ERROR(disp, (ret) ? EGL_SUCCESS : 0, ret)
- /* limit to APIs supported by core */
- disp->ClientAPIsMask &= _EGL_API_ALL_BITS;
- disp->Driver = drv;
- disp->Initialized = EGL_TRUE;
- } else {
- major_int = disp->APImajor;
- minor_int = disp->APIminor;
- }
+/*
+ * A bunch of macros and checks to simplify error checking.
+ */
- /* Update applications version of major and minor if not NULL */
- if ((major != NULL) && (minor != NULL)) {
- *major = major_int;
- *minor = minor_int;
- }
+#define _EGL_CHECK_DISPLAY(disp, ret, drv) \
+ do { \
+ drv = _eglCheckDisplay(disp, __FUNCTION__); \
+ if (!drv) \
+ RETURN_EGL_ERROR(disp, 0, ret); \
+ } while (0)
- return EGL_TRUE;
-}
+#define _EGL_CHECK_OBJECT(disp, type, obj, ret, drv) \
+ do { \
+ drv = _eglCheck ## type(disp, obj, __FUNCTION__); \
+ if (!drv) \
+ RETURN_EGL_ERROR(disp, 0, ret); \
+ } while (0)
+#define _EGL_CHECK_SURFACE(disp, surf, ret, drv) \
+ _EGL_CHECK_OBJECT(disp, Surface, surf, ret, drv)
-EGLBoolean EGLAPIENTRY
-eglTerminate(EGLDisplay dpy)
-{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+#define _EGL_CHECK_CONTEXT(disp, context, ret, drv) \
+ _EGL_CHECK_OBJECT(disp, Context, context, ret, drv)
- if (!disp)
- return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+#define _EGL_CHECK_CONFIG(disp, conf, ret, drv) \
+ _EGL_CHECK_OBJECT(disp, Config, conf, ret, drv)
- if (disp->Initialized) {
- _EGLDriver *drv = disp->Driver;
+#define _EGL_CHECK_SCREEN(disp, scrn, ret, drv) \
+ _EGL_CHECK_OBJECT(disp, Screen, scrn, ret, drv)
- drv->API.Terminate(drv, disp);
- /* do not reset disp->Driver */
- disp->Initialized = EGL_FALSE;
- }
+#define _EGL_CHECK_MODE(disp, m, ret, drv) \
+ _EGL_CHECK_OBJECT(disp, Mode, m, ret, drv)
- return EGL_TRUE;
-}
-/**
- * A bunch of check functions and declare macros to simply error checking.
- */
static INLINE _EGLDriver *
_eglCheckDisplay(_EGLDisplay *disp, const char *msg)
{
@@ -219,38 +184,6 @@ _eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
}
-#define _EGL_DECLARE_DD(dpy) \
- _EGLDisplay *disp = _eglLookupDisplay(dpy); \
- _EGLDriver *drv; \
- do { \
- drv = _eglCheckDisplay(disp, __FUNCTION__); \
- if (!drv) \
- return EGL_FALSE; \
- } while (0)
-
-
-#define _EGL_DECLARE_DD_AND_SURFACE(dpy, surface) \
- _EGLDisplay *disp = _eglLookupDisplay(dpy); \
- _EGLSurface *surf = _eglLookupSurface((surface), disp); \
- _EGLDriver *drv; \
- do { \
- drv = _eglCheckSurface(disp, surf, __FUNCTION__); \
- if (!drv) \
- return EGL_FALSE; \
- } while (0)
-
-
-#define _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx) \
- _EGLDisplay *disp = _eglLookupDisplay(dpy); \
- _EGLContext *context = _eglLookupContext((ctx), disp); \
- _EGLDriver *drv; \
- do { \
- drv = _eglCheckContext(disp, context, __FUNCTION__); \
- if (!drv) \
- return EGL_FALSE; \
- } while (0)
-
-
#ifdef EGL_MESA_screen_surface
@@ -282,36 +215,127 @@ _eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
}
-#define _EGL_DECLARE_DD_AND_SCREEN(dpy, screen) \
- _EGLDisplay *disp = _eglLookupDisplay(dpy); \
- _EGLScreen *scrn = _eglLookupScreen((screen), disp); \
- _EGLDriver *drv; \
- do { \
- drv = _eglCheckScreen(disp, scrn, __FUNCTION__); \
- if (!drv) \
- return EGL_FALSE; \
- } while (0)
+#endif /* EGL_MESA_screen_surface */
-#define _EGL_DECLARE_DD_AND_MODE(dpy, mode) \
- _EGLDisplay *disp = _eglLookupDisplay(dpy); \
- _EGLMode *m = _eglLookupMode((mode), disp); \
- _EGLDriver *drv; \
- do { \
- drv = _eglCheckMode(disp, m, __FUNCTION__); \
- if (!drv) \
- return EGL_FALSE; \
- } while (0)
+/**
+ * Lookup and lock a display.
+ */
+static INLINE _EGLDisplay *
+_eglLockDisplay(EGLDisplay display)
+{
+ _EGLDisplay *dpy = _eglLookupDisplay(display);
+ if (dpy)
+ _eglLockMutex(&dpy->Mutex);
+ return dpy;
+}
-#endif /* EGL_MESA_screen_surface */
+/**
+ * Unlock a display.
+ */
+static INLINE void
+_eglUnlockDisplay(_EGLDisplay *dpy)
+{
+ _eglUnlockMutex(&dpy->Mutex);
+}
+
+
+/**
+ * This is typically the first EGL function that an application calls.
+ * It associates a private _EGLDisplay object to the native display.
+ */
+EGLDisplay EGLAPIENTRY
+eglGetDisplay(EGLNativeDisplayType nativeDisplay)
+{
+ _EGLDisplay *dpy = _eglFindDisplay(nativeDisplay);
+ return _eglGetDisplayHandle(dpy);
+}
+
+
+/**
+ * This is typically the second EGL function that an application calls.
+ * Here we load/initialize the actual hardware driver.
+ */
+EGLBoolean EGLAPIENTRY
+eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ EGLint major_int, minor_int;
+
+ if (!disp)
+ RETURN_EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
+
+ if (!disp->Initialized) {
+ _EGLDriver *drv = disp->Driver;
+
+ if (!drv) {
+ _eglPreloadDrivers();
+ drv = _eglMatchDriver(disp);
+ if (!drv)
+ RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
+ }
+
+ /* Initialize the particular display now */
+ if (!drv->API.Initialize(drv, disp, &major_int, &minor_int))
+ RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
+
+ disp->APImajor = major_int;
+ disp->APIminor = minor_int;
+ snprintf(disp->Version, sizeof(disp->Version),
+ "%d.%d (%s)", major_int, minor_int, drv->Name);
+
+ /* limit to APIs supported by core */
+ disp->ClientAPIsMask &= _EGL_API_ALL_BITS;
+
+ disp->Driver = drv;
+ disp->Initialized = EGL_TRUE;
+ } else {
+ major_int = disp->APImajor;
+ minor_int = disp->APIminor;
+ }
+
+ /* Update applications version of major and minor if not NULL */
+ if ((major != NULL) && (minor != NULL)) {
+ *major = major_int;
+ *minor = minor_int;
+ }
+
+ RETURN_EGL_SUCCESS(disp, EGL_TRUE);
+}
+
+
+EGLBoolean EGLAPIENTRY
+eglTerminate(EGLDisplay dpy)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+
+ if (!disp)
+ RETURN_EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
+
+ if (disp->Initialized) {
+ _EGLDriver *drv = disp->Driver;
+
+ drv->API.Terminate(drv, disp);
+ /* do not reset disp->Driver */
+ disp->Initialized = EGL_FALSE;
+ }
+
+ RETURN_EGL_SUCCESS(disp, EGL_TRUE);
+}
const char * EGLAPIENTRY
eglQueryString(EGLDisplay dpy, EGLint name)
{
- _EGL_DECLARE_DD(dpy);
- return drv->API.QueryString(drv, disp, name);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLDriver *drv;
+ const char *ret;
+
+ _EGL_CHECK_DISPLAY(disp, NULL, drv);
+ ret = drv->API.QueryString(drv, disp, name);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -319,8 +343,14 @@ EGLBoolean EGLAPIENTRY
eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
EGLint config_size, EGLint *num_config)
{
- _EGL_DECLARE_DD(dpy);
- return drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+ ret = drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -328,9 +358,15 @@ EGLBoolean EGLAPIENTRY
eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
EGLint config_size, EGLint *num_config)
{
- _EGL_DECLARE_DD(dpy);
- return drv->API.ChooseConfig(drv, disp, attrib_list, configs,
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+ ret = drv->API.ChooseConfig(drv, disp, attrib_list, configs,
config_size, num_config);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -338,15 +374,15 @@ EGLBoolean EGLAPIENTRY
eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
EGLint attribute, EGLint *value)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
+ EGLBoolean ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_FALSE;
+ _EGL_CHECK_CONFIG(disp, conf, EGL_FALSE, drv);
+ ret = drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
- return drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -354,34 +390,37 @@ EGLContext EGLAPIENTRY
eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLContext *share = _eglLookupContext(share_list, disp);
_EGLDriver *drv;
_EGLContext *context;
+ EGLContext ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_NO_CONTEXT;
- if (!share && share_list != EGL_NO_CONTEXT) {
- _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
- return EGL_NO_CONTEXT;
- }
+ _EGL_CHECK_CONFIG(disp, conf, EGL_NO_CONTEXT, drv);
+ if (!share && share_list != EGL_NO_CONTEXT)
+ RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
- if (context)
- return _eglLinkContext(context, disp);
- else
- return EGL_NO_CONTEXT;
+ ret = (context) ? _eglLinkContext(context, disp) : EGL_NO_CONTEXT;
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{
- _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLContext *context = _eglLookupContext(ctx, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
_eglUnlinkContext(context);
- return drv->API.DestroyContext(drv, disp, context);
+ ret = drv->API.DestroyContext(drv, disp, context);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -389,32 +428,35 @@ EGLBoolean EGLAPIENTRY
eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
EGLContext ctx)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLContext *context = _eglLookupContext(ctx, disp);
_EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
_EGLSurface *read_surf = _eglLookupSurface(read, disp);
_EGLDriver *drv;
+ EGLBoolean ret;
if (!disp)
- return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
drv = disp->Driver;
/* display is allowed to be uninitialized under certain condition */
if (!disp->Initialized) {
if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE ||
ctx != EGL_NO_CONTEXT)
- return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
}
if (!drv)
- return EGL_TRUE;
+ RETURN_EGL_SUCCESS(disp, EGL_TRUE);
if (!context && ctx != EGL_NO_CONTEXT)
- return _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
if ((!draw_surf && draw != EGL_NO_SURFACE) ||
(!read_surf && read != EGL_NO_SURFACE))
- return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
+
+ ret = drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
- return drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -422,8 +464,15 @@ EGLBoolean EGLAPIENTRY
eglQueryContext(EGLDisplay dpy, EGLContext ctx,
EGLint attribute, EGLint *value)
{
- _EGL_DECLARE_DD_AND_CONTEXT(dpy, ctx);
- return drv->API.QueryContext(drv, disp, context, attribute, value);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLContext *context = _eglLookupContext(ctx, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
+ ret = drv->API.QueryContext(drv, disp, context, attribute, value);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -431,20 +480,18 @@ EGLSurface EGLAPIENTRY
eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
EGLNativeWindowType window, const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
+ EGLSurface ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_NO_SURFACE;
+ _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
- if (surf)
- return _eglLinkSurface(surf, disp);
- else
- return EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -452,20 +499,18 @@ EGLSurface EGLAPIENTRY
eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
+ EGLSurface ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_NO_SURFACE;
+ _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
- if (surf)
- return _eglLinkSurface(surf, disp);
- else
- return EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -473,79 +518,118 @@ EGLSurface EGLAPIENTRY
eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
+ EGLSurface ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_NO_SURFACE;
+ _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
- if (surf)
- return _eglLinkSurface(surf, disp);
- else
- return EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
{
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
_eglUnlinkSurface(surf);
- return drv->API.DestroySurface(drv, disp, surf);
+ ret = drv->API.DestroySurface(drv, disp, surf);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
EGLint attribute, EGLint *value)
{
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
- return drv->API.QuerySurface(drv, disp, surf, attribute, value);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+ ret = drv->API.QuerySurface(drv, disp, surf, attribute, value);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
EGLint attribute, EGLint value)
{
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
- return drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+ ret = drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
- return drv->API.BindTexImage(drv, disp, surf, buffer);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+ ret = drv->API.BindTexImage(drv, disp, surf, buffer);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
- return drv->API.ReleaseTexImage(drv, disp, surf, buffer);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+ ret = drv->API.ReleaseTexImage(drv, disp, surf, buffer);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglSwapInterval(EGLDisplay dpy, EGLint interval)
{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLContext *ctx = _eglGetCurrentContext();
_EGLSurface *surf;
- _EGL_DECLARE_DD(dpy);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
if (!ctx || !_eglIsContextLinked(ctx) || ctx->Resource.Display != disp)
- return _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
surf = ctx->DrawSurface;
if (!_eglIsSurfaceLinked(surf))
- return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
+
+ ret = drv->API.SwapInterval(drv, disp, surf, interval);
- return drv->API.SwapInterval(drv, disp, surf, interval);
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -553,21 +637,35 @@ EGLBoolean EGLAPIENTRY
eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
{
_EGLContext *ctx = _eglGetCurrentContext();
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
/* surface must be bound to current context in EGL 1.4 */
if (!ctx || !_eglIsContextLinked(ctx) || surf != ctx->DrawSurface)
- return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
+
+ ret = drv->API.SwapBuffers(drv, disp, surf);
- return drv->API.SwapBuffers(drv, disp, surf);
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean EGLAPIENTRY
eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
- _EGL_DECLARE_DD_AND_SURFACE(dpy, surface);
- return drv->API.CopyBuffers(drv, disp, surf, target);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+ ret = drv->API.CopyBuffers(drv, disp, surf, target);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -577,19 +675,24 @@ eglWaitClient(void)
_EGLContext *ctx = _eglGetCurrentContext();
_EGLDisplay *disp;
_EGLDriver *drv;
+ EGLBoolean ret;
if (!ctx)
- return EGL_TRUE;
+ RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
+
+ disp = ctx->Resource.Display;
+ _eglLockMutex(&disp->Mutex);
+
/* let bad current context imply bad current surface */
if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface))
- return _eglError(EGL_BAD_CURRENT_SURFACE, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
/* a valid current context implies an initialized current display */
- disp = ctx->Resource.Display;
assert(disp->Initialized);
drv = disp->Driver;
+ ret = drv->API.WaitClient(drv, disp, ctx);
- return drv->API.WaitClient(drv, disp, ctx);
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -603,7 +706,7 @@ eglWaitGL(void)
EGLBoolean ret;
if (api_index != es_index && _eglIsCurrentThreadDummy())
- return _eglError(EGL_BAD_ALLOC, "eglWaitGL");
+ RETURN_EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
t->CurrentAPIIndex = es_index;
ret = eglWaitClient();
@@ -621,19 +724,24 @@ eglWaitNative(EGLint engine)
_EGLContext *ctx = _eglGetCurrentContext();
_EGLDisplay *disp;
_EGLDriver *drv;
+ EGLBoolean ret;
if (!ctx)
- return EGL_TRUE;
+ RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
+
+ disp = ctx->Resource.Display;
+ _eglLockMutex(&disp->Mutex);
+
/* let bad current context imply bad current surface */
if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface))
- return _eglError(EGL_BAD_CURRENT_SURFACE, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
/* a valid current context implies an initialized current display */
- disp = ctx->Resource.Display;
assert(disp->Initialized);
drv = disp->Driver;
+ ret = drv->API.WaitNative(drv, disp, engine);
- return drv->API.WaitNative(drv, disp, engine);
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -641,7 +749,11 @@ EGLDisplay EGLAPIENTRY
eglGetCurrentDisplay(void)
{
_EGLContext *ctx = _eglGetCurrentContext();
- return (ctx) ? _eglGetDisplayHandle(ctx->Resource.Display) : EGL_NO_DISPLAY;
+ EGLDisplay ret;
+
+ ret = (ctx) ? _eglGetDisplayHandle(ctx->Resource.Display) : EGL_NO_DISPLAY;
+
+ RETURN_EGL_SUCCESS(NULL, ret);
}
@@ -649,7 +761,11 @@ EGLContext EGLAPIENTRY
eglGetCurrentContext(void)
{
_EGLContext *ctx = _eglGetCurrentContext();
- return _eglGetContextHandle(ctx);
+ EGLContext ret;
+
+ ret = _eglGetContextHandle(ctx);
+
+ RETURN_EGL_SUCCESS(NULL, ret);
}
@@ -657,10 +773,12 @@ EGLSurface EGLAPIENTRY
eglGetCurrentSurface(EGLint readdraw)
{
_EGLContext *ctx = _eglGetCurrentContext();
+ EGLint err = EGL_SUCCESS;
_EGLSurface *surf;
+ EGLSurface ret;
if (!ctx)
- return EGL_NO_SURFACE;
+ RETURN_EGL_SUCCESS(NULL, EGL_NO_SURFACE);
switch (readdraw) {
case EGL_DRAW:
@@ -670,12 +788,14 @@ eglGetCurrentSurface(EGLint readdraw)
surf = ctx->ReadSurface;
break;
default:
- _eglError(EGL_BAD_PARAMETER, __FUNCTION__);
surf = NULL;
+ err = EGL_BAD_PARAMETER;
break;
}
- return _eglGetSurfaceHandle(surf);
+ ret = _eglGetSurfaceHandle(surf);
+
+ RETURN_EGL_ERROR(NULL, err, ret);
}
@@ -719,27 +839,34 @@ eglGetProcAddress(const char *procname)
{ NULL, NULL }
};
EGLint i;
+ _EGLProc ret;
if (!procname)
- return NULL;
+ RETURN_EGL_SUCCESS(NULL, NULL);
+
+ ret = NULL;
if (strncmp(procname, "egl", 3) == 0) {
for (i = 0; egl_functions[i].name; i++) {
- if (strcmp(egl_functions[i].name, procname) == 0)
- return egl_functions[i].function;
+ if (strcmp(egl_functions[i].name, procname) == 0) {
+ ret = egl_functions[i].function;
+ break;
+ }
}
}
+ if (ret)
+ RETURN_EGL_SUCCESS(NULL, ret);
_eglPreloadDrivers();
/* now loop over drivers to query their procs */
for (i = 0; i < _eglGlobal.NumDrivers; i++) {
_EGLDriver *drv = _eglGlobal.Drivers[i];
- _EGLProc p = drv->API.GetProcAddress(drv, procname);
- if (p)
- return p;
+ ret = drv->API.GetProcAddress(drv, procname);
+ if (ret)
+ break;
}
- return NULL;
+ RETURN_EGL_SUCCESS(NULL, ret);
}
@@ -755,9 +882,16 @@ eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
const EGLint *attrib_list, EGLModeMESA *modes,
EGLint modes_size, EGLint *num_modes)
{
- _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
- return drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
- modes, modes_size, num_modes);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLScreen *scrn = _eglLookupScreen(screen, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
+ ret = drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
+ modes, modes_size, num_modes);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -765,8 +899,15 @@ EGLBoolean EGLAPIENTRY
eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
EGLint mode_size, EGLint *num_mode)
{
- _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
- return drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLScreen *scrn = _eglLookupScreen(screen, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
+ ret = drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -774,8 +915,15 @@ EGLBoolean EGLAPIENTRY
eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
EGLint attribute, EGLint *value)
{
- _EGL_DECLARE_DD_AND_MODE(dpy, mode);
- return drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLMode *m = _eglLookupMode(mode, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_MODE(disp, m, EGL_FALSE, drv);
+ ret = drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -783,20 +931,20 @@ EGLBoolean EGLAPIENTRY
eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
EGLint mask)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLContext *source_context = _eglLookupContext(source, disp);
_EGLContext *dest_context = _eglLookupContext(dest, disp);
_EGLDriver *drv;
+ EGLBoolean ret;
- drv = _eglCheckContext(disp, source_context, __FUNCTION__);
- if (!drv || !dest_context) {
- if (drv)
- _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
- return EGL_FALSE;
- }
+ _EGL_CHECK_CONTEXT(disp, source_context, EGL_FALSE, drv);
+ if (!dest_context)
+ RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
+
+ ret = drv->API.CopyContextMESA(drv, disp,
+ source_context, dest_context, mask);
- return drv->API.CopyContextMESA(drv, disp, source_context, dest_context,
- mask);
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -804,9 +952,14 @@ EGLBoolean
eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
EGLint max_screens, EGLint *num_screens)
{
- _EGL_DECLARE_DD(dpy);
- return drv->API.GetScreensMESA(drv, disp, screens,
- max_screens, num_screens);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+ ret = drv->API.GetScreensMESA(drv, disp, screens, max_screens, num_screens);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -814,20 +967,18 @@ EGLSurface
eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
+ EGLSurface ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_NO_SURFACE;
+ _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
- if (surf)
- return _eglLinkSurface(surf, disp);
- else
- return EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -835,29 +986,37 @@ EGLBoolean
eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
EGLSurface surface, EGLModeMESA mode)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
_EGLSurface *surf = _eglLookupSurface(surface, disp);
_EGLMode *m = _eglLookupMode(mode, disp);
_EGLDriver *drv;
+ EGLBoolean ret;
- drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
- if (!drv)
- return EGL_FALSE;
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
if (!surf && surface != EGL_NO_SURFACE)
- return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
if (!m && mode != EGL_NO_MODE_MESA)
- return _eglError(EGL_BAD_MODE_MESA, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_MODE_MESA, EGL_FALSE);
- return drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
+ ret = drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean
eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
{
- _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
- return drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLScreen *scrn = _eglLookupScreen(screen, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
+ ret = drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -865,8 +1024,15 @@ EGLBoolean
eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
EGLint attribute, EGLint *value)
{
- _EGL_DECLARE_DD_AND_SCREEN(dpy, screen);
- return drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLScreen *scrn = _eglLookupScreen(screen, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
+ ret = drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -874,49 +1040,51 @@ EGLBoolean
eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
EGLSurface *surface)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
_EGLDriver *drv;
_EGLSurface *surf;
+ EGLBoolean ret;
- drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
- if (!drv)
- return EGL_FALSE;
-
- if (drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf) != EGL_TRUE)
- surf = NULL;
- if (surface)
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
+ ret = drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf);
+ if (ret && surface)
*surface = _eglGetSurfaceHandle(surf);
- return (surf != NULL);
+
+ RETURN_EGL_EVAL(disp, ret);
}
EGLBoolean
eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
_EGLDriver *drv;
_EGLMode *m;
+ EGLBoolean ret;
- drv = _eglCheckScreen(disp, scrn, __FUNCTION__);
- if (!drv)
- return EGL_FALSE;
-
- if (drv->API.QueryScreenModeMESA(drv, disp, scrn, &m) != EGL_TRUE)
- m = NULL;
- if (mode)
+ _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
+ ret = drv->API.QueryScreenModeMESA(drv, disp, scrn, &m);
+ if (ret && mode)
*mode = m->Handle;
- return (m != NULL);
+ RETURN_EGL_EVAL(disp, ret);
}
const char *
eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
{
- _EGL_DECLARE_DD_AND_MODE(dpy, mode);
- return drv->API.QueryModeStringMESA(drv, disp, m);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLMode *m = _eglLookupMode(mode, disp);
+ _EGLDriver *drv;
+ const char *ret;
+
+ _EGL_CHECK_MODE(disp, m, NULL, drv);
+ ret = drv->API.QueryModeStringMESA(drv, disp, m);
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -947,13 +1115,14 @@ eglBindAPI(EGLenum api)
_EGLThreadInfo *t = _eglGetCurrentThread();
if (_eglIsCurrentThreadDummy())
- return _eglError(EGL_BAD_ALLOC, "eglBindAPI");
+ RETURN_EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
if (!_eglIsApiValid(api))
- return _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
+ RETURN_EGL_ERROR(NULL, EGL_BAD_PARAMETER, EGL_FALSE);
t->CurrentAPIIndex = _eglConvertApiToIndex(api);
- return EGL_TRUE;
+
+ RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
}
@@ -963,9 +1132,13 @@ eglBindAPI(EGLenum api)
EGLenum
eglQueryAPI(void)
{
- /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
_EGLThreadInfo *t = _eglGetCurrentThread();
- return _eglConvertApiFromIndex(t->CurrentAPIIndex);
+ EGLenum ret;
+
+ /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
+ ret = _eglConvertApiFromIndex(t->CurrentAPIIndex);
+
+ RETURN_EGL_SUCCESS(NULL, ret);
}
@@ -974,21 +1147,19 @@ eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
EGLClientBuffer buffer, EGLConfig config,
const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
+ EGLSurface ret;
- drv = _eglCheckConfig(disp, conf, __FUNCTION__);
- if (!drv)
- return EGL_NO_SURFACE;
+ _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
conf, attrib_list);
- if (surf)
- return _eglLinkSurface(surf, disp);
- else
- return EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+ RETURN_EGL_EVAL(disp, ret);
}
@@ -1005,9 +1176,14 @@ eglReleaseThread(void)
_EGLContext *ctx = t->CurrentContexts[i];
if (ctx) {
_EGLDisplay *disp = ctx->Resource.Display;
- _EGLDriver *drv = disp->Driver;
+ _EGLDriver *drv;
+
t->CurrentAPIIndex = i;
+
+ _eglLockMutex(&disp->Mutex);
+ drv = disp->Driver;
(void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
+ _eglUnlockMutex(&disp->Mutex);
}
}
@@ -1015,7 +1191,8 @@ eglReleaseThread(void)
}
_eglDestroyCurrentThread();
- return EGL_TRUE;
+
+ RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
}
@@ -1029,42 +1206,40 @@ EGLImageKHR
eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
EGLClientBuffer buffer, const EGLint *attr_list)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLContext *context = _eglLookupContext(ctx, disp);
_EGLDriver *drv;
_EGLImage *img;
+ EGLImageKHR ret;
- drv = _eglCheckDisplay(disp, __FUNCTION__);
- if (!drv)
- return EGL_NO_IMAGE_KHR;
- if (!context && ctx != EGL_NO_CONTEXT) {
- _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
- return EGL_NO_IMAGE_KHR;
- }
+ _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
+ if (!context && ctx != EGL_NO_CONTEXT)
+ RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
img = drv->API.CreateImageKHR(drv,
disp, context, target, buffer, attr_list);
- if (img)
- return _eglLinkImage(img, disp);
- else
- return EGL_NO_IMAGE_KHR;
+ ret = (img) ? _eglLinkImage(img, disp) : EGL_NO_IMAGE_KHR;
+
+ RETURN_EGL_EVAL(disp, ret);
}
-EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
+EGLBoolean
+eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
{
- _EGLDisplay *disp = _eglLookupDisplay(dpy);
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLImage *img = _eglLookupImage(image, disp);
_EGLDriver *drv;
+ EGLBoolean ret;
- drv = _eglCheckDisplay(disp, __FUNCTION__);
- if (!drv)
- return EGL_FALSE;
+ _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
if (!img)
- return _eglError(EGL_BAD_PARAMETER, __FUNCTION__);
+ RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
_eglUnlinkImage(img);
- return drv->API.DestroyImageKHR(drv, disp, img);
+ ret = drv->API.DestroyImageKHR(drv, disp, img);
+
+ RETURN_EGL_EVAL(disp, ret);
}
diff --git a/src/egl/main/eglapi.h b/src/egl/main/eglapi.h
index c3676ec56a..3e2ba8dd41 100644
--- a/src/egl/main/eglapi.h
+++ b/src/egl/main/eglapi.h
@@ -45,6 +45,7 @@ typedef const char *(*QueryString_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint n
typedef EGLBoolean (*WaitClient_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx);
typedef EGLBoolean (*WaitNative_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine);
+/* this function may be called from multiple threads at the same time */
typedef _EGLProc (*GetProcAddress_t)(_EGLDriver *drv, const char *procname);
diff --git a/src/egl/main/eglcompiler.h b/src/egl/main/eglcompiler.h
index d844fbb0ef..401a9cf56a 100644
--- a/src/egl/main/eglcompiler.h
+++ b/src/egl/main/eglcompiler.h
@@ -64,8 +64,7 @@
/**
* Function visibility
*/
-#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303) \
- || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
# define PUBLIC __attribute__((visibility("default")))
#else
# define PUBLIC
@@ -79,7 +78,7 @@
#ifndef __FUNCTION__
# if defined(__VMS)
# define __FUNCTION__ "VMS$NL:"
-# elif ((!defined __GNUC__) || (__GNUC__ < 2)) && (!defined __xlC__) && \
+# elif (!defined __GNUC__) && (!defined __xlC__) && \
(!defined(_MSC_VER) || _MSC_VER < 1300)
# if (__STDC_VERSION__ >= 199901L) /* C99 */ || \
(defined(__SUNPRO_C) && defined(__C99FEATURES__))
diff --git a/src/egl/main/eglconfig.c b/src/egl/main/eglconfig.c
index 1190f8cdd5..21d13cba90 100644
--- a/src/egl/main/eglconfig.c
+++ b/src/egl/main/eglconfig.c
@@ -76,9 +76,6 @@ _eglAddConfig(_EGLDisplay *dpy, _EGLConfig *conf)
}
-#ifndef _EGL_SKIP_HANDLE_CHECK
-
-
EGLBoolean
_eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy)
{
@@ -96,9 +93,6 @@ _eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy)
}
-#endif /* _EGL_SKIP_HANDLE_CHECK */
-
-
enum {
/* types */
ATTRIB_TYPE_INTEGER,
@@ -112,7 +106,7 @@ enum {
ATTRIB_CRITERION_ATLEAST,
ATTRIB_CRITERION_MASK,
ATTRIB_CRITERION_SPECIAL,
- ATTRIB_CRITERION_IGNORE,
+ ATTRIB_CRITERION_IGNORE
};
diff --git a/src/egl/main/eglconfig.h b/src/egl/main/eglconfig.h
index 56ec95fe9a..ced060f779 100644
--- a/src/egl/main/eglconfig.h
+++ b/src/egl/main/eglconfig.h
@@ -92,27 +92,10 @@ PUBLIC EGLConfig
_eglAddConfig(_EGLDisplay *dpy, _EGLConfig *conf);
-#ifndef _EGL_SKIP_HANDLE_CHECK
-
-
extern EGLBoolean
_eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy);
-#else
-
-
-static INLINE EGLBoolean
-_eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy)
-{
- _EGLConfig *conf = (_EGLConfig *) config;
- return (dpy && conf && conf->Display == dpy);
-}
-
-
-#endif /* _EGL_SKIP_HANDLE_CHECK */
-
-
/**
* Lookup a handle to find the linked config.
* Return NULL if the handle has no corresponding linked config.
diff --git a/src/egl/main/eglcurrent.c b/src/egl/main/eglcurrent.c
index 989c19a2fa..c697bf796d 100644
--- a/src/egl/main/eglcurrent.c
+++ b/src/egl/main/eglcurrent.c
@@ -248,19 +248,20 @@ _eglGetCurrentContext(void)
/**
- * Record EGL error code.
+ * Record EGL error code and return EGL_FALSE.
*/
EGLBoolean
_eglError(EGLint errCode, const char *msg)
{
_EGLThreadInfo *t = _eglGetCurrentThread();
- const char *s;
if (t == &dummy_thread)
return EGL_FALSE;
- if (t->LastError == EGL_SUCCESS) {
- t->LastError = errCode;
+ t->LastError = errCode;
+
+ if (errCode != EGL_SUCCESS) {
+ const char *s;
switch (errCode) {
case EGL_BAD_ACCESS:
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index d7a8d14292..5dc5fd9719 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -45,72 +45,8 @@ _eglFiniDisplay(void)
/**
- * Allocate a new _EGLDisplay object for the given nativeDisplay handle.
- * We'll also try to determine the device driver name at this time.
- *
- * Note that nativeDisplay may be an X Display ptr, or a string.
- */
-_EGLDisplay *
-_eglNewDisplay(EGLNativeDisplayType nativeDisplay)
-{
- _EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
- if (dpy) {
- dpy->NativeDisplay = nativeDisplay;
- }
- return dpy;
-}
-
-
-/**
- * Link a display to itself and return the handle of the link.
- * The handle can be passed to client directly.
- */
-EGLDisplay
-_eglLinkDisplay(_EGLDisplay *dpy)
-{
- _eglLockMutex(_eglGlobal.Mutex);
-
- dpy->Next = _eglGlobal.DisplayList;
- _eglGlobal.DisplayList = dpy;
-
- _eglUnlockMutex(_eglGlobal.Mutex);
-
- return (EGLDisplay) dpy;
-}
-
-
-/**
- * Unlink a linked display from itself.
- * Accessing an unlinked display should generate EGL_BAD_DISPLAY error.
- */
-void
-_eglUnlinkDisplay(_EGLDisplay *dpy)
-{
- _EGLDisplay *prev;
-
- _eglLockMutex(_eglGlobal.Mutex);
-
- prev = _eglGlobal.DisplayList;
- if (prev != dpy) {
- while (prev) {
- if (prev->Next == dpy)
- break;
- prev = prev->Next;
- }
- assert(prev);
- prev->Next = dpy->Next;
- }
- else {
- _eglGlobal.DisplayList = dpy->Next;
- }
-
- _eglUnlockMutex(_eglGlobal.Mutex);
-}
-
-
-/**
- * Find the display corresponding to the specified native display id in all
- * linked displays.
+ * Find the display corresponding to the specified native display, or create a
+ * new one.
*/
_EGLDisplay *
_eglFindDisplay(EGLNativeDisplayType nativeDisplay)
@@ -119,18 +55,30 @@ _eglFindDisplay(EGLNativeDisplayType nativeDisplay)
_eglLockMutex(_eglGlobal.Mutex);
+ /* search the display list first */
dpy = _eglGlobal.DisplayList;
while (dpy) {
- if (dpy->NativeDisplay == nativeDisplay) {
- _eglUnlockMutex(_eglGlobal.Mutex);
- return dpy;
- }
+ if (dpy->NativeDisplay == nativeDisplay)
+ break;
dpy = dpy->Next;
}
+ /* create a new display */
+ if (!dpy) {
+ dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
+ if (dpy) {
+ _eglInitMutex(&dpy->Mutex);
+ dpy->NativeDisplay = nativeDisplay;
+
+ /* add to the display list */
+ dpy->Next = _eglGlobal.DisplayList;
+ _eglGlobal.DisplayList = dpy;
+ }
+ }
+
_eglUnlockMutex(_eglGlobal.Mutex);
- return NULL;
+ return dpy;
}
@@ -186,9 +134,6 @@ _eglCleanupDisplay(_EGLDisplay *disp)
}
-#ifndef _EGL_SKIP_HANDLE_CHECK
-
-
/**
* Return EGL_TRUE if the given handle is a valid handle to a display.
*/
@@ -233,9 +178,6 @@ _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
}
-#endif /* !_EGL_SKIP_HANDLE_CHECK */
-
-
/**
* Link a resource to a display.
*/
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 03903290fd..21bf22b5fe 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -4,6 +4,7 @@
#include "egltypedefs.h"
#include "egldefines.h"
+#include "eglmutex.h"
enum _egl_resource_type {
@@ -13,6 +14,8 @@ enum _egl_resource_type {
_EGL_NUM_RESOURCES
};
+/* this cannot and need not go into egltypedefs.h */
+typedef enum _egl_resource_type _EGLResourceType;
/**
@@ -53,6 +56,8 @@ struct _egl_display
/* used to link displays */
_EGLDisplay *Next;
+ _EGLMutex Mutex;
+
EGLNativeDisplayType NativeDisplay;
EGLBoolean Initialized; /**< True if the display is initialized */
@@ -85,19 +90,7 @@ _eglFiniDisplay(void);
extern _EGLDisplay *
-_eglNewDisplay(EGLNativeDisplayType displayName);
-
-
-extern EGLDisplay
-_eglLinkDisplay(_EGLDisplay *dpy);
-
-
-extern void
-_eglUnlinkDisplay(_EGLDisplay *dpy);
-
-
-extern _EGLDisplay *
-_eglFindDisplay(EGLNativeDisplayType nativeDisplay);
+_eglFindDisplay(EGLNativeDisplayType displayName);
PUBLIC void
@@ -108,9 +101,6 @@ PUBLIC void
_eglCleanupDisplay(_EGLDisplay *disp);
-#ifndef _EGL_SKIP_HANDLE_CHECK
-
-
extern EGLBoolean
_eglCheckDisplayHandle(EGLDisplay dpy);
@@ -119,27 +109,6 @@ PUBLIC EGLBoolean
_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy);
-#else /* !_EGL_SKIP_HANDLE_CHECK */
-
-/* Only do a quick check. This is NOT standard compliant. */
-
-static INLINE EGLBoolean
-_eglCheckDisplayHandle(EGLDisplay dpy)
-{
- return ((_EGLDisplay *) dpy != NULL);
-}
-
-
-static INLINE EGLBoolean
-_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy);
-{
- return (((_EGLResource *) res)->Display == dpy);
-}
-
-
-#endif /* _EGL_SKIP_HANDLE_CHECK */
-
-
/**
* Lookup a handle to find the linked display.
* Return NULL if the handle has no corresponding linked display.
@@ -164,16 +133,6 @@ _eglGetDisplayHandle(_EGLDisplay *dpy)
}
-/**
- * Return true if the display is linked.
- */
-static INLINE EGLBoolean
-_eglIsDisplayLinked(_EGLDisplay *dpy)
-{
- return (EGLBoolean) (_eglGetDisplayHandle(dpy) != EGL_NO_DISPLAY);
-}
-
-
extern void
_eglLinkResource(_EGLResource *res, _EGLResourceType type, _EGLDisplay *dpy);
diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c
index a87c697b11..6384242b09 100644
--- a/src/egl/main/egldriver.c
+++ b/src/egl/main/egldriver.c
@@ -144,7 +144,13 @@ _eglOpenLibrary(const char *driverPath, lib_handle *handle)
mainFunc = (_EGLMain_t) GetProcAddress(lib, "_eglMain");
#elif defined(_EGL_PLATFORM_POSIX)
if (lib) {
- mainFunc = (_EGLMain_t) dlsym(lib, "_eglMain");
+ union {
+ _EGLMain_t func;
+ void *ptr;
+ } tmp = { NULL };
+ /* direct cast gives a warning when compiled with -pedantic */
+ tmp.ptr = dlsym(lib, "_eglMain");
+ mainFunc = tmp.func;
if (!mainFunc)
error = dlerror();
}
@@ -237,6 +243,10 @@ _eglMatchDriver(_EGLDisplay *dpy)
_EGLDriver *best_drv = NULL;
EGLint best_score = -1, i;
+ /*
+ * this function is called after preloading and the drivers never change
+ * after preloading.
+ */
for (i = 0; i < _eglGlobal.NumDrivers; i++) {
_EGLDriver *drv = _eglGlobal.Drivers[i];
EGLint score;
@@ -529,14 +539,21 @@ _eglPreloadDrivers(void)
{
EGLBoolean loaded;
+ /* protect the preloading process */
+ _eglLockMutex(_eglGlobal.Mutex);
+
/* already preloaded */
- if (_eglGlobal.NumDrivers)
+ if (_eglGlobal.NumDrivers) {
+ _eglUnlockMutex(_eglGlobal.Mutex);
return EGL_TRUE;
+ }
loaded = (_eglPreloadUserDriver() ||
_eglPreloadDisplayDrivers() ||
_eglPreloadDefaultDriver());
+ _eglUnlockMutex(_eglGlobal.Mutex);
+
return loaded;
}
@@ -548,6 +565,8 @@ void
_eglUnloadDrivers(void)
{
EGLint i;
+
+ /* this is called at atexit time */
for (i = 0; i < _eglGlobal.NumDrivers; i++) {
_EGLDriver *drv = _eglGlobal.Drivers[i];
lib_handle handle = drv->LibHandle;
diff --git a/src/egl/main/eglglobals.h b/src/egl/main/eglglobals.h
index cd1dd5851b..4368898020 100644
--- a/src/egl/main/eglglobals.h
+++ b/src/egl/main/eglglobals.h
@@ -18,6 +18,7 @@ struct _egl_global
EGLScreenMESA FreeScreenHandle;
+ /* these never change after preloading */
EGLint NumDrivers;
_EGLDriver *Drivers[10];
diff --git a/src/egl/main/eglscreen.c b/src/egl/main/eglscreen.c
index 97a405a4b4..c47afd6abd 100644
--- a/src/egl/main/eglscreen.c
+++ b/src/egl/main/eglscreen.c
@@ -22,17 +22,22 @@
#include "eglconfig.h"
#include "eglsurface.h"
#include "eglscreen.h"
+#include "eglmutex.h"
/**
* Return a new screen handle/ID.
* NOTE: we never reuse these!
*/
-EGLScreenMESA
+static EGLScreenMESA
_eglAllocScreenHandle(void)
{
- EGLScreenMESA s = _eglGlobal.FreeScreenHandle;
- _eglGlobal.FreeScreenHandle++;
+ EGLScreenMESA s;
+
+ _eglLockMutex(_eglGlobal.Mutex);
+ s = _eglGlobal.FreeScreenHandle++;
+ _eglUnlockMutex(_eglGlobal.Mutex);
+
return s;
}
diff --git a/src/egl/main/eglscreen.h b/src/egl/main/eglscreen.h
index c400ac3d15..0fd71f71fc 100644
--- a/src/egl/main/eglscreen.h
+++ b/src/egl/main/eglscreen.h
@@ -29,10 +29,6 @@ struct _egl_screen
};
-extern EGLScreenMESA
-_eglAllocScreenHandle(void);
-
-
PUBLIC void
_eglInitScreen(_EGLScreen *screen);
diff --git a/src/egl/main/egltypedefs.h b/src/egl/main/egltypedefs.h
index e0c95762c6..166b133909 100644
--- a/src/egl/main/egltypedefs.h
+++ b/src/egl/main/egltypedefs.h
@@ -8,8 +8,6 @@
#include "eglcompiler.h"
-typedef enum _egl_resource_type _EGLResourceType;
-
typedef struct _egl_api _EGLAPI;
typedef struct _egl_config _EGLConfig;
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-11 21:03:29 +0000