Rework how we search for winsys configs

When creating new onscreen framebuffers we need to take the
configuration in cogl terms and translate that into a configuration
applicable to any given winsys, e.g. an EGLConfig or a GLXFBConfig
or a PIXELFORMATDESCRIPTOR.

Also when we first create a context we typically have to do a very
similar thing because most OpenGL winsys APIs also associate a
framebuffer config with the context and all future configs need to be
compatible with that.

This patch introduces an internal CoglFramebufferConfig to wrap up some
of the configuration parameters that are common to CoglOnscreenTemplate
and to CoglFramebuffer so we aim to re-use code when dealing with the
above two problems.

This patch also aims to rework the winsys code so it can be more
naturally extended as we start adding more configureability to how
onscreen framebuffers are created.

FIXME: still need to update the wgl winsys!

6 files changed, 222 insertions, 117 deletions

diff --git a/cogl/cogl-framebuffer-private.h b/cogl/cogl-framebuffer-private.h
index 27a91e3d..c429be9a 100644
--- a/cogl/cogl-framebuffer-private.h
+++ b/cogl/cogl-framebuffer-private.h
@@ -47,11 +47,21 @@ typedef enum _CoglFramebufferType {
   COGL_FRAMEBUFFER_TYPE_OFFSCREEN
 } CoglFramebufferType;
 
+typedef struct
+{
+  CoglSwapChain *swap_chain;
+  gboolean need_stencil;
+} CoglFramebufferConfig;
+
 struct _CoglFramebuffer
 {
   CoglObject          _parent;
   CoglContext        *context;
   CoglFramebufferType  type;
+
+  /* The user configuration before allocation... */
+  CoglFramebufferConfig config;
+
   int                 width;
   int                 height;
   /* Format of the pixels in the framebuffer (including the expected
@@ -108,7 +118,14 @@ typedef struct _CoglOffscreen
   CoglFramebuffer  _parent;
   GLuint          fbo_handle;
   GSList          *renderbuffers;
-  CoglTexture     *texture;
+
+  /* For multisample rendering we sometimes have to abstract a second FBO
+   * used to perform an explicit sample resolve via the framebuffer_blit
+   * extension. If the hardware doesn't require an explicit resolve
+   * (e.g. PVR/Mali hardware then this won't be used) */
+  GLuint          resolve_fbo_handle;
+
+  CoglTexture    *texture;
 } CoglOffscreen;
 
 /* Flags to pass to _cogl_offscreen_new_to_texture_full */
diff --git a/cogl/cogl-framebuffer.c b/cogl/cogl-framebuffer.c
index 7a7d50a2..f3a03da4 100644
--- a/cogl/cogl-framebuffer.c
+++ b/cogl/cogl-framebuffer.c
@@ -36,6 +36,7 @@
 #include "cogl-util.h"
 #include "cogl-texture-private.h"
 #include "cogl-framebuffer-private.h"
+#include "cogl-onscreen-template-private.h"
 #include "cogl-clip-stack.h"
 #include "cogl-journal-private.h"
 #include "cogl-winsys-private.h"
@@ -957,6 +958,16 @@ _cogl_offscreen_free (CoglOffscreen *offscreen)
   g_free (offscreen);
 }
 
+static void
+_cogl_onscreen_init_from_template (CoglOnscreen *onscreen,
+                                   CoglOnscreenTemplate *onscreen_template)
+{
+  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
+
+  framebuffer->config = onscreen_template->config;
+  cogl_object_ref (framebuffer->config.swap_chain);
+}
+
 /* XXX: While we still have backend in Clutter we need a dummy object
  * to represent the CoglOnscreen framebuffer that the backend
  * creates... */
@@ -976,6 +987,8 @@ _cogl_onscreen_new (void)
   /* NB: make sure to pass positive width/height numbers here
    * because otherwise we'll hit input validation assertions!*/
 
+  _cogl_onscreen_init_from_template (onscreen, ctx->display->onscreen_template);
+
   COGL_FRAMEBUFFER (onscreen)->allocated = TRUE;
 
   /* XXX: Note we don't initialize onscreen->winsys in this case. */
@@ -1007,6 +1020,9 @@ cogl_onscreen_new (CoglContext *ctx, int width, int height)
                           width, /* width */
                           height); /* height */
 
+  _cogl_onscreen_init_from_template (onscreen, ctx->display->onscreen_template);
+
+  /* FIXME: This should be configurable via the template too */
   onscreen->swap_throttled = TRUE;
 
   return _cogl_onscreen_object_new (onscreen);
diff --git a/cogl/cogl-onscreen-template-private.h b/cogl/cogl-onscreen-template-private.h
index 0f8d2533..21278797 100644
--- a/cogl/cogl-onscreen-template-private.h
+++ b/cogl/cogl-onscreen-template-private.h
@@ -31,7 +31,7 @@ struct _CoglOnscreenTemplate
 {
   CoglObject _parent;
 
-  CoglSwapChain *swap_chain;
+  CoglFramebufferConfig config;
 };
 
 #endif /* __COGL_ONSCREEN_TEMPLATE_PRIVATE_H */
diff --git a/cogl/cogl-onscreen-template.c b/cogl/cogl-onscreen-template.c
index ff400e4e..b9fbd235 100644
--- a/cogl/cogl-onscreen-template.c
+++ b/cogl/cogl-onscreen-template.c
@@ -31,8 +31,11 @@
 #include "cogl.h"
 #include "cogl-object.h"
 
+#include "cogl-framebuffer-private.h"
 #include "cogl-onscreen-template-private.h"
 
+#include <stdlib.h>
+
 static void _cogl_onscreen_template_free (CoglOnscreenTemplate *onscreen_template);
 
 COGL_OBJECT_DEFINE (OnscreenTemplate, onscreen_template);
@@ -53,10 +56,15 @@ CoglOnscreenTemplate *
 cogl_onscreen_template_new (CoglSwapChain *swap_chain)
 {
   CoglOnscreenTemplate *onscreen_template = g_slice_new0 (CoglOnscreenTemplate);
+  char *user_config;
 
-  onscreen_template->swap_chain = swap_chain;
+  onscreen_template->config.swap_chain = swap_chain;
   if (swap_chain)
     cogl_object_ref (swap_chain);
+  else
+    onscreen_template->config.swap_chain = cogl_swap_chain_new ();
+
+  onscreen_template->config.need_stencil = TRUE;
 
   return _cogl_onscreen_template_object_new (onscreen_template);
 }
diff --git a/cogl/winsys/cogl-winsys-egl.c b/cogl/winsys/cogl-winsys-egl.c
index b2b35b17..b8b0d309 100644
--- a/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/winsys/cogl-winsys-egl.c
@@ -72,6 +72,8 @@
 #define COGL_ONSCREEN_X11_EVENT_MASK StructureNotifyMask
 #endif
 
+#define MAX_EGL_CONFIG_ATTRIBS 30
+
 typedef enum _CoglEGLWinsysFeature
 {
   COGL_EGL_WINSYS_FEATURE_SWAP_REGION                   =1L<<0,
@@ -143,6 +145,7 @@ typedef struct _CoglDisplayEGL
 
   EGLConfig egl_config;
   gboolean found_egl_config;
+  gboolean stencil_disabled;
 } CoglDisplayEGL;
 
 typedef struct _CoglContextEGL
@@ -596,10 +599,59 @@ get_visual_info (CoglDisplay *display, EGLConfig egl_config)
 }
 #endif
 
+static void
+egl_attributes_from_framebuffer_config (CoglDisplay *display,
+                                        CoglFramebufferConfig *config,
+                                        gboolean needs_stencil_override,
+                                        EGLint *attributes)
+{
+  int i = 0;
+
+  attributes[i++] = EGL_STENCIL_SIZE;
+  attributes[i++] = needs_stencil_override ? 2 : 0;
+
+  attributes[i++] = EGL_RED_SIZE;
+  attributes[i++] = 1;
+  attributes[i++] = EGL_GREEN_SIZE;
+  attributes[i++] = 1;
+  attributes[i++] = EGL_BLUE_SIZE;
+  attributes[i++] = 1;
+
+  attributes[i++] = EGL_ALPHA_SIZE;
+  attributes[i++] = config->swap_chain->has_alpha ? 1 : EGL_DONT_CARE;
+
+  attributes[i++] = EGL_DEPTH_SIZE;
+  attributes[i++] = 1;
+
+  /* XXX: Why does the GDL platform choose these by default? */
+#ifdef COGL_HAS_EGL_PLATFORM_GDL_SUPPORT
+  attributes[i++] = EGL_BIND_TO_TEXTURE_RGBA;
+  attributes[i++] = EGL_TRUE;
+  attributes[i++] = EGL_BIND_TO_TEXTURE_RGB;
+  attributes[i++] = EGL_TRUE;
+#endif
+
+  attributes[i++] = EGL_BUFFER_SIZE;
+  attributes[i++] = EGL_DONT_CARE;
+
+  attributes[i++] = EGL_RENDERABLE_TYPE;
+  attributes[i++] = (display->renderer->driver == COGL_DRIVER_GL ?
+                      EGL_OPENGL_BIT :
+                      display->renderer->driver == COGL_DRIVER_GLES1 ?
+                      EGL_OPENGL_ES_BIT :
+                      EGL_OPENGL_ES2_BIT);
+
+  attributes[i++] = EGL_SURFACE_TYPE;
+  attributes[i++] = EGL_WINDOW_BIT;
+
+  attributes[i++] = EGL_NONE;
+
+  g_assert (i < MAX_EGL_CONFIG_ATTRIBS);
+}
+
 static gboolean
 try_create_context (CoglDisplay *display,
-                    int retry_cookie,
-                    gboolean *try_fallback,
+                    gboolean with_stencil_buffer,
                     GError **error)
 {
   CoglDisplayEGL *egl_display = display->winsys;
@@ -612,38 +664,8 @@ try_create_context (CoglDisplay *display,
   EGLConfig config;
   EGLint config_count = 0;
   EGLBoolean status;
-  EGLint cfg_attribs[] = {
-    /* NB: This must be the first attribute, since we may
-     * try and fallback to no stencil buffer */
-    EGL_STENCIL_SIZE,    2,
-
-    EGL_RED_SIZE,        1,
-    EGL_GREEN_SIZE,      1,
-    EGL_BLUE_SIZE,       1,
-    EGL_ALPHA_SIZE,      EGL_DONT_CARE,
-
-    EGL_DEPTH_SIZE,      1,
-
-    /* XXX: Why does the GDL platform choose these by default? */
-#ifdef COGL_HAS_EGL_PLATFORM_GDL_SUPPORT
-    EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE,
-    EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE,
-#endif
-
-    EGL_BUFFER_SIZE,     EGL_DONT_CARE,
-
-    EGL_RENDERABLE_TYPE, (display->renderer->driver == COGL_DRIVER_GL ?
-                          EGL_OPENGL_BIT :
-                          display->renderer->driver == COGL_DRIVER_GLES1 ?
-                          EGL_OPENGL_ES_BIT :
-                          EGL_OPENGL_ES2_BIT),
-
-    EGL_SURFACE_TYPE,    EGL_WINDOW_BIT,
-
-    EGL_NONE
-  };
+  EGLint cfg_attribs[MAX_EGL_CONFIG_ATTRIBS];
   EGLint attribs[3];
-
 #ifdef COGL_HAS_EGL_PLATFORM_POWERVR_X11_SUPPORT
   XVisualInfo *xvisinfo;
   XSetWindowAttributes attrs;
@@ -653,28 +675,18 @@ try_create_context (CoglDisplay *display,
 #endif
   const char *error_message;
 
-  if (display->renderer->driver == COGL_DRIVER_GLES2)
-    {
-      attribs[0] = EGL_CONTEXT_CLIENT_VERSION;
-      attribs[1] = 2;
-      attribs[2] = EGL_NONE;
-    }
-  else
-    attribs[0] = EGL_NONE;
+  egl_attributes_from_framebuffer_config (display,
+                                          &display->onscreen_template->config,
+                                          with_stencil_buffer,
+                                          cfg_attribs);
+
+  g_return_val_if_fail (egl_display->egl_context == NULL, TRUE);
 
   edpy = egl_renderer->edpy;
 
   if (display->renderer->driver == COGL_DRIVER_GL)
     eglBindAPI (EGL_OPENGL_API);
 
-  /* Some GLES hardware can't support a stencil buffer: */
-  if (retry_cookie == 1)
-    {
-      g_warning ("Trying with stencil buffer disabled...");
-      cfg_attribs[1 /* EGL_STENCIL_SIZE */] = 0;
-    }
-  /* XXX: at this point we only have one fallback */
-
   status = eglChooseConfig (edpy,
                             cfg_attribs,
                             &config, 1,
@@ -687,6 +699,15 @@ try_create_context (CoglDisplay *display,
 
   egl_display->egl_config = config;
 
+  if (display->renderer->driver == COGL_DRIVER_GLES2)
+    {
+      attribs[0] = EGL_CONTEXT_CLIENT_VERSION;
+      attribs[1] = 2;
+      attribs[2] = EGL_NONE;
+    }
+  else
+    attribs[0] = EGL_NONE;
+
   egl_display->egl_context = eglCreateContext (edpy,
                                                config,
                                                EGL_NO_CONTEXT,
@@ -919,20 +940,10 @@ try_create_context (CoglDisplay *display,
 
 fail:
 
-  /* Currently we only have one fallback path... */
-  if (retry_cookie == 0)
-    {
-      *try_fallback = TRUE;
-      return FALSE;
-    }
-  else
-    {
-      *try_fallback = FALSE;
-      g_set_error (error, COGL_WINSYS_ERROR,
-                   COGL_WINSYS_ERROR_CREATE_CONTEXT,
-                   "%s", error_message);
-      return FALSE;
-    }
+  g_set_error (error, COGL_WINSYS_ERROR,
+               COGL_WINSYS_ERROR_CREATE_CONTEXT,
+               "%s", error_message);
+  return FALSE;
 }
 
 static void
@@ -997,35 +1008,25 @@ static gboolean
 create_context (CoglDisplay *display, GError **error)
 {
   CoglDisplayEGL *egl_display = display->winsys;
-  gboolean support_transparent_windows;
-  int retry_cookie = 0;
-  gboolean status;
-  gboolean try_fallback;
-  GError *try_error = NULL;
 
-  g_return_val_if_fail (egl_display->egl_context == NULL, TRUE);
-
-  if (display->onscreen_template->swap_chain &&
-      display->onscreen_template->swap_chain->has_alpha)
-    support_transparent_windows = TRUE;
+  /* Note: we don't just rely on eglChooseConfig to correctly
+   * report that the driver doesn't support a stencil buffer
+   * because we've seen PVR drivers that claim stencil buffer
+   * support according to the EGLConfig but then later fail
+   * when trying to create a context with such a config.
+   */
+  if (try_create_context (display, TRUE, error))
+    {
+      egl_display->stencil_disabled = FALSE;
+      return TRUE;
+    }
   else
-    support_transparent_windows = FALSE;
-
-  retry_cookie = 0;
-  while (!(status = try_create_context (display,
-                                        retry_cookie,
-                                        &try_fallback,
-                                        &try_error)) &&
-         try_fallback)
     {
       g_clear_error (error);
       cleanup_context (display);
-      retry_cookie++;
+      egl_display->stencil_disabled = TRUE;
+      return try_create_context (display, FALSE, error);
     }
-  if (!status)
-    g_propagate_error (error, try_error);
-
-  return status;
 }
 
 static void
@@ -1212,9 +1213,32 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
 #ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
   struct wl_visual *wayland_visual;
 #endif
+  EGLint attributes[MAX_EGL_CONFIG_ATTRIBS];
+  EGLConfig egl_config;
+  EGLint config_count = 0;
+  EGLBoolean status;
+  gboolean need_stencil =
+    egl_display->stencil_disabled ? FALSE : framebuffer->config.need_stencil;
 
   g_return_val_if_fail (egl_display->egl_context, FALSE);
 
+  egl_attributes_from_framebuffer_config (display,
+                                          &display->onscreen_template->config,
+                                          need_stencil,
+                                          attributes);
+
+  status = eglChooseConfig (egl_renderer->edpy,
+                            attributes,
+                            &egl_config, 1,
+                            &config_count);
+  if (status != EGL_TRUE || config_count == 0)
+    {
+      g_set_error (error, COGL_WINSYS_ERROR,
+                   COGL_WINSYS_ERROR_CREATE_ONSCREEN,
+                   "Failed to find a suitable EGL configuration");
+      return FALSE;
+    }
+
 #ifdef COGL_HAS_EGL_PLATFORM_POWERVR_X11_SUPPORT
 
   /* FIXME: We need to explicitly Select for ConfigureNotify events.
@@ -1274,7 +1298,7 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
 
       _cogl_xlib_renderer_trap_errors (display->renderer, &state);
 
-      xvisinfo = get_visual_info (display, egl_display->egl_config);
+      xvisinfo = get_visual_info (display, egl_config);
       if (xvisinfo == NULL)
         {
           g_set_error (error, COGL_WINSYS_ERROR,
@@ -1336,7 +1360,7 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
 
   egl_onscreen->egl_surface =
     eglCreateWindowSurface (egl_renderer->edpy,
-                            egl_display->egl_config,
+                            egl_config,
                             (NativeWindowType) xlib_onscreen->xwin,
                             NULL);
 #elif defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT)
@@ -1369,7 +1393,7 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
 
   egl_onscreen->egl_surface =
     eglCreateWindowSurface (egl_renderer->edpy,
-                            egl_display->egl_config,
+                            egl_config,
                             (EGLNativeWindowType)
                             egl_onscreen->wayland_egl_native_window,
                             NULL);
diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c
index 0eda135d..c41fe452 100644
--- a/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/winsys/cogl-winsys-glx.c
@@ -44,6 +44,8 @@
 #include "cogl-texture-2d-private.h"
 #include "cogl-texture-rectangle-private.h"
 #include "cogl-pipeline-opengl-private.h"
+#include "cogl-framebuffer-private.h"
+#include "cogl-swap-chain-private.h"
 
 #include <stdlib.h>
 #include <sys/types.h>
@@ -63,6 +65,7 @@
 #endif
 
 #define COGL_ONSCREEN_X11_EVENT_MASK StructureNotifyMask
+#define MAX_GLX_CONFIG_ATTRIBS 30
 
 typedef struct _CoglContextGLX
 {
@@ -452,34 +455,60 @@ update_winsys_features (CoglContext *context, GError **error)
   return TRUE;
 }
 
+static void
+glx_attributes_from_framebuffer_config (CoglDisplay *display,
+                                        CoglFramebufferConfig *config,
+                                        int *attributes)
+{
+  CoglGLXRenderer *glx_renderer = display->renderer->winsys;
+  int i = 0;
+
+  attributes[i++] = GLX_DRAWABLE_TYPE;
+  attributes[i++] = GLX_WINDOW_BIT;
+
+  attributes[i++] = GLX_RENDER_TYPE;
+  attributes[i++] = GLX_RGBA_BIT;
+
+  attributes[i++] = GLX_DOUBLEBUFFER;
+  attributes[i++] = GL_TRUE;
+
+  attributes[i++] = GLX_RED_SIZE;
+  attributes[i++] = 1;
+  attributes[i++] = GLX_GREEN_SIZE;
+  attributes[i++] = 1;
+  attributes[i++] = GLX_BLUE_SIZE;
+  attributes[i++] = 1;
+  attributes[i++] = GLX_ALPHA_SIZE;
+  attributes[i++] = config->swap_chain->has_alpha ? 1 : GLX_DONT_CARE;
+  attributes[i++] = GLX_DEPTH_SIZE;
+  attributes[i++] = 1;
+  attributes[i++] = GLX_STENCIL_SIZE;
+  attributes[i++] = config->need_stencil ? 1: GLX_DONT_CARE;
+
+  attributes[i++] = None;
+
+  g_assert (i < MAX_GLX_CONFIG_ATTRIBS);
+}
+
 /* It seems the GLX spec never defined an invalid GLXFBConfig that
  * we could overload as an indication of error, so we have to return
  * an explicit boolean status. */
 static gboolean
 find_fbconfig (CoglDisplay *display,
-               gboolean with_alpha,
+               CoglFramebufferConfig *config,
                GLXFBConfig *config_ret,
                GError **error)
 {
   CoglXlibRenderer *xlib_renderer = display->renderer->winsys;
   CoglGLXRenderer *glx_renderer = display->renderer->winsys;
   GLXFBConfig *configs = NULL;
-  int n_configs, i;
-  static const int attributes[] = {
-    GLX_DRAWABLE_TYPE,    GLX_WINDOW_BIT,
-    GLX_RENDER_TYPE,      GLX_RGBA_BIT,
-    GLX_DOUBLEBUFFER,     GL_TRUE,
-    GLX_RED_SIZE,         1,
-    GLX_GREEN_SIZE,       1,
-    GLX_BLUE_SIZE,        1,
-    GLX_ALPHA_SIZE,       1,
-    GLX_DEPTH_SIZE,       1,
-    GLX_STENCIL_SIZE,     1,
-    None
-  };
+  int n_configs;
+  static int attributes[MAX_GLX_CONFIG_ATTRIBS];
   gboolean ret = TRUE;
   int xscreen_num = DefaultScreen (xlib_renderer->xdpy);
 
+  glx_attributes_from_framebuffer_config (display, config, attributes);
+
   configs = glx_renderer->glXChooseFBConfig (xlib_renderer->xdpy,
                                              xscreen_num,
                                              attributes,
@@ -493,8 +522,10 @@ find_fbconfig (CoglDisplay *display,
       goto done;
     }
 
-  if (with_alpha)
+  if (config->swap_chain->has_alpha)
     {
+      int i;
+
       for (i = 0; i < n_configs; i++)
         {
           XVisualInfo *vinfo;
@@ -540,7 +571,8 @@ create_context (CoglDisplay *display, GError **error)
   CoglXlibDisplay *xlib_display = display->winsys;
   CoglXlibRenderer *xlib_renderer = display->renderer->winsys;
   CoglGLXRenderer *glx_renderer = display->renderer->winsys;
-  gboolean support_transparent_windows;
+  gboolean support_transparent_windows =
+    display->onscreen_template->config.swap_chain->has_alpha;
   GLXFBConfig config;
   GError *fbconfig_error = NULL;
   XSetWindowAttributes attrs;
@@ -550,14 +582,8 @@ create_context (CoglDisplay *display, GError **error)
 
   g_return_val_if_fail (glx_display->glx_context == NULL, TRUE);
 
-  if (display->onscreen_template->swap_chain &&
-      display->onscreen_template->swap_chain->has_alpha)
-    support_transparent_windows = TRUE;
-  else
-    support_transparent_windows = FALSE;
-
   glx_display->found_fbconfig =
-    find_fbconfig (display, support_transparent_windows, &config,
+    find_fbconfig (display, &display->onscreen_template->config, &config,
                    &fbconfig_error);
   if (!glx_display->found_fbconfig)
     {
@@ -762,9 +788,23 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
   Window xwin;
   CoglOnscreenXlib *xlib_onscreen;
   CoglOnscreenGLX *glx_onscreen;
+  GLXFBConfig fbconfig;
+  GError *fbconfig_error = NULL;
 
   g_return_val_if_fail (glx_display->glx_context, FALSE);
 
+  if (!find_fbconfig (display, &display->onscreen_template->config,
+                      &fbconfig,
+                      &fbconfig_error))
+    {
+      g_set_error (error, COGL_WINSYS_ERROR,
+                   COGL_WINSYS_ERROR_CREATE_CONTEXT,
+                   "Unable to find suitable fbconfig for the GLX context: %s",
+                   fbconfig_error->message);
+      g_error_free (fbconfig_error);
+      return FALSE;
+    }
+
   /* FIXME: We need to explicitly Select for ConfigureNotify events.
    * For foreign windows we need to be careful not to mess up any
    * existing event mask.
@@ -823,7 +863,7 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
       _cogl_xlib_renderer_trap_errors (display->renderer, &state);
 
       xvisinfo = glx_renderer->glXGetVisualFromFBConfig (xlib_renderer->xdpy,
-                                                         glx_display->fbconfig);
+                                                         fbconfig);
       if (xvisinfo == NULL)
         {
           g_set_error (error, COGL_WINSYS_ERROR,
@@ -887,7 +927,7 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
     {
       glx_onscreen->glxwin =
         glx_renderer->glXCreateWindow (xlib_renderer->xdpy,
-                                       glx_display->fbconfig,
+                                       fbconfig,
                                        xlib_onscreen->xwin,
                                        NULL);
     }