Use common display initialization logic for Unix

src/gpu/gl/glx/SkCreatePlatformGLContext_glx.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gl/SkGLContext.h"
 
 #include <X11/Xlib.h>
 #include <GL/glx.h>
 #include <GL/glu.h>
 
+#include "GrNativeDisplay_glx.h"
+
 namespace {
 
 /* Note: Skia requires glx 1.3 or newer */
 
 /* This struct is taken from a mesa demo.  Please update as required */
 static const struct { int major, minor; } gl_versions[] = {
    {1, 0},
    {1, 1},
    {1, 2},
    {1, 3},
@@ skipping 36 matching lines @@
     Display* fDisplay;
     Pixmap fPixmap;
     GLXPixmap fGlxPixmap;
 };
 
 GLXGLContext::GLXGLContext(GrGLStandard forcedGpuAPI)
     : fContext(nullptr)
     , fDisplay(nullptr)
     , fPixmap(0)
     , fGlxPixmap(0) {
-
     fDisplay = XOpenDisplay(0);
 
     if (!fDisplay) {
         SkDebugf("Failed to open X display.\n");
         this->destroyGLContext();
         return;
     }
 
     // Get a matching FB config

[robertphillips, 2015/10/16 14:54:40]

visualAttribs ?
static const ?

     static int visual_attribs[] = {
         GLX_X_RENDERABLE    , True,
         GLX_DRAWABLE_TYPE   , GLX_PIXMAP_BIT,
         None
     };
 
-    int glx_major, glx_minor;
-
-    // FBConfigs were added in GLX version 1.3.
-    if (!glXQueryVersion(fDisplay, &glx_major, &glx_minor) ||
-            ((glx_major == 1) && (glx_minor < 3)) || (glx_major < 1)) {
-        SkDebugf("GLX version 1.3 or higher required.\n");
+    GLXFBConfig bestFbConfig;
+    if (!GrNativeDisplay::Initialize(visual_attribs, fDisplay, &bestFbConfig)) {
         this->destroyGLContext();
         return;
     }
 
-    //SkDebugf("Getting matching framebuffer configs.\n");
-    int fbcount;
-    GLXFBConfig *fbc = glXChooseFBConfig(fDisplay, DefaultScreen(fDisplay),
-                                          visual_attribs, &fbcount);
-    if (!fbc) {
-        SkDebugf("Failed to retrieve a framebuffer config.\n");
-        this->destroyGLContext();
-        return;
-    }
-    //SkDebugf("Found %d matching FB configs.\n", fbcount);
-
-    // Pick the FB config/visual with the most samples per pixel
-    //SkDebugf("Getting XVisualInfos.\n");
-    int best_fbc = -1, best_num_samp = -1;
-
-    int i;
-    for (i = 0; i < fbcount; ++i) {
-        XVisualInfo *vi = glXGetVisualFromFBConfig(fDisplay, fbc[i]);
-        if (vi) {
-            int samp_buf, samples;
-            glXGetFBConfigAttrib(fDisplay, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf);
-            glXGetFBConfigAttrib(fDisplay, fbc[i], GLX_SAMPLES, &samples);
-
-            //SkDebugf("  Matching fbconfig %d, visual ID 0x%2x: SAMPLE_BUFFERS = %d,"
-            //       " SAMPLES = %d\n",
-            //        i, (unsigned int)vi->visualid, samp_buf, samples);
-
-            if (best_fbc < 0 || (samp_buf && samples > best_num_samp))
-                best_fbc = i, best_num_samp = samples;
-        }
-        XFree(vi);
-    }
-
-    GLXFBConfig bestFbc = fbc[best_fbc];
-
-    // Be sure to free the FBConfig list allocated by glXChooseFBConfig()
-    XFree(fbc);
-
     // Get a visual
-    XVisualInfo *vi = glXGetVisualFromFBConfig(fDisplay, bestFbc);
+    XVisualInfo *vi = glXGetVisualFromFBConfig(fDisplay, bestFbConfig);
     //SkDebugf("Chosen visual ID = 0x%x\n", (unsigned int)vi->visualid);
 
     fPixmap = XCreatePixmap(fDisplay, RootWindow(fDisplay, vi->screen), 10, 10, vi->depth);
 
     if (!fPixmap) {
         SkDebugf("Failed to create pixmap.\n");
         this->destroyGLContext();
         return;
     }
 
     fGlxPixmap = glXCreateGLXPixmap(fDisplay, vi, fPixmap);
 
     // Done with the visual info data
     XFree(vi);
 
     // Create the context
 
     // Install an X error handler so the application won't exit if GL 3.0
     // context allocation fails.
     //
     // Note this error handler is global.
     // All display connections in all threads of a process use the same
     // error handler, so be sure to guard against other threads issuing
     // X commands while this code is running.
     ctxErrorOccurred = false;
-    int (*oldHandler)(Display*, XErrorEvent*) =
-        XSetErrorHandler(&ctxErrorHandler);
+    int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
 
     // Get the default screen's GLX extension list
-    const char *glxExts = glXQueryExtensionsString(
-        fDisplay, DefaultScreen(fDisplay)
-    );
+    const char *glxExts = glXQueryExtensionsString(fDisplay, DefaultScreen(fDisplay));
 
 
     // Check for the GLX_ARB_create_context extension string and the function.
     // If either is not present, use GLX 1.3 context creation method.
     if (!gluCheckExtension(reinterpret_cast<const GLubyte*>("GLX_ARB_create_context"),
                            reinterpret_cast<const GLubyte*>(glxExts))) {
         if (kGLES_GrGLStandard != forcedGpuAPI) {
-            fContext = glXCreateNewContext(fDisplay, bestFbc, GLX_RGBA_TYPE, 0, True);
+            fContext = glXCreateNewContext(fDisplay, bestFbConfig, GLX_RGBA_TYPE, 0, True);
         }
     } else {
         //SkDebugf("Creating context.\n");
         PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB =
             (PFNGLXCREATECONTEXTATTRIBSARBPROC) glXGetProcAddressARB((GrGLubyte*)"glXCreateContextAttribsARB");
 
         if (kGLES_GrGLStandard == forcedGpuAPI) {
             if (gluCheckExtension(
                     reinterpret_cast<const GLubyte*>("GLX_EXT_create_context_es2_profile"),
                     reinterpret_cast<const GLubyte*>(glxExts))) {
                 static const int context_attribs_gles[] = {
                     GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
                     GLX_CONTEXT_MINOR_VERSION_ARB, 0,
                     GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
                     None
                 };
-                fContext = glXCreateContextAttribsARB(fDisplay, bestFbc, 0, True,
+                fContext = glXCreateContextAttribsARB(fDisplay, bestFbConfig, 0, True,
                                                       context_attribs_gles);
             }
         } else {
             // Well, unfortunately GLX will not just give us the highest context so instead we have
             // to do this nastiness
-            for (i = NUM_GL_VERSIONS - 2; i > 0 ; i--) {
+            for (int i = NUM_GL_VERSIONS - 2; i > 0 ; i--) {
                 /* don't bother below GL 3.0 */
                 if (gl_versions[i].major == 3 && gl_versions[i].minor == 0) {
                     break;
                 }
                 // On Nvidia GPUs, to use Nv Path rendering we need a compatibility profile for the
                 // time being.
                 // TODO when Nvidia implements NVPR on Core profiles, we should start requesting
                 // core here
                 static const int context_attribs_gl[] = {
                       GLX_CONTEXT_MAJOR_VERSION_ARB, gl_versions[i].major,
                       GLX_CONTEXT_MINOR_VERSION_ARB, gl_versions[i].minor,
                       GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
                       None
                 };
                 fContext =
-                        glXCreateContextAttribsARB(fDisplay, bestFbc, 0, True, context_attribs_gl);
+                        glXCreateContextAttribsARB(fDisplay, bestFbConfig, 0, True,
+                                                   context_attribs_gl);
 
                 // Sync to ensure any errors generated are processed.
                 XSync(fDisplay, False);
 
                 if (!ctxErrorOccurred && fContext) {
                     break;
                 }
                 // try again
                 ctxErrorOccurred = false;
             }
 
             // Couldn't create GL 3.0 context.
             // Fall back to old-style 2.x context.
             // When a context version below 3.0 is requested,
             // implementations will return the newest context version
             // compatible with OpenGL versions less than version 3.0.
             if (ctxErrorOccurred || !fContext) {
                 static const int context_attribs_gl_fallback[] = {
                     GLX_CONTEXT_MAJOR_VERSION_ARB, 1,
                     GLX_CONTEXT_MINOR_VERSION_ARB, 0,
                     None
                 };
 
                 ctxErrorOccurred = false;
 
-                fContext = glXCreateContextAttribsARB(fDisplay, bestFbc, 0, True,
+                fContext = glXCreateContextAttribsARB(fDisplay, bestFbConfig, 0, True,
                                                       context_attribs_gl_fallback);
             }
         }
     }
 
     // Sync to ensure any errors generated are processed.
     XSync(fDisplay, False);
 
     // Restore the original error handler
     XSetErrorHandler(oldHandler);
@@ skipping 81 matching lines @@
 } // anonymous namespace
 
 SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI) {
     GLXGLContext *ctx = new GLXGLContext(forcedGpuAPI);
     if (!ctx->isValid()) {
         delete ctx;
         return nullptr;
     }
     return ctx;
 }