diff options
Diffstat (limited to 'src/egl/main/eglapi.c')
| -rw-r--r-- | src/egl/main/eglapi.c | 811 |
1 files changed, 493 insertions, 318 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); } |