From 9061d733d3f31293c145cf3b7a0f71c1bfd31989 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Sat, 15 Aug 2009 22:44:46 +0800 Subject: egl: Remove core functions from eglGetProcAddress. eglGetProcAddress may not be used to query core (non-extension) functions. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 61 ++++++++++++++------------------------------------- 1 file changed, 16 insertions(+), 45 deletions(-) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 29617b7aff..82ee9d9bcd 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -586,43 +586,11 @@ eglGetError(void) void (* EGLAPIENTRY eglGetProcAddress(const char *procname))() { - typedef void (*genericFunc)(); - struct name_function { + static const struct { const char *name; _EGLProc function; - }; - static struct name_function egl_functions[] = { - /* alphabetical order */ - { "eglBindTexImage", (_EGLProc) eglBindTexImage }, - { "eglChooseConfig", (_EGLProc) eglChooseConfig }, - { "eglCopyBuffers", (_EGLProc) eglCopyBuffers }, - { "eglCreateContext", (_EGLProc) eglCreateContext }, - { "eglCreatePbufferSurface", (_EGLProc) eglCreatePbufferSurface }, - { "eglCreatePixmapSurface", (_EGLProc) eglCreatePixmapSurface }, - { "eglCreateWindowSurface", (_EGLProc) eglCreateWindowSurface }, - { "eglDestroyContext", (_EGLProc) eglDestroyContext }, - { "eglDestroySurface", (_EGLProc) eglDestroySurface }, - { "eglGetConfigAttrib", (_EGLProc) eglGetConfigAttrib }, - { "eglGetConfigs", (_EGLProc) eglGetConfigs }, - { "eglGetCurrentContext", (_EGLProc) eglGetCurrentContext }, - { "eglGetCurrentDisplay", (_EGLProc) eglGetCurrentDisplay }, - { "eglGetCurrentSurface", (_EGLProc) eglGetCurrentSurface }, - { "eglGetDisplay", (_EGLProc) eglGetDisplay }, - { "eglGetError", (_EGLProc) eglGetError }, - { "eglGetProcAddress", (_EGLProc) eglGetProcAddress }, - { "eglInitialize", (_EGLProc) eglInitialize }, - { "eglMakeCurrent", (_EGLProc) eglMakeCurrent }, - { "eglQueryContext", (_EGLProc) eglQueryContext }, - { "eglQueryString", (_EGLProc) eglQueryString }, - { "eglQuerySurface", (_EGLProc) eglQuerySurface }, - { "eglReleaseTexImage", (_EGLProc) eglReleaseTexImage }, - { "eglSurfaceAttrib", (_EGLProc) eglSurfaceAttrib }, - { "eglSwapBuffers", (_EGLProc) eglSwapBuffers }, - { "eglSwapInterval", (_EGLProc) eglSwapInterval }, - { "eglTerminate", (_EGLProc) eglTerminate }, - { "eglWaitGL", (_EGLProc) eglWaitGL }, - { "eglWaitNative", (_EGLProc) eglWaitNative }, - /* Extensions */ + } egl_functions[] = { + /* extensions only */ #ifdef EGL_MESA_screen_surface { "eglChooseModeMESA", (_EGLProc) eglChooseModeMESA }, { "eglGetModesMESA", (_EGLProc) eglGetModesMESA }, @@ -637,19 +605,16 @@ void (* EGLAPIENTRY eglGetProcAddress(const char *procname))() { "eglQueryScreenModeMESA", (_EGLProc) eglQueryScreenModeMESA }, { "eglQueryModeStringMESA", (_EGLProc) eglQueryModeStringMESA }, #endif /* EGL_MESA_screen_surface */ -#ifdef EGL_VERSION_1_2 - { "eglBindAPI", (_EGLProc) eglBindAPI }, - { "eglCreatePbufferFromClientBuffer", (_EGLProc) eglCreatePbufferFromClientBuffer }, - { "eglQueryAPI", (_EGLProc) eglQueryAPI }, - { "eglReleaseThread", (_EGLProc) eglReleaseThread }, - { "eglWaitClient", (_EGLProc) eglWaitClient }, -#endif /* EGL_VERSION_1_2 */ { NULL, NULL } }; EGLint i; - for (i = 0; egl_functions[i].name; i++) { - if (strcmp(egl_functions[i].name, procname) == 0) { - return (genericFunc) egl_functions[i].function; + + if (!procname) + return 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; } } @@ -664,6 +629,9 @@ void (* EGLAPIENTRY eglGetProcAddress(const char *procname))() } +#ifdef EGL_MESA_screen_surface + + /* * EGL_MESA_screen extension */ @@ -838,6 +806,9 @@ eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode) } +#endif /* EGL_MESA_screen_surface */ + + /** ** EGL 1.2 **/ -- cgit v1.2.3 From e787ffcd02cac9085ac69f631cce235d1cad59c9 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 28 Sep 2009 17:39:07 +0800 Subject: egl: Preload a driver if eglGetProcAddress is called early. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 82ee9d9bcd..23d841d2d1 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -618,6 +618,10 @@ void (* EGLAPIENTRY eglGetProcAddress(const char *procname))() } } + /* preload a driver if there isn't one */ + if (!_eglGlobal.NumDrivers) + _eglPreloadDriver(NULL); + /* now loop over drivers to query their procs */ for (i = 0; i < _eglGlobal.NumDrivers; i++) { _EGLProc p = _eglGlobal.Drivers[i]->API.GetProcAddress(procname); -- cgit v1.2.3 From 310c76812e5a2013dad36fc9d1686f57e7b1e626 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 17 Aug 2009 15:53:54 +0800 Subject: egl: Allow binding to any client API. As a result, EGL_NONE is no longer a valid client API. And it is possible that no config supports the current bound API. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 32 +++----------------------------- src/egl/main/eglcurrent.c | 2 +- src/egl/main/eglcurrent.h | 23 +++++++++++++++-------- src/egl/main/eglglobals.c | 1 - src/egl/main/eglglobals.h | 3 --- 5 files changed, 19 insertions(+), 42 deletions(-) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 23d841d2d1..d86ef9ce56 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -92,8 +92,8 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) snprintf(disp->Version, sizeof(disp->Version), "%d.%d (%s)", major_int, minor_int, drv->Name); - /* update the global notion of supported APIs */ - _eglGlobal.ClientAPIsMask |= disp->ClientAPIsMask; + /* limit to APIs supported by core */ + disp->ClientAPIsMask &= _EGL_API_ALL_BITS; disp->Driver = drv; } else { @@ -842,33 +842,7 @@ eglBindAPI(EGLenum api) if (!_eglIsApiValid(api)) return _eglError(EGL_BAD_PARAMETER, "eglBindAPI"); - switch (api) { -#ifdef EGL_VERSION_1_4 - case EGL_OPENGL_API: - if (_eglGlobal.ClientAPIsMask & EGL_OPENGL_BIT) { - t->CurrentAPIIndex = _eglConvertApiToIndex(api); - return EGL_TRUE; - } - _eglError(EGL_BAD_PARAMETER, "eglBindAPI"); - return EGL_FALSE; -#endif - case EGL_OPENGL_ES_API: - if (_eglGlobal.ClientAPIsMask & (EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT)) { - t->CurrentAPIIndex = _eglConvertApiToIndex(api); - return EGL_TRUE; - } - _eglError(EGL_BAD_PARAMETER, "eglBindAPI"); - return EGL_FALSE; - case EGL_OPENVG_API: - if (_eglGlobal.ClientAPIsMask & EGL_OPENVG_BIT) { - t->CurrentAPIIndex = _eglConvertApiToIndex(api); - return EGL_TRUE; - } - _eglError(EGL_BAD_PARAMETER, "eglBindAPI"); - return EGL_FALSE; - default: - return EGL_FALSE; - } + t->CurrentAPIIndex = _eglConvertApiToIndex(api); return EGL_TRUE; } diff --git a/src/egl/main/eglcurrent.c b/src/egl/main/eglcurrent.c index 4431f964f6..ca7a077168 100644 --- a/src/egl/main/eglcurrent.c +++ b/src/egl/main/eglcurrent.c @@ -9,7 +9,7 @@ /* This should be kept in sync with _eglInitThreadInfo() */ #define _EGL_THREAD_INFO_INITIALIZER \ - { EGL_SUCCESS, { NULL }, 1 } + { EGL_SUCCESS, { NULL }, 0 } /* a fallback thread info to guarantee that every thread always has one */ static _EGLThreadInfo dummy_thread = _EGL_THREAD_INFO_INITIALIZER; diff --git a/src/egl/main/eglcurrent.h b/src/egl/main/eglcurrent.h index 8eb241029e..9503e0aba0 100644 --- a/src/egl/main/eglcurrent.h +++ b/src/egl/main/eglcurrent.h @@ -4,8 +4,16 @@ #include "egltypedefs.h" -#define _EGL_API_NUM_INDICES \ - (EGL_OPENGL_API - EGL_OPENGL_ES_API + 2) /* idx 0 is for EGL_NONE */ +#define _EGL_API_ALL_BITS \ + (EGL_OPENGL_ES_BIT | \ + EGL_OPENVG_BIT | \ + EGL_OPENGL_ES2_BIT | \ + EGL_OPENGL_BIT) + + +#define _EGL_API_FIRST_API EGL_OPENGL_ES_API +#define _EGL_API_LAST_API EGL_OPENGL_API +#define _EGL_API_NUM_APIS (_EGL_API_LAST_API - _EGL_API_FIRST_API + 1) /** @@ -14,20 +22,19 @@ struct _egl_thread_info { EGLint LastError; - _EGLContext *CurrentContexts[_EGL_API_NUM_INDICES]; + _EGLContext *CurrentContexts[_EGL_API_NUM_APIS]; /* use index for fast access to current context */ EGLint CurrentAPIIndex; }; /** - * Return true if a client API enum can be converted to an index. + * Return true if a client API enum is recognized. */ static INLINE EGLBoolean _eglIsApiValid(EGLenum api) { - return ((api >= EGL_OPENGL_ES_API && api <= EGL_OPENGL_API) || - api == EGL_NONE); + return (api >= _EGL_API_FIRST_API && api <= _EGL_API_LAST_API); } @@ -38,7 +45,7 @@ _eglIsApiValid(EGLenum api) static INLINE EGLint _eglConvertApiToIndex(EGLenum api) { - return (api != EGL_NONE) ? api - EGL_OPENGL_ES_API + 1 : 0; + return api - _EGL_API_FIRST_API; } @@ -49,7 +56,7 @@ _eglConvertApiToIndex(EGLenum api) static INLINE EGLenum _eglConvertApiFromIndex(EGLint idx) { - return (idx) ? EGL_OPENGL_ES_API + idx - 1 : EGL_NONE; + return _EGL_API_FIRST_API + idx; } diff --git a/src/egl/main/eglglobals.c b/src/egl/main/eglglobals.c index 3ae4c1ad3a..30d9fe97b4 100644 --- a/src/egl/main/eglglobals.c +++ b/src/egl/main/eglglobals.c @@ -15,7 +15,6 @@ struct _egl_global _eglGlobal = &_eglGlobalMutex, /* Mutex */ NULL, /* DisplayList */ 1, /* FreeScreenHandle */ - 0x0, /* ClientAPIsMask */ 0, /* NumDrivers */ { NULL }, /* Drivers */ 2, /* NumAtExitCalls */ diff --git a/src/egl/main/eglglobals.h b/src/egl/main/eglglobals.h index 58511076d4..5ebb914ca7 100644 --- a/src/egl/main/eglglobals.h +++ b/src/egl/main/eglglobals.h @@ -19,9 +19,6 @@ struct _egl_global EGLScreenMESA FreeScreenHandle; - /* bitmaks of supported APIs (supported by _some_ driver) */ - EGLint ClientAPIsMask; - EGLint NumDrivers; _EGLDriver *Drivers[10]; -- cgit v1.2.3 From 61906631202af855d0742586956ff9f34522a525 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Wed, 30 Sep 2009 15:34:45 +0800 Subject: egl: Rework error checking in eglGetCurrentSurface. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index d86ef9ce56..1512c0a14e 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -568,8 +568,26 @@ eglGetCurrentContext(void) EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw) { - _EGLSurface *s = _eglGetCurrentSurface(readdraw); - return _eglGetSurfaceHandle(s); + _EGLContext *ctx = _eglGetCurrentContext(); + _EGLSurface *surf; + + if (!ctx) + return EGL_NO_SURFACE; + + switch (readdraw) { + case EGL_DRAW: + surf = ctx->DrawSurface; + break; + case EGL_READ: + surf = ctx->ReadSurface; + break; + default: + _eglError(EGL_BAD_PARAMETER, __FUNCTION__); + surf = NULL; + break; + } + + return _eglGetSurfaceHandle(surf); } -- cgit v1.2.3 From aaa1253b09a6a38e7fcd695aa36e89b9d4bd8dfe Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Wed, 30 Sep 2009 15:08:34 +0800 Subject: egl: Update comments about eglapi.c. Mention that opaque handles are looked up and checked. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 1512c0a14e..1d370db471 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -9,12 +9,27 @@ * heterogeneous hardware devices in the future. * * The EGLDisplay, EGLConfig, EGLContext and EGLSurface types are - * opaque handles implemented with 32-bit unsigned integers. - * It's up to the driver function or fallback function to look up the - * handle and get an object. - * By using opaque handles, we leave open the possibility of having - * indirect rendering in the future, like GLX. + * opaque handles. Internal objects are linked to a display to + * create the handles. * + * For each public API entry point, the opaque handles are looked up + * before being dispatched to the drivers. When it fails to look up + * a handle, one of + * + * EGL_BAD_DISPLAY + * EGL_BAD_CONFIG + * EGL_BAD_CONTEXT + * EGL_BAD_SURFACE + * EGL_BAD_SCREEN_MESA + * EGL_BAD_MODE_MESA + * + * is generated and the driver function is not called. An + * uninitialized EGLDisplay has no driver associated with it. When + * such display is detected, + * + * EGL_NOT_INITIALIZED + * + * is generated. * * Notes on naming conventions: * -- cgit v1.2.3 From bbfd0e26151bef567c152c8018ecc15f04c70914 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Thu, 15 Oct 2009 11:08:33 +0800 Subject: egl: Rework error checking in eglSwapBuffers. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 1d370db471..366901889f 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -31,6 +31,15 @@ * * is generated. * + * Some of the entry points use current display, context, or surface + * implicitly. For such entry points, the implicit objects are also + * checked before calling the driver function. Other than the + * errors listed above, + * + * EGL_BAD_CURRENT_SURFACE + * + * may also be generated. + * * Notes on naming conventions: * * eglFooBar - public EGL function @@ -519,7 +528,13 @@ eglSwapInterval(EGLDisplay dpy, EGLint interval) EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) { + _EGLContext *ctx = _eglGetCurrentContext(); _EGL_DECLARE_DD_AND_SURFACE(dpy, surface); + + /* 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 drv->API.SwapBuffers(drv, disp, surf); } -- cgit v1.2.3 From 57da499d7ba074128e8c97b8076805e403a2b9c4 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Thu, 15 Oct 2009 11:08:48 +0800 Subject: egl: Rework eglSwapInterval. This adds error checking to eglSwapInterval and clamps the swap interval. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 12 +++++++++++- src/egl/main/eglapi.h | 2 +- src/egl/main/eglsurface.c | 27 ++++++++++++++++++++++----- src/egl/main/eglsurface.h | 2 +- 4 files changed, 35 insertions(+), 8 deletions(-) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 366901889f..5ce0469351 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -520,8 +520,18 @@ eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval) { + _EGLContext *ctx = _eglGetCurrentContext(); + _EGLSurface *surf; _EGL_DECLARE_DD(dpy); - return drv->API.SwapInterval(drv, disp, interval); + + if (!ctx || !_eglIsContextLinked(ctx) || ctx->Display != disp) + return _eglError(EGL_BAD_CONTEXT, __FUNCTION__); + + surf = ctx->DrawSurface; + if (!_eglIsSurfaceLinked(surf)) + return _eglError(EGL_BAD_SURFACE, __FUNCTION__); + + return drv->API.SwapInterval(drv, disp, surf, interval); } diff --git a/src/egl/main/eglapi.h b/src/egl/main/eglapi.h index 6081e58892..feb35c863c 100644 --- a/src/egl/main/eglapi.h +++ b/src/egl/main/eglapi.h @@ -35,7 +35,7 @@ typedef EGLBoolean (*QuerySurface_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurf typedef EGLBoolean (*SurfaceAttrib_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint attribute, EGLint value); typedef EGLBoolean (*BindTexImage_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint buffer); typedef EGLBoolean (*ReleaseTexImage_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLint buffer); -typedef EGLBoolean (*SwapInterval_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint interval); +typedef EGLBoolean (*SwapInterval_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint interval); typedef EGLBoolean (*SwapBuffers_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw); typedef EGLBoolean (*CopyBuffers_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, NativePixmapType target); diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c index e7a1a8329e..940a1b760c 100644 --- a/src/egl/main/eglsurface.c +++ b/src/egl/main/eglsurface.c @@ -15,6 +15,22 @@ #include "eglsurface.h" +static void +_eglClampSwapInterval(_EGLSurface *surf, EGLint interval) +{ + EGLint bound = GET_CONFIG_ATTRIB(surf->Config, EGL_MAX_SWAP_INTERVAL); + if (interval >= bound) { + interval = bound; + } + else { + bound = GET_CONFIG_ATTRIB(surf->Config, EGL_MIN_SWAP_INTERVAL); + if (interval < bound) + interval = bound; + } + surf->SwapInterval = interval; +} + + /** * Do error check on parameters and initialize the given _EGLSurface object. * \return EGL_TRUE if no errors, EGL_FALSE otherwise. @@ -194,7 +210,9 @@ _eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type, surf->TextureTarget = texTarget; surf->MipmapTexture = mipmapTex; surf->MipmapLevel = 0; - surf->SwapInterval = 0; + /* the default swap interval is 1 */ + _eglClampSwapInterval(surf, 1); + #ifdef EGL_VERSION_1_2 surf->SwapBehavior = EGL_BUFFER_DESTROYED; /* XXX ok? */ surf->HorizontalResolution = EGL_UNKNOWN; /* set by caller */ @@ -466,11 +484,10 @@ _eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface, EGLBoolean -_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, EGLint interval) +_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, + EGLint interval) { - _EGLSurface *surf = _eglGetCurrentSurface(EGL_DRAW); - if (surf) - surf->SwapInterval = interval; + _eglClampSwapInterval(surf, interval); return EGL_TRUE; } diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h index f6d44b5922..b75fa9c368 100644 --- a/src/egl/main/eglsurface.h +++ b/src/egl/main/eglsurface.h @@ -86,7 +86,7 @@ _eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint extern EGLBoolean -_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, EGLint interval); +_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint interval); #ifdef EGL_VERSION_1_2 -- cgit v1.2.3 From 6c21c8862bc6edc9cddf3b6eb6f276961099a7a8 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 28 Sep 2009 14:12:39 +0800 Subject: egl: Rework the synchronization primitives. This adds error checking to the synchronization primitives. And eglWaitGL is now implemented by eglWaitClient. Signed-off-by: Chia-I Wu --- src/egl/main/eglapi.c | 66 ++++++++++++++++++++++++++++++------------------ src/egl/main/eglapi.h | 6 ++--- src/egl/main/egldriver.c | 2 +- src/egl/main/eglmisc.c | 3 ++- src/egl/main/eglmisc.h | 2 +- 5 files changed, 48 insertions(+), 31 deletions(-) (limited to 'src/egl/main/eglapi.c') diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c index 5ce0469351..14cc5fa613 100644 --- a/src/egl/main/eglapi.c +++ b/src/egl/main/eglapi.c @@ -558,32 +558,66 @@ eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, NativePixmapType target) EGLBoolean EGLAPIENTRY -eglWaitGL(void) +eglWaitClient(void) { - _EGLDisplay *disp = _eglGetCurrentDisplay(); + _EGLContext *ctx = _eglGetCurrentContext(); + _EGLDisplay *disp; _EGLDriver *drv; - if (!disp) + if (!ctx) return EGL_TRUE; + /* let bad current context imply bad current surface */ + if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface)) + return _eglError(EGL_BAD_CURRENT_SURFACE, __FUNCTION__); - /* a current display is always initialized */ + /* a valid current context implies an initialized current display */ + disp = ctx->Display; drv = disp->Driver; + assert(drv); + + return drv->API.WaitClient(drv, disp, ctx); +} + - return drv->API.WaitGL(drv, disp); +EGLBoolean EGLAPIENTRY +eglWaitGL(void) +{ +#ifdef EGL_VERSION_1_2 + _EGLThreadInfo *t = _eglGetCurrentThread(); + EGLint api_index = t->CurrentAPIIndex; + EGLint es_index = _eglConvertApiToIndex(EGL_OPENGL_ES_API); + EGLBoolean ret; + + if (api_index != es_index && _eglIsCurrentThreadDummy()) + return _eglError(EGL_BAD_ALLOC, "eglWaitGL"); + + t->CurrentAPIIndex = es_index; + ret = eglWaitClient(); + t->CurrentAPIIndex = api_index; + return ret; +#else + return eglWaitClient(); +#endif } EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine) { - _EGLDisplay *disp = _eglGetCurrentDisplay(); + _EGLContext *ctx = _eglGetCurrentContext(); + _EGLDisplay *disp; _EGLDriver *drv; - if (!disp) + if (!ctx) return EGL_TRUE; + /* let bad current context imply bad current surface */ + if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface)) + return _eglError(EGL_BAD_CURRENT_SURFACE, __FUNCTION__); - /* a current display is always initialized */ + /* a valid current context implies an initialized current display */ + disp = ctx->Display; drv = disp->Driver; + assert(drv); return drv->API.WaitNative(drv, disp, engine); } @@ -958,20 +992,4 @@ eglReleaseThread(void) } -EGLBoolean -eglWaitClient(void) -{ - _EGLDisplay *disp = _eglGetCurrentDisplay(); - _EGLDriver *drv; - - if (!disp) - return EGL_TRUE; - - /* a current display is always initialized */ - drv = disp->Driver; - - return drv->API.WaitClient(drv, disp); -} - - #endif /* EGL_VERSION_1_2 */ diff --git a/src/egl/main/eglapi.h b/src/egl/main/eglapi.h index feb35c863c..aa0abe3eb6 100644 --- a/src/egl/main/eglapi.h +++ b/src/egl/main/eglapi.h @@ -41,7 +41,7 @@ typedef EGLBoolean (*CopyBuffers_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurfa /* misc funcs */ typedef const char *(*QueryString_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name); -typedef EGLBoolean (*WaitGL_t)(_EGLDriver *drv, _EGLDisplay *dpy); +typedef EGLBoolean (*WaitClient_t)(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx); typedef EGLBoolean (*WaitNative_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine); typedef _EGLProc (*GetProcAddress_t)(const char *procname); @@ -65,7 +65,6 @@ typedef const char * (*QueryModeStringMESA_t)(_EGLDriver *drv, _EGLDisplay *dpy, #ifdef EGL_VERSION_1_2 -typedef EGLBoolean (*WaitClient_t)(_EGLDriver *drv, _EGLDisplay *dpy); typedef _EGLSurface *(*CreatePbufferFromClientBuffer_t)(_EGLDriver *drv, _EGLDisplay *dpy, EGLenum buftype, EGLClientBuffer buffer, _EGLConfig *config, const EGLint *attrib_list); #endif /* EGL_VERSION_1_2 */ @@ -101,7 +100,7 @@ struct _egl_api CopyBuffers_t CopyBuffers; QueryString_t QueryString; - WaitGL_t WaitGL; + WaitClient_t WaitClient; WaitNative_t WaitNative; GetProcAddress_t GetProcAddress; @@ -120,7 +119,6 @@ struct _egl_api QueryModeStringMESA_t QueryModeStringMESA; #ifdef EGL_VERSION_1_2 - WaitClient_t WaitClient; CreatePbufferFromClientBuffer_t CreatePbufferFromClientBuffer; #endif }; diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c index 0c76c79973..018b06d3be 100644 --- a/src/egl/main/egldriver.c +++ b/src/egl/main/egldriver.c @@ -408,7 +408,7 @@ _eglInitDriverFallbacks(_EGLDriver *drv) drv->API.CopyBuffers = _eglCopyBuffers; drv->API.QueryString = _eglQueryString; - drv->API.WaitGL = _eglWaitGL; + drv->API.WaitClient = _eglWaitClient; drv->API.WaitNative = _eglWaitNative; #ifdef EGL_MESA_screen_surface diff --git a/src/egl/main/eglmisc.c b/src/egl/main/eglmisc.c index b37213faf1..e66913320b 100644 --- a/src/egl/main/eglmisc.c +++ b/src/egl/main/eglmisc.c @@ -108,11 +108,12 @@ _eglQueryString(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name) EGLBoolean -_eglWaitGL(_EGLDriver *drv, _EGLDisplay *dpy) +_eglWaitClient(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx) { /* just a placeholder */ (void) drv; (void) dpy; + (void) ctx; return EGL_TRUE; } diff --git a/src/egl/main/eglmisc.h b/src/egl/main/eglmisc.h index a15c839be2..829d4cde79 100644 --- a/src/egl/main/eglmisc.h +++ b/src/egl/main/eglmisc.h @@ -37,7 +37,7 @@ _eglQueryString(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name); extern EGLBoolean -_eglWaitGL(_EGLDriver *drv, _EGLDisplay *dpy); +_eglWaitClient(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx); extern EGLBoolean -- cgit v1.2.3