egl: Cleanup _EGLDisplay initialization.

Reorder/rename and document the fields that should be set by the driver during
initialization.  Drop the major/minor arguments from drv->API.Initialize.

diff --git a/src/egl/drivers/dri2/egl_dri2.c b/src/egl/drivers/dri2/egl_dri2.c
index 458d18f4da5aa2d17a1d91fd491611580812aa3f..f6bca4abf72a4d9181e39235a5e314e1f4eddc6b 100644 (file)
--- a/src/egl/drivers/dri2/egl_dri2.c
+++ b/src/egl/drivers/dri2/egl_dri2.c
@@ -260,8 +260,8 @@ dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
          base.BindToTextureRGBA = bind_to_texture_rgba;
    }
 
-   base.RenderableType = disp->ClientAPIsMask;
-   base.Conformant = disp->ClientAPIsMask;
+   base.RenderableType = disp->ClientAPIs;
+   base.Conformant = disp->ClientAPIs;
 
    if (!_eglValidateConfig(&base, EGL_FALSE)) {
       _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
@@ -752,13 +752,13 @@ dri2_create_screen(_EGLDisplay *disp)
    else
       api_mask = 1 << __DRI_API_OPENGL;
 
-   disp->ClientAPIsMask = 0;
+   disp->ClientAPIs = 0;
    if (api_mask & (1 <<__DRI_API_OPENGL))
-      disp->ClientAPIsMask |= EGL_OPENGL_BIT;
+      disp->ClientAPIs |= EGL_OPENGL_BIT;
    if (api_mask & (1 <<__DRI_API_GLES))
-      disp->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
+      disp->ClientAPIs |= EGL_OPENGL_ES_BIT;
    if (api_mask & (1 << __DRI_API_GLES2))
-      disp->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
+      disp->ClientAPIs |= EGL_OPENGL_ES2_BIT;
 
    if (dri2_dpy->dri2->base.version >= 2) {
       disp->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
@@ -775,8 +775,7 @@ dri2_create_screen(_EGLDisplay *disp)
 }
 
 static EGLBoolean
-dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp,
-                   EGLint *major, EGLint *minor)
+dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp)
 {
    struct dri2_egl_display *dri2_dpy;
 
@@ -855,8 +854,8 @@ dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp,
    disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
 
    /* we're supporting EGL 1.4 */
-   *major = 1;
-   *minor = 4;
+   disp->VersionMajor = 1;
+   disp->VersionMinor = 4;
 
    return EGL_TRUE;
 
@@ -1415,8 +1414,7 @@ dri2_get_driver_for_fd(int fd)
 }
 
 static EGLBoolean
-dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp,
-                   EGLint *major, EGLint *minor)
+dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp)
 {
    struct dri2_egl_display *dri2_dpy;
    int i;
@@ -1451,8 +1449,8 @@ dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp,
    disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
 
    /* we're supporting EGL 1.4 */
-   *major = 1;
-   *minor = 4;
+   disp->VersionMajor = 1;
+   disp->VersionMinor = 4;
 
    return EGL_TRUE;
 
@@ -1470,16 +1468,15 @@ dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp,
  * Called via eglInitialize(), GLX_drv->API.Initialize().
  */
 static EGLBoolean
-dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp,
-               EGLint *major, EGLint *minor)
+dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp)
 {
    switch (disp->Platform) {
    case _EGL_PLATFORM_X11:
-      return dri2_initialize_x11(drv, disp, major, minor);
+      return dri2_initialize_x11(drv, disp);
 
 #ifdef HAVE_LIBUDEV
    case _EGL_PLATFORM_DRM:
-      return dri2_initialize_drm(drv, disp, major, minor);
+      return dri2_initialize_drm(drv, disp);
 #endif
 
    default:

diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 5fce06d66df4a6798c98bd29d28c3a2fc48e0c69..84b04f7967e1153101750b13f749beb81a8e05ea 100644 (file)
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -581,8 +581,7 @@ check_quirks(struct GLX_egl_driver *GLX_drv,
  * Called via eglInitialize(), GLX_drv->API.Initialize().
  */
 static EGLBoolean
-GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp,
-                   EGLint *major, EGLint *minor)
+GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp)
 {
    struct GLX_egl_driver *GLX_drv = GLX_egl_driver(drv);
    struct GLX_egl_display *GLX_dpy;
@@ -614,7 +613,7 @@ GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp,
    }
 
    disp->DriverData = (void *) GLX_dpy;
-   disp->ClientAPIsMask = EGL_OPENGL_BIT;
+   disp->ClientAPIs = EGL_OPENGL_BIT;
 
    check_extensions(GLX_drv, GLX_dpy, DefaultScreen(GLX_dpy->dpy));
    check_quirks(GLX_drv, GLX_dpy, DefaultScreen(GLX_dpy->dpy));
@@ -629,8 +628,8 @@ GLX_eglInitialize(_EGLDriver *drv, _EGLDisplay *disp,
    }
 
    /* we're supporting EGL 1.4 */
-   *major = 1;
-   *minor = 4;
+   disp->VersionMajor = 1;
+   disp->VersionMinor = 4;
 
    return EGL_TRUE;
 }

diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index efa9e97346b127e093429aa2d8731ecee120100b..4e64ce6f7188108c9c4f44a75f8ba0702f7204ec 100644 (file)
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -57,7 +57,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "eglstring.h"
 #include "eglcontext.h"
 #include "egldisplay.h"
 #include "egltypedefs.h"
@@ -294,16 +293,14 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
       if (!_eglMatchDriver(disp, EGL_FALSE))
          RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
 
-      _eglsnprintf(disp->Version, sizeof(disp->Version), "%d.%d (%s)",
-            disp->APImajor, disp->APIminor, disp->Driver->Name);
       /* limit to APIs supported by core */
-      disp->ClientAPIsMask &= _EGL_API_ALL_BITS;
+      disp->ClientAPIs &= _EGL_API_ALL_BITS;
    }
 
    /* Update applications version of major and minor if not NULL */
    if ((major != NULL) && (minor != NULL)) {
-      *major = disp->APImajor;
-      *minor = disp->APIminor;
+      *major = disp->VersionMajor;
+      *minor = disp->VersionMinor;
    }
 
    RETURN_EGL_SUCCESS(disp, EGL_TRUE);

diff --git a/src/egl/main/eglapi.h b/src/egl/main/eglapi.h
index 127becc9acdccebdeb2d22befb907483e5c1f9c0..01492082f66581ad14648d196771251fd59aa81d 100644 (file)
--- a/src/egl/main/eglapi.h
+++ b/src/egl/main/eglapi.h
@@ -12,7 +12,7 @@ typedef void (*_EGLProc)(void);
  */
 
 /* driver funcs */
-typedef EGLBoolean (*Initialize_t)(_EGLDriver *, _EGLDisplay *dpy, EGLint *major, EGLint *minor);
+typedef EGLBoolean (*Initialize_t)(_EGLDriver *, _EGLDisplay *dpy);
 typedef EGLBoolean (*Terminate_t)(_EGLDriver *, _EGLDisplay *dpy);
 
 /* config funcs */

diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index bcba05480a86676f9599a75e250c049f120a46d2..faeb29064782ab15799b0dc47358376f3e092a6f 100644 (file)
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -74,8 +74,6 @@ struct _egl_extensions
 
    EGLBoolean NOK_swap_region;
    EGLBoolean NOK_texture_from_pixmap;
-
-   char String[_EGL_MAX_EXTENSIONS_LEN];
 };
 
 
@@ -86,21 +84,23 @@ struct _egl_display
 
    _EGLMutex Mutex;
 
-   _EGLPlatformType Platform;
-   void *PlatformDisplay;
-
-   EGLBoolean Initialized; /**< True if the display is initialized */
-   _EGLDriver *Driver;
-   void *DriverData; /* private to driver */
+   _EGLPlatformType Platform; /**< The type of the platform display */
+   void *PlatformDisplay;     /**< A pointer to the platform display */
 
-   int APImajor, APIminor; /**< as returned by eglInitialize() */
-   char Version[1000];     /**< initialized from APImajor/minor, DriverName */
+   _EGLDriver *Driver;        /**< Matched driver of the display */
+   EGLBoolean Initialized;    /**< True if the display is initialized */
 
-   /** Bitmask of supported APIs (EGL_xx_BIT) set by the driver during init */
-   EGLint ClientAPIsMask;
-   char ClientAPIs[1000];   /**< updated by eglQueryString */
+   /* these fields are set by the driver during init */
+   void *DriverData;          /**< Driver private data */
+   EGLint VersionMajor;       /**< EGL major version */
+   EGLint VersionMinor;       /**< EGL minor version */
+   EGLint ClientAPIs;         /**< Bitmask of APIs supported (EGL_xxx_BIT) */
+   _EGLExtensions Extensions; /**< Extensions supported */
 
-   _EGLExtensions Extensions;
+   /* these fields are derived from above */
+   char VersionString[1000];                       /**< EGL_VERSION */
+   char ClientAPIsString[1000];                    /**< EGL_CLIENT_APIS */
+   char ExtensionsString[_EGL_MAX_EXTENSIONS_LEN]; /**< EGL_EXTENSIONS */
 
    _EGLArray *Screens;
    _EGLArray *Configs;

diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c
index 0f2e40abf57846392e72710e780dbbd23b6d1f4e..1ae030db448cb6f990028fde984ff74629daeb3f 100644 (file)
--- a/src/egl/main/egldriver.c
+++ b/src/egl/main/egldriver.c
@@ -537,7 +537,7 @@ _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean use_probe)
    _EGLModule *mod;
    _EGLDriver *best_drv = NULL;
    EGLint best_score = 0;
-   EGLint major, minor, i;
+   EGLint i;
 
    _eglLockMutex(&_eglModuleMutex);
 
@@ -562,7 +562,7 @@ _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean use_probe)
          }
       }
       else {
-         if (mod->Driver->API.Initialize(mod->Driver, dpy, &major, &minor)) {
+         if (mod->Driver->API.Initialize(mod->Driver, dpy)) {
             best_drv = mod->Driver;
             best_score = 100;
          }
@@ -591,7 +591,7 @@ _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean use_probe)
                mod->Driver->Probe(mod->Driver, dpy) : 1;
          }
          else {
-            if (mod->Driver->API.Initialize(mod->Driver, dpy, &major, &minor))
+            if (mod->Driver->API.Initialize(mod->Driver, dpy))
                best_score = 100;
          }
 
@@ -621,8 +621,6 @@ _eglMatchDriver(_EGLDisplay *dpy, EGLBoolean use_probe)
       if (!use_probe) {
          dpy->Driver = best_drv;
          dpy->Initialized = EGL_TRUE;
-         dpy->APImajor = major;
-         dpy->APIminor = minor;
       }
    }
 

diff --git a/src/egl/main/eglmisc.c b/src/egl/main/eglmisc.c
index bbb96a908e490cd88e9a36bb772c7ddb5e42c055..5a607dc080a49b2246181595a619e1436921ff6f 100644 (file)
--- a/src/egl/main/eglmisc.c
+++ b/src/egl/main/eglmisc.c
@@ -36,6 +36,8 @@
 #include "eglcurrent.h"
 #include "eglmisc.h"
 #include "egldisplay.h"
+#include "egldriver.h"
+#include "eglstring.h"
 
 
 /**
@@ -73,11 +75,11 @@ _eglUpdateExtensionsString(_EGLDisplay *dpy)
    do {                                                                    \
       if (dpy->Extensions.ext) {                                           \
          _eglAppendExtension(&exts, "EGL_" #ext);                          \
-         assert(exts <= dpy->Extensions.String + _EGL_MAX_EXTENSIONS_LEN); \
+         assert(exts <= dpy->ExtensionsString + _EGL_MAX_EXTENSIONS_LEN);  \
       }                                                                    \
    } while (0)
 
-   char *exts = dpy->Extensions.String;
+   char *exts = dpy->ExtensionsString;
 
    if (exts[0])
       return;
@@ -114,21 +116,21 @@ _eglUpdateExtensionsString(_EGLDisplay *dpy)
 static void
 _eglUpdateAPIsString(_EGLDisplay *dpy)
 {
-   char *apis = dpy->ClientAPIs;
+   char *apis = dpy->ClientAPIsString;
 
-   if (apis[0] || !dpy->ClientAPIsMask)
+   if (apis[0] || !dpy->ClientAPIs)
       return;
 
-   if (dpy->ClientAPIsMask & EGL_OPENGL_BIT)
+   if (dpy->ClientAPIs & EGL_OPENGL_BIT)
       strcat(apis, "OpenGL ");
 
-   if (dpy->ClientAPIsMask & EGL_OPENGL_ES_BIT)
+   if (dpy->ClientAPIs & EGL_OPENGL_ES_BIT)
       strcat(apis, "OpenGL_ES ");
 
-   if (dpy->ClientAPIsMask & EGL_OPENGL_ES2_BIT)
+   if (dpy->ClientAPIs & EGL_OPENGL_ES2_BIT)
       strcat(apis, "OpenGL_ES2 ");
 
-   if (dpy->ClientAPIsMask & EGL_OPENVG_BIT)
+   if (dpy->ClientAPIs & EGL_OPENVG_BIT)
       strcat(apis, "OpenVG ");
 
    assert(strlen(apis) < sizeof(dpy->ClientAPIs));
@@ -139,20 +141,21 @@ const char *
 _eglQueryString(_EGLDriver *drv, _EGLDisplay *dpy, EGLint name)
 {
    (void) drv;
-   (void) dpy;
+
    switch (name) {
    case EGL_VENDOR:
       return _EGL_VENDOR_STRING;
    case EGL_VERSION:
-      return dpy->Version;
+      _eglsnprintf(dpy->VersionString, sizeof(dpy->VersionString),
+              "%d.%d (%s)", dpy->VersionMajor, dpy->VersionMajor,
+              dpy->Driver->Name);
+      return dpy->VersionString;
    case EGL_EXTENSIONS:
       _eglUpdateExtensionsString(dpy);
-      return dpy->Extensions.String;
-#ifdef EGL_VERSION_1_2
+      return dpy->ExtensionsString;
    case EGL_CLIENT_APIS:
       _eglUpdateAPIsString(dpy);
-      return dpy->ClientAPIs;
-#endif
+      return dpy->ClientAPIsString;
    default:
       _eglError(EGL_BAD_PARAMETER, "eglQueryString");
       return NULL;

diff --git a/src/egl/main/eglstring.h b/src/egl/main/eglstring.h
index f1d559b24a23362fc73e5aecea37bd2af6b42c47..8a8c43c1eff83ac8a03cae04a47a07c1b550b36c 100644 (file)
--- a/src/egl/main/eglstring.h
+++ b/src/egl/main/eglstring.h
@@ -4,6 +4,7 @@
 #include <string.h>
 
 #ifdef _EGL_OS_WINDOWS
+#include <stdio.h>
 #define _eglstrcasecmp _stricmp
 #define _eglsnprintf _snprintf
 #else

diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c
index f2b137a674adeaeebd0f58f3d1930f38b87930d8..903547051720f624f1c53d480a2f0cb0a6a5837d 100644 (file)
--- a/src/gallium/state_trackers/egl/common/egl_g3d.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d.c
@@ -280,7 +280,7 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
       ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT;
 
    valid = init_config_attributes(&gconf->base,
-         nconf, dpy->ClientAPIsMask, depth_stencil_format,
+         nconf, dpy->ClientAPIs, depth_stencil_format,
          preserve_buffer, max_swap_interval);
    if (!valid) {
       _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", nconf->native_visual_id);
@@ -474,8 +474,7 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
 }
 
 static EGLBoolean
-egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
-                   EGLint *major, EGLint *minor)
+egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy)
 {
    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
    struct egl_g3d_display *gdpy;
@@ -502,13 +501,13 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
    }
 
    if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_DEFAULT_MASK)
-      dpy->ClientAPIsMask |= EGL_OPENGL_BIT;
+      dpy->ClientAPIs |= EGL_OPENGL_BIT;
    if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_OPENGL_ES1_MASK)
-      dpy->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
+      dpy->ClientAPIs |= EGL_OPENGL_ES_BIT;
    if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_OPENGL_ES2_MASK)
-      dpy->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
+      dpy->ClientAPIs |= EGL_OPENGL_ES2_BIT;
    if (gdpy->loader->profile_masks[ST_API_OPENVG] & ST_PROFILE_DEFAULT_MASK)
-      dpy->ClientAPIsMask |= EGL_OPENVG_BIT;
+      dpy->ClientAPIs |= EGL_OPENVG_BIT;
 
    gdpy->smapi = egl_g3d_create_st_manager(dpy);
    if (!gdpy->smapi) {
@@ -547,8 +546,8 @@ egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
       goto fail;
    }
 
-   *major = 1;
-   *minor = 4;
+   dpy->VersionMajor = 1;
+   dpy->VersionMinor = 4;
 
    return EGL_TRUE;