[lfs-patches] r3288 - trunk/mesa

fernando at higgs.linuxfromscratch.org fernando at higgs.linuxfromscratch.org
Sat Oct 17 12:35:35 PDT 2015


Author: fernando
Date: Sat Oct 17 12:35:35 2015
New Revision: 3288

Log:
\
• Update to mesa-11.0.3-add_xdemos-2.patch.

Added:
   trunk/mesa/mesa-11.0.3-add_xdemos-2.patch

Added: trunk/mesa/mesa-11.0.3-add_xdemos-2.patch
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/mesa/mesa-11.0.3-add_xdemos-2.patch	Sat Oct 17 12:35:35 2015	(r3288)
@@ -0,0 +1,3198 @@
+Submitted By:            Fernando de Oliveira <famobr at yahoo dot com
+                         dot br>, based on previous patches submitted 
+                         by Armin K. <krejzi at email dot com>
+Date:                    2015-10-17
+Initial Package Version: 11.0.3
+Upstream Status:         Not applicable.
+Origin:                  Self.
+Description:             This patch adds two OpenGL demos, glxinfo and
+                         glxgears and respective man pages.
+
+
+diff -Naur a/xdemos/glinfo_common.c b/xdemos/glinfo_common.c
+--- a/xdemos/glinfo_common.c	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/glinfo_common.c	2015-10-17 11:47:19.100139771 -0300
+@@ -0,0 +1,800 @@
++/*
++ * Copyright (C) 1999-2014  Brian Paul   All Rights Reserved.
++ * 
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ * 
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#include <assert.h>
++#include <ctype.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include "glinfo_common.h"
++
++#ifdef _WIN32
++#define snprintf _snprintf
++#endif
++
++
++/**
++ * Return the GL enum name for a numeric value.
++ * We really only care about the compressed texture formats for now.
++ */
++static const char *
++enum_name(GLenum val)
++{
++   static const struct {
++      const char *name;
++      GLenum val;
++   } enums [] = {
++      { "GL_COMPRESSED_ALPHA", 0x84E9 },
++      { "GL_COMPRESSED_LUMINANCE", 0x84EA },
++      { "GL_COMPRESSED_LUMINANCE_ALPHA", 0x84EB },
++      { "GL_COMPRESSED_INTENSITY", 0x84EC },
++      { "GL_COMPRESSED_RGB", 0x84ED },
++      { "GL_COMPRESSED_RGBA", 0x84EE },
++      { "GL_COMPRESSED_TEXTURE_FORMATS", 0x86A3 },
++      { "GL_COMPRESSED_RGB", 0x84ED },
++      { "GL_COMPRESSED_RGBA", 0x84EE },
++      { "GL_COMPRESSED_TEXTURE_FORMATS", 0x86A3 },
++      { "GL_COMPRESSED_ALPHA", 0x84E9 },
++      { "GL_COMPRESSED_LUMINANCE", 0x84EA },
++      { "GL_COMPRESSED_LUMINANCE_ALPHA", 0x84EB },
++      { "GL_COMPRESSED_INTENSITY", 0x84EC },
++      { "GL_COMPRESSED_SRGB", 0x8C48 },
++      { "GL_COMPRESSED_SRGB_ALPHA", 0x8C49 },
++      { "GL_COMPRESSED_SLUMINANCE", 0x8C4A },
++      { "GL_COMPRESSED_SLUMINANCE_ALPHA", 0x8C4B },
++      { "GL_COMPRESSED_RED", 0x8225 },
++      { "GL_COMPRESSED_RG", 0x8226 },
++      { "GL_COMPRESSED_RED_RGTC1", 0x8DBB },
++      { "GL_COMPRESSED_SIGNED_RED_RGTC1", 0x8DBC },
++      { "GL_COMPRESSED_RG_RGTC2", 0x8DBD },
++      { "GL_COMPRESSED_SIGNED_RG_RGTC2", 0x8DBE },
++      { "GL_COMPRESSED_RGB8_ETC2", 0x9274 },
++      { "GL_COMPRESSED_SRGB8_ETC2", 0x9275 },
++      { "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", 0x9276 },
++      { "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", 0x9277 },
++      { "GL_COMPRESSED_RGBA8_ETC2_EAC", 0x9278 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", 0x9279 },
++      { "GL_COMPRESSED_R11_EAC", 0x9270 },
++      { "GL_COMPRESSED_SIGNED_R11_EAC", 0x9271 },
++      { "GL_COMPRESSED_RG11_EAC", 0x9272 },
++      { "GL_COMPRESSED_SIGNED_RG11_EAC", 0x9273 },
++      { "GL_COMPRESSED_ALPHA_ARB", 0x84E9 },
++      { "GL_COMPRESSED_LUMINANCE_ARB", 0x84EA },
++      { "GL_COMPRESSED_LUMINANCE_ALPHA_ARB", 0x84EB },
++      { "GL_COMPRESSED_INTENSITY_ARB", 0x84EC },
++      { "GL_COMPRESSED_RGB_ARB", 0x84ED },
++      { "GL_COMPRESSED_RGBA_ARB", 0x84EE },
++      { "GL_COMPRESSED_TEXTURE_FORMATS_ARB", 0x86A3 },
++      { "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB", 0x8E8C },
++      { "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB", 0x8E8D },
++      { "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB", 0x8E8E },
++      { "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB", 0x8E8F },
++      { "GL_COMPRESSED_RGBA_ASTC_4x4_KHR", 0x93B0 },
++      { "GL_COMPRESSED_RGBA_ASTC_5x4_KHR", 0x93B1 },
++      { "GL_COMPRESSED_RGBA_ASTC_5x5_KHR", 0x93B2 },
++      { "GL_COMPRESSED_RGBA_ASTC_6x5_KHR", 0x93B3 },
++      { "GL_COMPRESSED_RGBA_ASTC_6x6_KHR", 0x93B4 },
++      { "GL_COMPRESSED_RGBA_ASTC_8x5_KHR", 0x93B5 },
++      { "GL_COMPRESSED_RGBA_ASTC_8x6_KHR", 0x93B6 },
++      { "GL_COMPRESSED_RGBA_ASTC_8x8_KHR", 0x93B7 },
++      { "GL_COMPRESSED_RGBA_ASTC_10x5_KHR", 0x93B8 },
++      { "GL_COMPRESSED_RGBA_ASTC_10x6_KHR", 0x93B9 },
++      { "GL_COMPRESSED_RGBA_ASTC_10x8_KHR", 0x93BA },
++      { "GL_COMPRESSED_RGBA_ASTC_10x10_KHR", 0x93BB },
++      { "GL_COMPRESSED_RGBA_ASTC_12x10_KHR", 0x93BC },
++      { "GL_COMPRESSED_RGBA_ASTC_12x12_KHR", 0x93BD },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", 0x93D0 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", 0x93D1 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", 0x93D2 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", 0x93D3 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", 0x93D4 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", 0x93D5 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", 0x93D6 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", 0x93D7 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", 0x93D8 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", 0x93D9 },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", 0x93DA },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", 0x93DB },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", 0x93DC },
++      { "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", 0x93DD },
++      { "GL_COMPRESSED_RGB_FXT1_3DFX", 0x86B0 },
++      { "GL_COMPRESSED_RGBA_FXT1_3DFX", 0x86B1 },
++      { "GL_COMPRESSED_LUMINANCE_LATC1_EXT", 0x8C70 },
++      { "GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT", 0x8C71 },
++      { "GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT", 0x8C72 },
++      { "GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT", 0x8C73 },
++      { "GL_COMPRESSED_RED_RGTC1_EXT", 0x8DBB },
++      { "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT", 0x8DBC },
++      { "GL_COMPRESSED_RED_GREEN_RGTC2_EXT", 0x8DBD },
++      { "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT", 0x8DBE },
++      { "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", 0x83F0 },
++      { "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", 0x83F1 },
++      { "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT", 0x83F2 },
++      { "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT", 0x83F3 },
++      { "GL_COMPRESSED_SRGB_EXT", 0x8C48 },
++      { "GL_COMPRESSED_SRGB_ALPHA_EXT", 0x8C49 },
++      { "GL_COMPRESSED_SLUMINANCE_EXT", 0x8C4A },
++      { "GL_COMPRESSED_SLUMINANCE_ALPHA_EXT", 0x8C4B },
++      { "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT", 0x8C4C },
++      { "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT", 0x8C4D },
++      { "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT", 0x8C4E },
++      { "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT", 0x8C4F },
++      { "GL_PALETTE4_RGB8_OES", 0x8B90 },
++      { "GL_PALETTE4_RGBA8_OES", 0x8B91 },
++      { "GL_PALETTE4_R5_G6_B5_OES", 0x8B92 },
++      { "GL_PALETTE4_RGBA4_OES", 0x8B93 },
++      { "GL_PALETTE4_RGB5_A1_OES", 0x8B94 },
++      { "GL_PALETTE8_RGB8_OES", 0x8B95 },
++      { "GL_PALETTE8_RGBA8_OES", 0x8B96 },
++      { "GL_PALETTE8_R5_G6_B5_OES", 0x8B97 },
++      { "GL_PALETTE8_RGBA4_OES", 0x8B98 },
++      { "GL_PALETTE8_RGB5_A1_OES", 0x8B99 }
++   };
++   const int n = sizeof(enums) / sizeof(enums[0]);
++   static char buffer[100];
++   int i;
++   for (i = 0; i < n; i++) {
++      if (enums[i].val == val) {
++         return enums[i].name;
++      }
++   }
++   /* enum val not found, just print hexadecimal value into static buffer */
++   snprintf(buffer, sizeof(buffer), "0x%x", val);
++   return buffer;
++}
++
++
++/*
++ * qsort callback for string comparison.
++ */
++static int
++compare_string_ptr(const void *p1, const void *p2)
++{
++   return strcmp(* (char * const *) p1, * (char * const *) p2);
++}
++
++/*
++ * Print a list of extensions, with word-wrapping.
++ */
++void
++print_extension_list(const char *ext, GLboolean singleLine)
++{
++   char **extensions;
++   int num_extensions;
++   const char *indentString = "    ";
++   const int indent = 4;
++   const int max = 79;
++   int width, i, j, k;
++
++   if (!ext || !ext[0])
++      return;
++
++   /* count the number of extensions, ignoring successive spaces */
++   num_extensions = 0;
++   j = 1;
++   do {
++      if ((ext[j] == ' ' || ext[j] == 0) && ext[j - 1] != ' ') {
++         ++num_extensions;
++      }
++   } while(ext[j++]);
++
++   /* copy individual extensions to an array */
++   extensions = malloc(num_extensions * sizeof *extensions);
++   if (!extensions) {
++      fprintf(stderr, "Error: malloc() failed\n");
++      exit(1);
++   }
++   i = j = k = 0;
++   while (1) {
++      if (ext[j] == ' ' || ext[j] == 0) {
++         /* found end of an extension name */
++         const int len = j - i;
++
++         if (len) {
++            assert(k < num_extensions);
++
++            extensions[k] = malloc(len + 1);
++            if (!extensions[k]) {
++               fprintf(stderr, "Error: malloc() failed\n");
++               exit(1);
++            }
++
++            memcpy(extensions[k], ext + i, len);
++            extensions[k][len] = 0;
++
++            ++k;
++         };
++
++         i += len + 1;
++
++         if (ext[j] == 0) {
++            break;
++         }
++      }
++      j++;
++   }
++   assert(k == num_extensions);
++
++   /* sort extensions alphabetically */
++   qsort(extensions, num_extensions, sizeof extensions[0], compare_string_ptr);
++
++   /* print the extensions */
++   width = indent;
++   printf("%s", indentString);
++   for (k = 0; k < num_extensions; ++k) {
++      const int len = strlen(extensions[k]);
++      if ((!singleLine) && (width + len > max)) {
++         /* start a new line */
++         printf("\n");
++         width = indent;
++         printf("%s", indentString);
++      }
++      /* print the extension name */
++      printf("%s", extensions[k]);
++
++      /* either we're all done, or we'll continue with next extension */
++      width += len + 1;
++
++      if (singleLine) {
++         printf("\n");
++         width = indent;
++         printf("%s", indentString);
++      }
++      else if (k < (num_extensions -1)) {
++         printf(", ");
++         width += 2;
++      }
++   }
++   printf("\n");
++
++   for (k = 0; k < num_extensions; ++k) {
++      free(extensions[k]);
++   }
++   free(extensions);
++}
++
++
++
++
++/**
++ * Get list of OpenGL extensions using core profile's glGetStringi().
++ */
++char *
++build_core_profile_extension_list(const struct ext_functions *extfuncs)
++{
++   GLint i, n, totalLen;
++   char *buffer;
++
++   glGetIntegerv(GL_NUM_EXTENSIONS, &n);
++
++   /* compute totalLen */
++   totalLen = 0;
++   for (i = 0; i < n; i++) {
++      const char *ext = (const char *) extfuncs->GetStringi(GL_EXTENSIONS, i);
++      if (ext)
++          totalLen += strlen(ext) + 1; /* plus a space */
++   }
++
++   if (!totalLen)
++     return NULL;
++
++   buffer = malloc(totalLen + 1);
++   if (buffer) {
++      int pos = 0;
++      for (i = 0; i < n; i++) {
++         const char *ext = (const char *) extfuncs->GetStringi(GL_EXTENSIONS, i);
++         strcpy(buffer + pos, ext);
++         pos += strlen(ext);
++         buffer[pos++] = ' ';
++      }
++      buffer[pos] = '\0';
++   }
++   return buffer;
++}
++
++
++/** Is extension 'ext' supported? */
++GLboolean
++extension_supported(const char *ext, const char *extensionsList)
++{
++   while (1) {
++      const char *p = strstr(extensionsList, ext);
++      if (p) {
++         /* check that next char is a space or end of string */
++         int extLen = strlen(ext);
++         if (p[extLen] == 0 || p[extLen] == ' ') {
++            return 1;
++         }
++         else {
++            /* We found a superset string, keep looking */
++            extensionsList += extLen;
++         }
++      }
++      else {
++         break;
++      }
++   }
++   return 0;
++}
++
++
++/**
++ * Is verNum >= verString?
++ * \param verString  such as "2.1", "3.0", etc.
++ * \param verNum  such as 20, 21, 30, 31, 32, etc.
++ */
++static GLboolean
++version_supported(const char *verString, int verNum)
++{
++   int v;
++
++   if (!verString ||
++       !isdigit(verString[0]) ||
++       verString[1] != '.' ||
++       !isdigit(verString[2])) {
++      return GL_FALSE;
++   }
++
++   v = (verString[0] - '0') * 10 + (verString[2] - '0');
++
++   return verNum >= v;
++}
++
++
++struct token_name
++{
++   GLenum token;
++   const char *name;
++};
++
++
++static void
++print_shader_limit_list(const struct token_name *lim)
++{
++   GLint max[1];
++   unsigned i;
++
++   for (i = 0; lim[i].token; i++) {
++      glGetIntegerv(lim[i].token, max);
++      if (glGetError() == GL_NO_ERROR) {
++	 printf("        %s = %d\n", lim[i].name, max[0]);
++      }
++   }
++}
++
++
++/**
++ * Print interesting limits for vertex/fragment shaders.
++ */
++static void
++print_shader_limits(GLenum target)
++{
++   static const struct token_name vertex_limits[] = {
++      { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB" },
++      { GL_MAX_VARYING_FLOATS_ARB, "GL_MAX_VARYING_FLOATS_ARB" },
++      { GL_MAX_VERTEX_ATTRIBS_ARB, "GL_MAX_VERTEX_ATTRIBS_ARB" },
++      { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
++      { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" },
++      { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB" },
++      { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
++      { GL_MAX_VERTEX_OUTPUT_COMPONENTS  , "GL_MAX_VERTEX_OUTPUT_COMPONENTS  " },
++      { (GLenum) 0, NULL }
++   };
++   static const struct token_name fragment_limits[] = {
++      { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB" },
++      { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
++      { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
++      { GL_MAX_FRAGMENT_INPUT_COMPONENTS , "GL_MAX_FRAGMENT_INPUT_COMPONENTS " },
++      { (GLenum) 0, NULL }
++   };
++   static const struct token_name geometry_limits[] = {
++      { GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS" },
++      { GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS" },
++      { GL_MAX_GEOMETRY_OUTPUT_VERTICES  , "GL_MAX_GEOMETRY_OUTPUT_VERTICES  " },
++      { GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS" },
++      { GL_MAX_GEOMETRY_INPUT_COMPONENTS , "GL_MAX_GEOMETRY_INPUT_COMPONENTS " },
++      { GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS" },
++      { (GLenum) 0, NULL }
++   };
++
++   switch (target) {
++   case GL_VERTEX_SHADER:
++      printf("    GL_VERTEX_SHADER_ARB:\n");
++      print_shader_limit_list(vertex_limits);
++      break;
++
++   case GL_FRAGMENT_SHADER:
++      printf("    GL_FRAGMENT_SHADER_ARB:\n");
++      print_shader_limit_list(fragment_limits);
++      break;
++
++   case GL_GEOMETRY_SHADER:
++      printf("    GL_GEOMETRY_SHADER:\n");
++      print_shader_limit_list(geometry_limits);
++      break;
++   }
++}
++
++
++/**
++ * Print interesting limits for vertex/fragment programs.
++ */
++static void
++print_program_limits(GLenum target, 
++                     const struct ext_functions *extfuncs)
++{
++#if defined(GL_ARB_vertex_program) || defined(GL_ARB_fragment_program)
++   struct token_name {
++      GLenum token;
++      const char *name;
++   };
++   static const struct token_name common_limits[] = {
++      { GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" },
++      { GL_MAX_PROGRAM_TEMPORARIES_ARB, "GL_MAX_PROGRAM_TEMPORARIES_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" },
++      { GL_MAX_PROGRAM_PARAMETERS_ARB, "GL_MAX_PROGRAM_PARAMETERS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB" },
++      { GL_MAX_PROGRAM_ATTRIBS_ARB, "GL_MAX_PROGRAM_ATTRIBS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB" },
++      { GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" },
++      { GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB" },
++      { GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB" },
++      { (GLenum) 0, NULL }
++   };
++   static const struct token_name fragment_limits[] = {
++      { GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB" },
++      { GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB" },
++      { GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" },
++      { GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" },
++      { (GLenum) 0, NULL }
++   };
++
++   GLint max[1];
++   int i;
++
++   if (target == GL_VERTEX_PROGRAM_ARB) {
++      printf("    GL_VERTEX_PROGRAM_ARB:\n");
++   }
++   else if (target == GL_FRAGMENT_PROGRAM_ARB) {
++      printf("    GL_FRAGMENT_PROGRAM_ARB:\n");
++   }
++   else {
++      return; /* something's wrong */
++   }
++
++   for (i = 0; common_limits[i].token; i++) {
++      extfuncs->GetProgramivARB(target, common_limits[i].token, max);
++      if (glGetError() == GL_NO_ERROR) {
++         printf("        %s = %d\n", common_limits[i].name, max[0]);
++      }
++   }
++   if (target == GL_FRAGMENT_PROGRAM_ARB) {
++      for (i = 0; fragment_limits[i].token; i++) {
++         extfuncs->GetProgramivARB(target, fragment_limits[i].token, max);
++         if (glGetError() == GL_NO_ERROR) {
++            printf("        %s = %d\n", fragment_limits[i].name, max[0]);
++         }
++      }
++   }
++#endif /* GL_ARB_vertex_program / GL_ARB_fragment_program */
++}
++
++
++/**
++ * Print interesting OpenGL implementation limits.
++ * \param version  20, 21, 30, 31, 32, etc.
++ */
++void
++print_limits(const char *extensions, const char *oglstring, int version,
++             const struct ext_functions *extfuncs)
++{
++   struct token_name {
++      GLuint count;
++      GLenum token;
++      const char *name;
++      const char *extension; /* NULL or GL extension name or version string */
++   };
++   static const struct token_name limits[] = {
++      { 1, GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH", NULL },
++      { 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", NULL },
++      { 1, GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES", NULL },
++      { 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH", "GL_ARB_imaging" },
++      { 1, GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES", NULL },
++      { 1, GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES", NULL },
++      { 1, GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER", NULL },
++      { 1, GL_MAX_LIGHTS, "GL_MAX_LIGHTS", NULL },
++      { 1, GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING", NULL },
++      { 1, GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH", NULL },
++      { 1, GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH", NULL },
++      { 1, GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE", NULL },
++      { 1, GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH", NULL },
++      { 1, GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH", NULL },
++      { 1, GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE", NULL },
++      { 1, GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE", NULL },
++#if defined(GL_EXT_texture_array)
++      { 1, GL_MAX_ARRAY_TEXTURE_LAYERS_EXT, "GL_MAX_ARRAY_TEXTURE_LAYERS", "GL_EXT_texture_array" },
++#endif
++      { 2, GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS", NULL },
++      { 2, GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE", NULL },
++      { 2, GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE", NULL },
++      { 2, GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE", NULL },
++      { 2, GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE", NULL },
++#if defined(GL_ARB_texture_cube_map)
++      { 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB", "GL_ARB_texture_cube_map" },
++#endif
++#if defined(GL_NV_texture_rectangle)
++      { 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV", "GL_NV_texture_rectangle" },
++#endif
++#if defined(GL_ARB_multitexture)
++      { 1, GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB", "GL_ARB_multitexture" },
++#endif
++#if defined(GL_EXT_texture_lod_bias)
++      { 1, GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT", "GL_EXT_texture_lod_bias" },
++#endif
++#if defined(GL_EXT_texture_filter_anisotropic)
++      { 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", "GL_EXT_texture_filter_anisotropic" },
++#endif
++#if defined(GL_ARB_draw_buffers)
++      { 1, GL_MAX_DRAW_BUFFERS_ARB, "GL_MAX_DRAW_BUFFERS_ARB", "GL_ARB_draw_buffers" },
++#endif
++#if defined(GL_ARB_blend_func_extended)
++      { 1, GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS", "GL_ARB_blend_func_extended" },
++#endif
++#if defined (GL_ARB_framebuffer_object)
++      { 1, GL_MAX_RENDERBUFFER_SIZE, "GL_MAX_RENDERBUFFER_SIZE", "GL_ARB_framebuffer_object" },
++      { 1, GL_MAX_COLOR_ATTACHMENTS, "GL_MAX_COLOR_ATTACHMENTS", "GL_ARB_framebuffer_object" },
++      { 1, GL_MAX_SAMPLES, "GL_MAX_SAMPLES", "GL_ARB_framebuffer_object" },
++#endif
++#if defined (GL_EXT_transform_feedback)
++     { 1, GL_MAX_TRANSFORM_FEEDBACK_BUFFERS, "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS", "GL_EXT_transform_feedback" },
++     { 1, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", "GL_EXT_transform_feedback" },
++     { 1, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", "GL_EXT_transform_feedback", },
++     { 1, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT, "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", "GL_EXT_transform_feedback" },
++#endif
++#if defined (GL_ARB_texture_buffer_object)
++      { 1, GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT", "GL_ARB_texture_buffer_object" },
++      { 1, GL_MAX_TEXTURE_BUFFER_SIZE, "GL_MAX_TEXTURE_BUFFER_SIZE", "GL_ARB_texture_buffer_object" },
++#endif
++#if defined (GL_ARB_texture_multisample)
++      { 1, GL_MAX_COLOR_TEXTURE_SAMPLES, "GL_MAX_COLOR_TEXTURE_SAMPLES", "GL_ARB_texture_multisample" },
++      { 1, GL_MAX_DEPTH_TEXTURE_SAMPLES, "GL_MAX_DEPTH_TEXTURE_SAMPLES", "GL_ARB_texture_multisample" },
++      { 1, GL_MAX_INTEGER_SAMPLES, "GL_MAX_INTEGER_SAMPLES", "GL_ARB_texture_multisample" },
++#endif
++#if defined (GL_ARB_uniform_buffer_object)
++      { 1, GL_MAX_VERTEX_UNIFORM_BLOCKS, "GL_MAX_VERTEX_UNIFORM_BLOCKS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_FRAGMENT_UNIFORM_BLOCKS, "GL_MAX_FRAGMENT_UNIFORM_BLOCKS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_GEOMETRY_UNIFORM_BLOCKS, "GL_MAX_GEOMETRY_UNIFORM_BLOCKS" , "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_COMBINED_UNIFORM_BLOCKS, "GL_MAX_COMBINED_UNIFORM_BLOCKS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_UNIFORM_BUFFER_BINDINGS, "GL_MAX_UNIFORM_BUFFER_BINDINGS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_UNIFORM_BLOCK_SIZE, "GL_MAX_UNIFORM_BLOCK_SIZE", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS", "GL_ARB_uniform_buffer_object" },
++      { 1, GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT", "GL_ARB_uniform_buffer_object" },
++#endif
++#if defined (GL_ARB_vertex_attrib_binding)
++      { 1, GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET", "GL_ARB_vertex_attrib_binding" },
++      { 1, GL_MAX_VERTEX_ATTRIB_BINDINGS, "GL_MAX_VERTEX_ATTRIB_BINDINGS", "GL_ARB_vertex_attrib_binding" },
++#endif
++#if defined(GL_VERSION_4_4)
++      { 1, GL_MAX_VERTEX_ATTRIB_STRIDE, "GL_MAX_VERTEX_ATTRIB_STRIDE", "4.4" },
++#endif
++      { 0, (GLenum) 0, NULL, NULL }
++   };
++   GLint i, max[2];
++
++   printf("%s limits:\n", oglstring);
++   for (i = 0; limits[i].count; i++) {
++      if (!limits[i].extension ||
++          version_supported(limits[i].extension, version) ||
++          extension_supported(limits[i].extension, extensions)) {
++         glGetIntegerv(limits[i].token, max);
++         if (glGetError() == GL_NO_ERROR) {
++            if (limits[i].count == 1)
++               printf("    %s = %d\n", limits[i].name, max[0]);
++            else /* XXX fix if we ever query something with more than 2 values */
++               printf("    %s = %d, %d\n", limits[i].name, max[0], max[1]);
++         }
++      }
++   }
++
++   /* these don't fit into the above mechanism, unfortunately */
++   if (extension_supported("GL_ARB_imaging", extensions)) {
++      extfuncs->GetConvolutionParameteriv(GL_CONVOLUTION_2D,
++                                          GL_MAX_CONVOLUTION_WIDTH, max);
++      extfuncs->GetConvolutionParameteriv(GL_CONVOLUTION_2D,
++                                          GL_MAX_CONVOLUTION_HEIGHT, max+1);
++      printf("    GL_MAX_CONVOLUTION_WIDTH/HEIGHT = %d, %d\n", max[0], max[1]);
++   }
++
++   if (extension_supported("GL_ARB_texture_compression", extensions)) {
++      GLint i, n;
++      GLint *formats;
++      glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &n);
++      printf("    GL_NUM_COMPRESSED_TEXTURE_FORMATS = %d\n", n);
++      formats = (GLint *) malloc(n * sizeof(GLint));
++      glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats);
++      for (i = 0; i < n; i++) {
++         printf("        %s\n", enum_name(formats[i]));
++      }
++      free(formats);
++   }
++#if defined(GL_ARB_vertex_program)
++   if (extension_supported("GL_ARB_vertex_program", extensions)) {
++      print_program_limits(GL_VERTEX_PROGRAM_ARB, extfuncs);
++   }
++#endif
++#if defined(GL_ARB_fragment_program)
++   if (extension_supported("GL_ARB_fragment_program", extensions)) {
++      print_program_limits(GL_FRAGMENT_PROGRAM_ARB, extfuncs);
++   }
++#endif
++   if (extension_supported("GL_ARB_vertex_shader", extensions)) {
++      print_shader_limits(GL_VERTEX_SHADER_ARB);
++   }
++   if (extension_supported("GL_ARB_fragment_shader", extensions)) {
++      print_shader_limits(GL_FRAGMENT_SHADER_ARB);
++   }
++   if (version >= 32) {
++      print_shader_limits(GL_GEOMETRY_SHADER);
++   }
++}
++
++
++
++/**
++ * Return string representation for bits in a bitmask.
++ */
++const char *
++bitmask_to_string(const struct bit_info bits[], int numBits, int mask)
++{
++   static char buffer[256], *p;
++   int i;
++
++   strcpy(buffer, "(none)");
++   p = buffer;
++   for (i = 0; i < numBits; i++) {
++      if (mask & bits[i].bit) {
++         if (p > buffer)
++            *p++ = ',';
++         strcpy(p, bits[i].name);
++         p += strlen(bits[i].name);
++      }
++   }
++
++   return buffer;
++}
++
++/**
++ * Return string representation for the bitmask returned by
++ * GL_CONTEXT_PROFILE_MASK (OpenGL 3.2 or later).
++ */
++const char *
++profile_mask_string(int mask)
++{
++   const static struct bit_info bits[] = {
++#ifdef GL_CONTEXT_CORE_PROFILE_BIT
++      { GL_CONTEXT_CORE_PROFILE_BIT, "core profile"},
++#endif
++#ifdef GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
++      { GL_CONTEXT_COMPATIBILITY_PROFILE_BIT, "compatibility profile" }
++#endif
++   };
++
++   return bitmask_to_string(bits, ELEMENTS(bits), mask);
++}
++
++
++/**
++ * Return string representation for the bitmask returned by
++ * GL_CONTEXT_FLAGS (OpenGL 3.0 or later).
++ */
++const char *
++context_flags_string(int mask)
++{
++   const static struct bit_info bits[] = {
++#ifdef GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
++      { GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT, "forward-compatible" },
++#endif
++#ifdef GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB
++      { GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB, "robust-access" },
++#endif
++   };
++
++   return bitmask_to_string(bits, ELEMENTS(bits), mask);
++}
++
++
++static void
++usage(void)
++{
++#ifdef _WIN32
++   printf("Usage: wglinfo [-v] [-t] [-h] [-b] [-l] [-s]\n");
++#else
++   printf("Usage: glxinfo [-v] [-t] [-h] [-b] [-l] [-s] [-i] [-display <dname>]\n");
++   printf("\t-display <dname>: Print GLX visuals on specified server.\n");
++   printf("\t-i: Force an indirect rendering context.\n");
++#endif
++   printf("\t-B: brief output, print only the basics.\n");
++   printf("\t-v: Print visuals info in verbose form.\n");
++   printf("\t-t: Print verbose table.\n");
++   printf("\t-h: This information.\n");
++   printf("\t-b: Find the 'best' visual and print its number.\n");
++   printf("\t-l: Print interesting OpenGL limits.\n");
++   printf("\t-s: Print a single extension per line.\n");
++}
++
++void
++parse_args(int argc, char *argv[], struct options *options)
++{
++   int i;
++
++   options->mode = Normal;
++   options->findBest = GL_FALSE;
++   options->limits = GL_FALSE;
++   options->singleLine = GL_FALSE;
++   options->displayName = NULL;
++   options->allowDirect = GL_TRUE;
++
++   for (i = 1; i < argc; i++) {
++#ifndef _WIN32
++      if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
++         options->displayName = argv[i + 1];
++         i++;
++      }
++      else if (strcmp(argv[i], "-i") == 0) {
++         options->allowDirect = GL_FALSE;
++      }
++      else
++#endif
++      if (strcmp(argv[i], "-t") == 0) {
++         options->mode = Wide;
++      }
++      else if (strcmp(argv[i], "-v") == 0) {
++         options->mode = Verbose;
++      }
++      else if (strcmp(argv[i], "-B") == 0) {
++         options->mode = Brief;
++      }
++      else if (strcmp(argv[i], "-b") == 0) {
++         options->findBest = GL_TRUE;
++      }
++      else if (strcmp(argv[i], "-l") == 0) {
++         options->limits = GL_TRUE;
++      }
++      else if (strcmp(argv[i], "-h") == 0) {
++         usage();
++         exit(0);
++      }
++      else if(strcmp(argv[i], "-s") == 0) {
++         options->singleLine = GL_TRUE;
++      }
++      else {
++         printf("Unknown option `%s'\n", argv[i]);
++         usage();
++         exit(0);
++      }
++   }
++}
+diff -Naur a/xdemos/glinfo_common.h b/xdemos/glinfo_common.h
+--- a/xdemos/glinfo_common.h	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/glinfo_common.h	2015-10-17 11:47:19.100139771 -0300
+@@ -0,0 +1,142 @@
++/*
++ * Copyright (C) 1999-2014  Brian Paul   All Rights Reserved.
++ * 
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ * 
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++
++/**
++ * Common code shared by glxinfo and wglinfo.
++ */
++
++#ifndef GLINFO_COMMON_H
++#define GLINFO_COMMON_H
++
++
++#ifdef _WIN32
++/* GL/glext.h is not commonly available on Windows. */
++#include <GL/glew.h>
++#else
++#include <GL/gl.h>
++#include <GL/glext.h>
++#endif
++
++typedef void (APIENTRY * GETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params);
++typedef const GLubyte *(APIENTRY * GETSTRINGIPROC) (GLenum name, GLuint index);
++typedef void (APIENTRY * GETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
++
++
++/**
++ * Ext functions needed in common code but must be provided by
++ * glxinfo or wglinfo.
++ */
++struct ext_functions
++{
++   GETPROGRAMIVARBPROC GetProgramivARB;
++   GETSTRINGIPROC GetStringi;
++   GETCONVOLUTIONPARAMETERIVPROC GetConvolutionParameteriv;
++};
++
++
++#define ELEMENTS(array) (sizeof(array) / sizeof(array[0]))
++
++
++struct bit_info
++{
++   int bit;
++   const char *name;
++};
++
++
++typedef enum
++{
++   Normal,
++   Wide,
++   Verbose,
++   Brief
++} InfoMode;
++
++
++struct options
++{
++   InfoMode mode;
++   GLboolean findBest;
++   GLboolean limits;
++   GLboolean singleLine;
++   /* GLX only */
++   char *displayName;
++   GLboolean allowDirect;
++};
++
++
++/** list of known OpenGL versions */
++static const struct { int major, minor; } gl_versions[] = {
++   {4, 5},
++   {4, 4},
++   {4, 3},
++   {4, 2},
++   {4, 1},
++   {4, 0},
++
++   {3, 3},
++   {3, 2},
++   {3, 1},
++   {3, 0},
++
++   {2, 1},
++   {2, 0},
++
++   {1, 5},
++   {1, 4},
++   {1, 3},
++   {1, 2},
++   {1, 1},
++   {1, 0},
++
++   {0, 0} /* end of list */
++};
++
++
++void
++print_extension_list(const char *ext, GLboolean singleLine);
++
++char *
++build_core_profile_extension_list(const struct ext_functions *extfuncs);
++
++GLboolean
++extension_supported(const char *ext, const char *extensionsList);
++
++void
++print_limits(const char *extensions, const char *oglstring, int version,
++             const struct ext_functions *extfuncs);
++
++const char *
++bitmask_to_string(const struct bit_info bits[], int numBits, int mask);
++
++const char *
++profile_mask_string(int mask);
++
++const char *
++context_flags_string(int mask);
++
++
++void
++parse_args(int argc, char *argv[], struct options *options);
++
++
++#endif /* GLINFO_COMMON_H */
+diff -Naur a/xdemos/glxgears.1 b/xdemos/glxgears.1
+--- a/xdemos/glxgears.1	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/glxgears.1	2015-10-17 12:14:26.566042037 -0300
+@@ -0,0 +1,37 @@
++.TH glxgears 1 "2006-11-29"
++.SH NAME
++glxgears \- ``gears'' demo for GLX
++.SH SYNOPSIS
++.B glxgears
++.RI [ options ]
++.SH DESCRIPTION
++The \fIglxgears\fP program is a port of the ``gears'' demo to GLX. It displays
++a set of rotating gears and prints out the frame rate at regular intervals. It
++has become quite popular as basic benchmarking tool.
++.SH OPTIONS
++.TP 8
++.B \-display \fIdisplay\fP
++Specify which X display to run on.
++.TP 8
++.B \-stereo
++Use a stereo enabled GLX visual.
++.TP 8
++.B \-samples \fIN\fP
++Run in multisample mode with at least N samples.
++.TP 8
++.B \-fullscreen
++Run in fullscreen mode.
++.TP 8
++.B \-info
++Display OpenGL renderer information.
++.TP 8
++.B \-geometry \fIWxH+X+Y\fP
++Window geometry.
++.SH AUTHOR
++glxgears was written by Brian Paul <brian.paul at tungstengraphics.com>.
++.PP
++This manual page was written by Thierry Reding <thierry at gilfi.de>, for the
++Debian project and updated by Fernando de Oliveira <famobr at yahoo dot
++com dot br>, for the Linux From Scratch (LFS) project (but may be used by
++others).
++
++
+diff -Naur a/xdemos/glxgears.c b/xdemos/glxgears.c
+--- a/xdemos/glxgears.c	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/glxgears.c	2015-10-17 11:47:19.101139750 -0300
+@@ -0,0 +1,809 @@
++/*
++ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
++ * 
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ * 
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/*
++ * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT)
++ * Port by Brian Paul  23 March 2001
++ *
++ * See usage() below for command line options.
++ */
++
++
++#include <math.h>
++#include <stdlib.h>
++#include <stdio.h>
++#include <string.h>
++#include <X11/Xlib.h>
++#include <X11/keysym.h>
++#include <GL/gl.h>
++#include <GL/glx.h>
++#include <GL/glxext.h>
++
++#ifndef GLX_MESA_swap_control
++#define GLX_MESA_swap_control 1
++typedef int (*PFNGLXGETSWAPINTERVALMESAPROC)(void);
++#endif
++
++
++#define BENCHMARK
++
++#ifdef BENCHMARK
++
++/* XXX this probably isn't very portable */
++
++#include <sys/time.h>
++#include <unistd.h>
++
++/* return current time (in seconds) */
++static double
++current_time(void)
++{
++   struct timeval tv;
++#ifdef __VMS
++   (void) gettimeofday(&tv, NULL );
++#else
++   struct timezone tz;
++   (void) gettimeofday(&tv, &tz);
++#endif
++   return (double) tv.tv_sec + tv.tv_usec / 1000000.0;
++}
++
++#else /*BENCHMARK*/
++
++/* dummy */
++static double
++current_time(void)
++{
++   /* update this function for other platforms! */
++   static double t = 0.0;
++   static int warn = 1;
++   if (warn) {
++      fprintf(stderr, "Warning: current_time() not implemented!!\n");
++      warn = 0;
++   }
++   return t += 1.0;
++}
++
++#endif /*BENCHMARK*/
++
++
++
++#ifndef M_PI
++#define M_PI 3.14159265
++#endif
++
++
++/** Event handler results: */
++#define NOP 0
++#define EXIT 1
++#define DRAW 2
++
++static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
++static GLint gear1, gear2, gear3;
++static GLfloat angle = 0.0;
++
++static GLboolean fullscreen = GL_FALSE;	/* Create a single fullscreen window */
++static GLboolean stereo = GL_FALSE;	/* Enable stereo.  */
++static GLint samples = 0;               /* Choose visual with at least N samples. */
++static GLboolean animate = GL_TRUE;	/* Animation */
++static GLfloat eyesep = 5.0;		/* Eye separation. */
++static GLfloat fix_point = 40.0;	/* Fixation point distance.  */
++static GLfloat left, right, asp;	/* Stereo frustum params.  */
++
++
++/*
++ *
++ *  Draw a gear wheel.  You'll probably want to call this function when
++ *  building a display list since we do a lot of trig here.
++ * 
++ *  Input:  inner_radius - radius of hole at center
++ *          outer_radius - radius at center of teeth
++ *          width - width of gear
++ *          teeth - number of teeth
++ *          tooth_depth - depth of tooth
++ */
++static void
++gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
++     GLint teeth, GLfloat tooth_depth)
++{
++   GLint i;
++   GLfloat r0, r1, r2;
++   GLfloat angle, da;
++   GLfloat u, v, len;
++
++   r0 = inner_radius;
++   r1 = outer_radius - tooth_depth / 2.0;
++   r2 = outer_radius + tooth_depth / 2.0;
++
++   da = 2.0 * M_PI / teeth / 4.0;
++
++   glShadeModel(GL_FLAT);
++
++   glNormal3f(0.0, 0.0, 1.0);
++
++   /* draw front face */
++   glBegin(GL_QUAD_STRIP);
++   for (i = 0; i <= teeth; i++) {
++      angle = i * 2.0 * M_PI / teeth;
++      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
++      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
++      if (i < teeth) {
++	 glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
++	 glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
++		    width * 0.5);
++      }
++   }
++   glEnd();
++
++   /* draw front sides of teeth */
++   glBegin(GL_QUADS);
++   da = 2.0 * M_PI / teeth / 4.0;
++   for (i = 0; i < teeth; i++) {
++      angle = i * 2.0 * M_PI / teeth;
++
++      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
++      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
++      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
++		 width * 0.5);
++      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
++		 width * 0.5);
++   }
++   glEnd();
++
++   glNormal3f(0.0, 0.0, -1.0);
++
++   /* draw back face */
++   glBegin(GL_QUAD_STRIP);
++   for (i = 0; i <= teeth; i++) {
++      angle = i * 2.0 * M_PI / teeth;
++      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
++      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
++      if (i < teeth) {
++	 glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
++		    -width * 0.5);
++	 glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
++      }
++   }
++   glEnd();
++
++   /* draw back sides of teeth */
++   glBegin(GL_QUADS);
++   da = 2.0 * M_PI / teeth / 4.0;
++   for (i = 0; i < teeth; i++) {
++      angle = i * 2.0 * M_PI / teeth;
++
++      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
++		 -width * 0.5);
++      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
++		 -width * 0.5);
++      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
++      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
++   }
++   glEnd();
++
++   /* draw outward faces of teeth */
++   glBegin(GL_QUAD_STRIP);
++   for (i = 0; i < teeth; i++) {
++      angle = i * 2.0 * M_PI / teeth;
++
++      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
++      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
++      u = r2 * cos(angle + da) - r1 * cos(angle);
++      v = r2 * sin(angle + da) - r1 * sin(angle);
++      len = sqrt(u * u + v * v);
++      u /= len;
++      v /= len;
++      glNormal3f(v, -u, 0.0);
++      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
++      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
++      glNormal3f(cos(angle), sin(angle), 0.0);
++      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
++		 width * 0.5);
++      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
++		 -width * 0.5);
++      u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
++      v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
++      glNormal3f(v, -u, 0.0);
++      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
++		 width * 0.5);
++      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
++		 -width * 0.5);
++      glNormal3f(cos(angle), sin(angle), 0.0);
++   }
++
++   glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
++   glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
++
++   glEnd();
++
++   glShadeModel(GL_SMOOTH);
++
++   /* draw inside radius cylinder */
++   glBegin(GL_QUAD_STRIP);
++   for (i = 0; i <= teeth; i++) {
++      angle = i * 2.0 * M_PI / teeth;
++      glNormal3f(-cos(angle), -sin(angle), 0.0);
++      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
++      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
++   }
++   glEnd();
++}
++
++
++static void
++draw(void)
++{
++   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++
++   glPushMatrix();
++   glRotatef(view_rotx, 1.0, 0.0, 0.0);
++   glRotatef(view_roty, 0.0, 1.0, 0.0);
++   glRotatef(view_rotz, 0.0, 0.0, 1.0);
++
++   glPushMatrix();
++   glTranslatef(-3.0, -2.0, 0.0);
++   glRotatef(angle, 0.0, 0.0, 1.0);
++   glCallList(gear1);
++   glPopMatrix();
++
++   glPushMatrix();
++   glTranslatef(3.1, -2.0, 0.0);
++   glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
++   glCallList(gear2);
++   glPopMatrix();
++
++   glPushMatrix();
++   glTranslatef(-3.1, 4.2, 0.0);
++   glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
++   glCallList(gear3);
++   glPopMatrix();
++
++   glPopMatrix();
++}
++
++
++static void
++draw_gears(void)
++{
++   if (stereo) {
++      /* First left eye.  */
++      glDrawBuffer(GL_BACK_LEFT);
++
++      glMatrixMode(GL_PROJECTION);
++      glLoadIdentity();
++      glFrustum(left, right, -asp, asp, 5.0, 60.0);
++
++      glMatrixMode(GL_MODELVIEW);
++
++      glPushMatrix();
++      glTranslated(+0.5 * eyesep, 0.0, 0.0);
++      draw();
++      glPopMatrix();
++
++      /* Then right eye.  */
++      glDrawBuffer(GL_BACK_RIGHT);
++
++      glMatrixMode(GL_PROJECTION);
++      glLoadIdentity();
++      glFrustum(-right, -left, -asp, asp, 5.0, 60.0);
++
++      glMatrixMode(GL_MODELVIEW);
++
++      glPushMatrix();
++      glTranslated(-0.5 * eyesep, 0.0, 0.0);
++      draw();
++      glPopMatrix();
++   }
++   else {
++      draw();
++   }
++}
++
++
++/** Draw single frame, do SwapBuffers, compute FPS */
++static void
++draw_frame(Display *dpy, Window win)
++{
++   static int frames = 0;
++   static double tRot0 = -1.0, tRate0 = -1.0;
++   double dt, t = current_time();
++
++   if (tRot0 < 0.0)
++      tRot0 = t;
++   dt = t - tRot0;
++   tRot0 = t;
++
++   if (animate) {
++      /* advance rotation for next frame */
++      angle += 70.0 * dt;  /* 70 degrees per second */
++      if (angle > 3600.0)
++         angle -= 3600.0;
++   }
++
++   draw_gears();
++   glXSwapBuffers(dpy, win);
++
++   frames++;
++   
++   if (tRate0 < 0.0)
++      tRate0 = t;
++   if (t - tRate0 >= 5.0) {
++      GLfloat seconds = t - tRate0;
++      GLfloat fps = frames / seconds;
++      printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
++             fps);
++      fflush(stdout);
++      tRate0 = t;
++      frames = 0;
++   }
++}
++
++
++/* new window size or exposure */
++static void
++reshape(int width, int height)
++{
++   glViewport(0, 0, (GLint) width, (GLint) height);
++
++   if (stereo) {
++      GLfloat w;
++
++      asp = (GLfloat) height / (GLfloat) width;
++      w = fix_point * (1.0 / 5.0);
++
++      left = -5.0 * ((w - 0.5 * eyesep) / fix_point);
++      right = 5.0 * ((w + 0.5 * eyesep) / fix_point);
++   }
++   else {
++      GLfloat h = (GLfloat) height / (GLfloat) width;
++
++      glMatrixMode(GL_PROJECTION);
++      glLoadIdentity();
++      glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
++   }
++   
++   glMatrixMode(GL_MODELVIEW);
++   glLoadIdentity();
++   glTranslatef(0.0, 0.0, -40.0);
++}
++   
++
++
++static void
++init(void)
++{
++   static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
++   static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
++   static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
++   static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
++
++   glLightfv(GL_LIGHT0, GL_POSITION, pos);
++   glEnable(GL_CULL_FACE);
++   glEnable(GL_LIGHTING);
++   glEnable(GL_LIGHT0);
++   glEnable(GL_DEPTH_TEST);
++
++   /* make the gears */
++   gear1 = glGenLists(1);
++   glNewList(gear1, GL_COMPILE);
++   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
++   gear(1.0, 4.0, 1.0, 20, 0.7);
++   glEndList();
++
++   gear2 = glGenLists(1);
++   glNewList(gear2, GL_COMPILE);
++   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
++   gear(0.5, 2.0, 2.0, 10, 0.7);
++   glEndList();
++
++   gear3 = glGenLists(1);
++   glNewList(gear3, GL_COMPILE);
++   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
++   gear(1.3, 2.0, 0.5, 10, 0.7);
++   glEndList();
++
++   glEnable(GL_NORMALIZE);
++}
++
++
++/**
++ * Remove window border/decorations.
++ */
++static void
++no_border( Display *dpy, Window w)
++{
++   static const unsigned MWM_HINTS_DECORATIONS = (1 << 1);
++   static const int PROP_MOTIF_WM_HINTS_ELEMENTS = 5;
++
++   typedef struct
++   {
++      unsigned long       flags;
++      unsigned long       functions;
++      unsigned long       decorations;
++      long                inputMode;
++      unsigned long       status;
++   } PropMotifWmHints;
++
++   PropMotifWmHints motif_hints;
++   Atom prop, proptype;
++   unsigned long flags = 0;
++
++   /* setup the property */
++   motif_hints.flags = MWM_HINTS_DECORATIONS;
++   motif_hints.decorations = flags;
++
++   /* get the atom for the property */
++   prop = XInternAtom( dpy, "_MOTIF_WM_HINTS", True );
++   if (!prop) {
++      /* something went wrong! */
++      return;
++   }
++
++   /* not sure this is correct, seems to work, XA_WM_HINTS didn't work */
++   proptype = prop;
++
++   XChangeProperty( dpy, w,                         /* display, window */
++                    prop, proptype,                 /* property, type */
++                    32,                             /* format: 32-bit datums */
++                    PropModeReplace,                /* mode */
++                    (unsigned char *) &motif_hints, /* data */
++                    PROP_MOTIF_WM_HINTS_ELEMENTS    /* nelements */
++                  );
++}
++
++
++/*
++ * Create an RGB, double-buffered window.
++ * Return the window and context handles.
++ */
++static void
++make_window( Display *dpy, const char *name,
++             int x, int y, int width, int height,
++             Window *winRet, GLXContext *ctxRet, VisualID *visRet)
++{
++   int attribs[64];
++   int i = 0;
++
++   int scrnum;
++   XSetWindowAttributes attr;
++   unsigned long mask;
++   Window root;
++   Window win;
++   GLXContext ctx;
++   XVisualInfo *visinfo;
++
++   /* Singleton attributes. */
++   attribs[i++] = GLX_RGBA;
++   attribs[i++] = GLX_DOUBLEBUFFER;
++   if (stereo)
++      attribs[i++] = GLX_STEREO;
++
++   /* Key/value attributes. */
++   attribs[i++] = GLX_RED_SIZE;
++   attribs[i++] = 1;
++   attribs[i++] = GLX_GREEN_SIZE;
++   attribs[i++] = 1;
++   attribs[i++] = GLX_BLUE_SIZE;
++   attribs[i++] = 1;
++   attribs[i++] = GLX_DEPTH_SIZE;
++   attribs[i++] = 1;
++   if (samples > 0) {
++      attribs[i++] = GLX_SAMPLE_BUFFERS;
++      attribs[i++] = 1;
++      attribs[i++] = GLX_SAMPLES;
++      attribs[i++] = samples;
++   }
++
++   attribs[i++] = None;
++
++   scrnum = DefaultScreen( dpy );
++   root = RootWindow( dpy, scrnum );
++
++   visinfo = glXChooseVisual(dpy, scrnum, attribs);
++   if (!visinfo) {
++      printf("Error: couldn't get an RGB, Double-buffered");
++      if (stereo)
++         printf(", Stereo");
++      if (samples > 0)
++         printf(", Multisample");
++      printf(" visual\n");
++      exit(1);
++   }
++
++   /* window attributes */
++   attr.background_pixel = 0;
++   attr.border_pixel = 0;
++   attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
++   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
++   /* XXX this is a bad way to get a borderless window! */
++   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
++
++   win = XCreateWindow( dpy, root, x, y, width, height,
++		        0, visinfo->depth, InputOutput,
++		        visinfo->visual, mask, &attr );
++
++   if (fullscreen)
++      no_border(dpy, win);
++
++   /* set hints and properties */
++   {
++      XSizeHints sizehints;
++      sizehints.x = x;
++      sizehints.y = y;
++      sizehints.width  = width;
++      sizehints.height = height;
++      sizehints.flags = USSize | USPosition;
++      XSetNormalHints(dpy, win, &sizehints);
++      XSetStandardProperties(dpy, win, name, name,
++                              None, (char **)NULL, 0, &sizehints);
++   }
++
++   ctx = glXCreateContext( dpy, visinfo, NULL, True );
++   if (!ctx) {
++      printf("Error: glXCreateContext failed\n");
++      exit(1);
++   }
++
++   *winRet = win;
++   *ctxRet = ctx;
++   *visRet = visinfo->visualid;
++
++   XFree(visinfo);
++}
++
++
++/**
++ * Determine whether or not a GLX extension is supported.
++ */
++static int
++is_glx_extension_supported(Display *dpy, const char *query)
++{
++   const int scrnum = DefaultScreen(dpy);
++   const char *glx_extensions = NULL;
++   const size_t len = strlen(query);
++   const char *ptr;
++
++   if (glx_extensions == NULL) {
++      glx_extensions = glXQueryExtensionsString(dpy, scrnum);
++   }
++
++   ptr = strstr(glx_extensions, query);
++   return ((ptr != NULL) && ((ptr[len] == ' ') || (ptr[len] == '\0')));
++}
++
++
++/**
++ * Attempt to determine whether or not the display is synched to vblank.
++ */
++static void
++query_vsync(Display *dpy, GLXDrawable drawable)
++{
++   int interval = 0;
++
++#if defined(GLX_EXT_swap_control)
++   if (is_glx_extension_supported(dpy, "GLX_EXT_swap_control")) {
++       unsigned int tmp = -1;
++       glXQueryDrawable(dpy, drawable, GLX_SWAP_INTERVAL_EXT, &tmp);
++       interval = tmp;
++   } else
++#endif
++   if (is_glx_extension_supported(dpy, "GLX_MESA_swap_control")) {
++      PFNGLXGETSWAPINTERVALMESAPROC pglXGetSwapIntervalMESA =
++          (PFNGLXGETSWAPINTERVALMESAPROC)
++          glXGetProcAddressARB((const GLubyte *) "glXGetSwapIntervalMESA");
++
++      interval = (*pglXGetSwapIntervalMESA)();
++   } else if (is_glx_extension_supported(dpy, "GLX_SGI_swap_control")) {
++      /* The default swap interval with this extension is 1.  Assume that it
++       * is set to the default.
++       *
++       * Many Mesa-based drivers default to 0, but all of these drivers also
++       * export GLX_MESA_swap_control.  In that case, this branch will never
++       * be taken, and the correct result should be reported.
++       */
++      interval = 1;
++   }
++
++
++   if (interval > 0) {
++      printf("Running synchronized to the vertical refresh.  The framerate should be\n");
++      if (interval == 1) {
++         printf("approximately the same as the monitor refresh rate.\n");
++      } else if (interval > 1) {
++         printf("approximately 1/%d the monitor refresh rate.\n",
++                interval);
++      }
++   }
++}
++
++/**
++ * Handle one X event.
++ * \return NOP, EXIT or DRAW
++ */
++static int
++handle_event(Display *dpy, Window win, XEvent *event)
++{
++   (void) dpy;
++   (void) win;
++
++   switch (event->type) {
++   case Expose:
++      return DRAW;
++   case ConfigureNotify:
++      reshape(event->xconfigure.width, event->xconfigure.height);
++      break;
++   case KeyPress:
++      {
++         char buffer[10];
++         int code;
++         code = XLookupKeysym(&event->xkey, 0);
++         if (code == XK_Left) {
++            view_roty += 5.0;
++         }
++         else if (code == XK_Right) {
++            view_roty -= 5.0;
++         }
++         else if (code == XK_Up) {
++            view_rotx += 5.0;
++         }
++         else if (code == XK_Down) {
++            view_rotx -= 5.0;
++         }
++         else {
++            XLookupString(&event->xkey, buffer, sizeof(buffer),
++                          NULL, NULL);
++            if (buffer[0] == 27) {
++               /* escape */
++               return EXIT;
++            }
++            else if (buffer[0] == 'a' || buffer[0] == 'A') {
++               animate = !animate;
++            }
++         }
++         return DRAW;
++      }
++   }
++   return NOP;
++}
++
++
++static void
++event_loop(Display *dpy, Window win)
++{
++   while (1) {
++      int op;
++      while (!animate || XPending(dpy) > 0) {
++         XEvent event;
++         XNextEvent(dpy, &event);
++         op = handle_event(dpy, win, &event);
++         if (op == EXIT)
++            return;
++         else if (op == DRAW)
++            break;
++      }
++
++      draw_frame(dpy, win);
++   }
++}
++
++
++static void
++usage(void)
++{
++   printf("Usage:\n");
++   printf("  -display <displayname>  set the display to run on\n");
++   printf("  -stereo                 run in stereo mode\n");
++   printf("  -samples N              run in multisample mode with at least N samples\n");
++   printf("  -fullscreen             run in fullscreen mode\n");
++   printf("  -info                   display OpenGL renderer info\n");
++   printf("  -geometry WxH+X+Y       window geometry\n");
++}
++ 
++
++int
++main(int argc, char *argv[])
++{
++   unsigned int winWidth = 300, winHeight = 300;
++   int x = 0, y = 0;
++   Display *dpy;
++   Window win;
++   GLXContext ctx;
++   char *dpyName = NULL;
++   GLboolean printInfo = GL_FALSE;
++   VisualID visId;
++   int i;
++
++   for (i = 1; i < argc; i++) {
++      if (strcmp(argv[i], "-display") == 0) {
++         dpyName = argv[i+1];
++         i++;
++      }
++      else if (strcmp(argv[i], "-info") == 0) {
++         printInfo = GL_TRUE;
++      }
++      else if (strcmp(argv[i], "-stereo") == 0) {
++         stereo = GL_TRUE;
++      }
++      else if (i < argc-1 && strcmp(argv[i], "-samples") == 0) {
++         samples = strtod(argv[i+1], NULL );
++         ++i;
++      }
++      else if (strcmp(argv[i], "-fullscreen") == 0) {
++         fullscreen = GL_TRUE;
++      }
++      else if (i < argc-1 && strcmp(argv[i], "-geometry") == 0) {
++         XParseGeometry(argv[i+1], &x, &y, &winWidth, &winHeight);
++         i++;
++      }
++      else {
++         usage();
++         return -1;
++      }
++   }
++
++   dpy = XOpenDisplay(dpyName);
++   if (!dpy) {
++      printf("Error: couldn't open display %s\n",
++	     dpyName ? dpyName : getenv("DISPLAY"));
++      return -1;
++   }
++
++   if (fullscreen) {
++      int scrnum = DefaultScreen(dpy);
++
++      x = 0; y = 0;
++      winWidth = DisplayWidth(dpy, scrnum);
++      winHeight = DisplayHeight(dpy, scrnum);
++   }
++
++   make_window(dpy, "glxgears", x, y, winWidth, winHeight, &win, &ctx, &visId);
++   XMapWindow(dpy, win);
++   glXMakeCurrent(dpy, win, ctx);
++   query_vsync(dpy, win);
++
++   if (printInfo) {
++      printf("GL_RENDERER   = %s\n", (char *) glGetString(GL_RENDERER));
++      printf("GL_VERSION    = %s\n", (char *) glGetString(GL_VERSION));
++      printf("GL_VENDOR     = %s\n", (char *) glGetString(GL_VENDOR));
++      printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
++      printf("VisualID %d, 0x%x\n", (int) visId, (int) visId);
++   }
++
++   init();
++
++   /* Set initial projection/viewing transformation.
++    * We can't be sure we'll get a ConfigureNotify event when the window
++    * first appears.
++    */
++   reshape(winWidth, winHeight);
++
++   event_loop(dpy, win);
++
++   glDeleteLists(gear1, 1);
++   glDeleteLists(gear2, 1);
++   glDeleteLists(gear3, 1);
++   glXMakeCurrent(dpy, None, NULL);
++   glXDestroyContext(dpy, ctx);
++   XDestroyWindow(dpy, win);
++   XCloseDisplay(dpy);
++
++   return 0;
++}
+diff -Naur a/xdemos/glxinfo.1 b/xdemos/glxinfo.1
+--- a/xdemos/glxinfo.1	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/glxinfo.1	2015-10-17 12:09:57.708723149 -0300
+@@ -0,0 +1,46 @@
++.TH glxinfo 1 "2006-11-29"
++.SH NAME
++glxinfo \- show information about the GLX implementation
++.SH SYNOPSIS
++.B glxinfo
++.RI [ options ]
++.SH DESCRIPTION
++The \fIglxinfo\fP program shows information about the OpenGL and GLX
++implementations running on a given X display.
++.PP
++The information includes details about the server- and client-side GLX
++implementation, the OpenGL and GLU implementations as well as a list
++of available GLX visuals.
++.SH OPTIONS
++.TP 8
++.B \-v
++Print visuals info in verbose form.
++.TP 8
++.B \-t
++Print verbose table.
++.TP 8
++.B \-display \fIdisplay\fP
++Specify the X display to interrogate.
++.TP 8
++.B \-h
++Print usage information.
++.TP 8
++.B \-i
++Force an indirect rendering context.
++.TP 8
++.B \-b
++Find the "best" visual and print its number.
++.TP 8
++.B \-l
++Print interesting OpenGL limits.
++.TP 8
++.B \-s
++Print a single extension per line.
++.SH AUTHOR
++glxinfo was written by Brian Paul <brian.paul at tungstengraphics.com>.
++.PP
++This manual page was written by Thierry Reding <thierry at gilfi.de>, for the
++Debian project and updated by Fernando de Oliveira <famobr at yahoo dot
++com dot br>, for the Linux From Scratch (LFS) project (but may be used by
++others).
++
++
+diff -Naur a/xdemos/glxinfo.c b/xdemos/glxinfo.c
+--- a/xdemos/glxinfo.c	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/glxinfo.c	2015-10-17 11:47:19.104139689 -0300
+@@ -0,0 +1,1281 @@
++/*
++ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
++ * 
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ * 
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++
++/*
++ * This program is a work-alike of the IRIX glxinfo program.
++ * Command line options:
++ *  -t                     print wide table
++ *  -v                     print verbose information
++ *  -display DisplayName   specify the X display to interogate
++ *  -B                     brief, print only the basics
++ *  -b                     only print ID of "best" visual on screen 0
++ *  -i                     use indirect rendering connection only
++ *  -l                     print interesting OpenGL limits (added 5 Sep 2002)
++ *
++ * Brian Paul  26 January 2000
++ */
++
++#define GLX_GLXEXT_PROTOTYPES
++#define GL_GLEXT_PROTOTYPES
++
++#include <assert.h>
++#include <X11/Xlib.h>
++#include <X11/Xutil.h>
++#include <GL/gl.h>
++#include <GL/glx.h>
++#include <stdio.h>
++#include <string.h>
++#include <stdlib.h>
++#include "glinfo_common.h"
++
++
++#ifndef GLX_NONE_EXT
++#define GLX_NONE_EXT  0x8000
++#endif
++
++#ifndef GLX_TRANSPARENT_RGB
++#define GLX_TRANSPARENT_RGB 0x8008
++#endif
++
++#ifndef GLX_RGBA_BIT
++#define GLX_RGBA_BIT			0x00000001
++#endif
++
++#ifndef GLX_COLOR_INDEX_BIT
++#define GLX_COLOR_INDEX_BIT		0x00000002
++#endif
++
++
++struct visual_attribs
++{
++   /* X visual attribs */
++   int id;		/* May be visual ID or FBConfig ID */
++   int vis_id;		/* Visual ID.  Only set for FBConfigs */
++   int klass;
++   int depth;
++   int redMask, greenMask, blueMask;
++   int colormapSize;
++   int bitsPerRGB;
++
++   /* GL visual attribs */
++   int supportsGL;
++   int drawableType;
++   int transparentType;
++   int transparentRedValue;
++   int transparentGreenValue;
++   int transparentBlueValue;
++   int transparentAlphaValue;
++   int transparentIndexValue;
++   int bufferSize;
++   int level;
++   int render_type;
++   int doubleBuffer;
++   int stereo;
++   int auxBuffers;
++   int redSize, greenSize, blueSize, alphaSize;
++   int depthSize;
++   int stencilSize;
++   int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
++   int numSamples, numMultisample;
++   int visualCaveat;
++   int floatComponents;
++   int packedfloatComponents;
++   int srgb;
++};
++
++   
++/**
++ * Version of the context that was created
++ *
++ * 20, 21, 30, 31, 32, etc.
++ */
++static int version;
++
++/**
++ * GL Error checking/warning.
++ */
++static void
++CheckError(int line)
++{
++   int n;
++   n = glGetError();
++   if (n)
++      printf("Warning: GL error 0x%x at line %d\n", n, line);
++}
++
++
++static void
++print_display_info(Display *dpy)
++{
++   printf("name of display: %s\n", DisplayString(dpy));
++}
++
++
++/**
++ * Choose a simple FB Config.
++ */
++static GLXFBConfig *
++choose_fb_config(Display *dpy, int scrnum)
++{
++   int fbAttribSingle[] = {
++      GLX_RENDER_TYPE,   GLX_RGBA_BIT,
++      GLX_RED_SIZE,      1,
++      GLX_GREEN_SIZE,    1,
++      GLX_BLUE_SIZE,     1,
++      GLX_DOUBLEBUFFER,  False,
++      None };
++   int fbAttribDouble[] = {
++      GLX_RENDER_TYPE,   GLX_RGBA_BIT,
++      GLX_RED_SIZE,      1,
++      GLX_GREEN_SIZE,    1,
++      GLX_BLUE_SIZE,     1,
++      GLX_DOUBLEBUFFER,  True,
++      None };
++   GLXFBConfig *configs;
++   int nConfigs;
++
++   configs = glXChooseFBConfig(dpy, scrnum, fbAttribSingle, &nConfigs);
++   if (!configs)
++      configs = glXChooseFBConfig(dpy, scrnum, fbAttribDouble, &nConfigs);
++
++   return configs;
++}
++
++
++static Bool CreateContextErrorFlag;
++
++static int
++create_context_error_handler(Display *dpy, XErrorEvent *error)
++{
++   (void) dpy;
++   (void) error->error_code;
++   CreateContextErrorFlag = True;
++   return 0;
++}
++
++
++/**
++ * Try to create a GLX context of the given version with flags/options.
++ * Note: A version number is required in order to get a core profile
++ * (at least w/ NVIDIA).
++ */
++static GLXContext
++create_context_flags(Display *dpy, GLXFBConfig fbconfig, int major, int minor,
++                     int contextFlags, int profileMask, Bool direct)
++{
++#ifdef GLX_ARB_create_context
++   static PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB_func = 0;
++   static Bool firstCall = True;
++   int (*old_handler)(Display *, XErrorEvent *);
++   GLXContext context;
++   int attribs[20];
++   int n = 0;
++
++   if (firstCall) {
++      /* See if we have GLX_ARB_create_context_profile and get pointer to
++       * glXCreateContextAttribsARB() function.
++       */
++      const char *glxExt = glXQueryExtensionsString(dpy, 0);
++      if (extension_supported("GLX_ARB_create_context_profile", glxExt)) {
++         glXCreateContextAttribsARB_func = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
++            glXGetProcAddress((const GLubyte *) "glXCreateContextAttribsARB");
++      }
++      firstCall = False;
++   }
++
++   if (!glXCreateContextAttribsARB_func)
++      return 0;
++
++   /* setup attribute array */
++   if (major) {
++      attribs[n++] = GLX_CONTEXT_MAJOR_VERSION_ARB;
++      attribs[n++] = major;
++      attribs[n++] = GLX_CONTEXT_MINOR_VERSION_ARB;
++      attribs[n++] = minor;
++   }
++   if (contextFlags) {
++      attribs[n++] = GLX_CONTEXT_FLAGS_ARB;
++      attribs[n++] = contextFlags;
++   }
++#ifdef GLX_ARB_create_context_profile
++   if (profileMask) {
++      attribs[n++] = GLX_CONTEXT_PROFILE_MASK_ARB;
++      attribs[n++] = profileMask;
++   }
++#endif
++   attribs[n++] = 0;
++
++   /* install X error handler */
++   old_handler = XSetErrorHandler(create_context_error_handler);
++   CreateContextErrorFlag = False;
++
++   /* try creating context */
++   context = glXCreateContextAttribsARB_func(dpy,
++                                             fbconfig,
++                                             0, /* share_context */
++                                             direct,
++                                             attribs);
++
++   /* restore error handler */
++   XSetErrorHandler(old_handler);
++
++   if (CreateContextErrorFlag)
++      context = 0;
++
++   if (context && direct) {
++      if (!glXIsDirect(dpy, context)) {
++         glXDestroyContext(dpy, context);
++         return 0;
++      }
++   }
++
++   return context;
++#else
++   return 0;
++#endif
++}
++
++
++/**
++ * Try to create a GLX context of the newest version.
++ */
++static GLXContext
++create_context_with_config(Display *dpy, GLXFBConfig config,
++                           Bool coreProfile, Bool es2Profile, Bool direct)
++{
++   GLXContext ctx = 0;
++
++   if (coreProfile) {
++      /* Try to create a core profile, starting with the newest version of
++       * GL that we're aware of.  If we don't specify the version
++       */
++      int i;
++      for (i = 0; gl_versions[i].major > 0; i++) {
++          /* don't bother below GL 3.0 */
++          if (gl_versions[i].major == 3 &&
++              gl_versions[i].minor == 0)
++             return 0;
++         ctx = create_context_flags(dpy, config,
++                                    gl_versions[i].major,
++                                    gl_versions[i].minor,
++                                    0x0,
++                                    GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
++                                    direct);
++         if (ctx)
++            return ctx;
++      }
++      /* couldn't get core profile context */
++      return 0;
++   }
++
++   if (es2Profile) {
++#ifdef GLX_CONTEXT_ES2_PROFILE_BIT_EXT
++      if (extension_supported("GLX_EXT_create_context_es2_profile",
++                              glXQueryExtensionsString(dpy, 0))) {
++         ctx = create_context_flags(dpy, config, 2, 0, 0x0,
++                                    GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
++                                    direct);
++         return ctx;
++      }
++#endif
++      return 0;
++   }
++
++   /* GLX should return a context of the latest GL version that supports
++    * the full profile.
++    */
++   ctx = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, direct);
++
++   /* make sure the context is direct, if direct was requested */
++   if (ctx && direct) {
++      if (!glXIsDirect(dpy, ctx)) {
++         glXDestroyContext(dpy, ctx);
++         return 0;
++      }
++   }
++
++   return ctx;
++}
++
++
++static XVisualInfo *
++choose_xvisinfo(Display *dpy, int scrnum)
++{
++   int attribSingle[] = {
++      GLX_RGBA,
++      GLX_RED_SIZE, 1,
++      GLX_GREEN_SIZE, 1,
++      GLX_BLUE_SIZE, 1,
++      None };
++   int attribDouble[] = {
++      GLX_RGBA,
++      GLX_RED_SIZE, 1,
++      GLX_GREEN_SIZE, 1,
++      GLX_BLUE_SIZE, 1,
++      GLX_DOUBLEBUFFER,
++      None };
++   XVisualInfo *visinfo;
++
++   visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
++   if (!visinfo)
++      visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
++
++   return visinfo;
++}
++
++
++static void
++query_renderer(void)
++{
++#ifdef GLX_MESA_query_renderer
++    PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC queryInteger;
++    PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC queryString;
++    unsigned int v[3];
++
++    queryInteger = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)
++	glXGetProcAddressARB((const GLubyte *)
++			     "glXQueryCurrentRendererIntegerMESA");
++    queryString = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)
++	glXGetProcAddressARB((const GLubyte *)
++			     "glXQueryCurrentRendererStringMESA");
++
++    printf("Extended renderer info (GLX_MESA_query_renderer):\n");
++    queryInteger(GLX_RENDERER_VENDOR_ID_MESA, v);
++    printf("    Vendor: %s (0x%x)\n",
++	   queryString(GLX_RENDERER_VENDOR_ID_MESA), *v);
++    queryInteger(GLX_RENDERER_DEVICE_ID_MESA, v);
++    printf("    Device: %s (0x%x)\n",
++	   queryString(GLX_RENDERER_DEVICE_ID_MESA), *v);
++    queryInteger(GLX_RENDERER_VERSION_MESA, v);
++    printf("    Version: %d.%d.%d\n", v[0], v[1], v[2]);
++    queryInteger(GLX_RENDERER_ACCELERATED_MESA, v);
++    printf("    Accelerated: %s\n", *v ? "yes" : "no");
++    queryInteger(GLX_RENDERER_VIDEO_MEMORY_MESA, v);
++    printf("    Video memory: %dMB\n", *v);
++    queryInteger(GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA, v);
++    printf("    Unified memory: %s\n", *v ? "yes" : "no");
++    queryInteger(GLX_RENDERER_PREFERRED_PROFILE_MESA, v);
++    printf("    Preferred profile: %s (0x%x)\n",
++	   *v == GLX_CONTEXT_CORE_PROFILE_BIT_ARB ? "core" :
++	   *v == GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB ? "compat" :
++	   "unknown", *v);
++    queryInteger(GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA, v);
++    printf("    Max core profile version: %d.%d\n", v[0], v[1]);
++    queryInteger(GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA, v);
++    printf("    Max compat profile version: %d.%d\n", v[0], v[1]);
++    queryInteger(GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA, v);
++    printf("    Max GLES1 profile version: %d.%d\n", v[0], v[1]);
++    queryInteger(GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA, v);
++    printf("    Max GLES[23] profile version: %d.%d\n", v[0], v[1]);
++#endif
++}
++
++
++static Bool
++print_screen_info(Display *dpy, int scrnum,
++                  const struct options *opts,
++                  Bool coreProfile, Bool es2Profile, Bool limits,
++                  Bool coreWorked)
++{
++   Window win;
++   XSetWindowAttributes attr;
++   unsigned long mask;
++   Window root;
++   GLXContext ctx = NULL;
++   XVisualInfo *visinfo;
++   int width = 100, height = 100;
++   GLXFBConfig *fbconfigs;
++   const char *oglstring = coreProfile ? "OpenGL core profile" :
++                           es2Profile ? "OpenGL ES profile" : "OpenGL";
++
++   root = RootWindow(dpy, scrnum);
++
++   /*
++    * Choose FBConfig or XVisualInfo and create a context.
++    */
++   fbconfigs = choose_fb_config(dpy, scrnum);
++   if (fbconfigs) {
++      ctx = create_context_with_config(dpy, fbconfigs[0],
++                                       coreProfile, es2Profile,
++                                       opts->allowDirect);
++      if (!ctx && opts->allowDirect && !coreProfile) {
++         /* try indirect */
++         ctx = create_context_with_config(dpy, fbconfigs[0],
++                                          coreProfile, es2Profile, False);
++      }
++
++      visinfo = glXGetVisualFromFBConfig(dpy, fbconfigs[0]);
++      XFree(fbconfigs);
++   }
++   else if (!coreProfile && !es2Profile) {
++      visinfo = choose_xvisinfo(dpy, scrnum);
++      if (visinfo)
++	 ctx = glXCreateContext(dpy, visinfo, NULL, opts->allowDirect);
++   } else
++      visinfo = NULL;
++
++   if (!visinfo && !coreProfile && !es2Profile) {
++      fprintf(stderr, "Error: couldn't find RGB GLX visual or fbconfig\n");
++      return False;
++   }
++
++   if (!ctx) {
++      if (!coreProfile && !es2Profile)
++	 fprintf(stderr, "Error: glXCreateContext failed\n");
++      XFree(visinfo);
++      return False;
++   }
++
++   /*
++    * Create a window so that we can just bind the context.
++    */
++   attr.background_pixel = 0;
++   attr.border_pixel = 0;
++   attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
++   attr.event_mask = StructureNotifyMask | ExposureMask;
++   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
++   win = XCreateWindow(dpy, root, 0, 0, width, height,
++		       0, visinfo->depth, InputOutput,
++		       visinfo->visual, mask, &attr);
++
++   if (glXMakeCurrent(dpy, win, ctx)) {
++      const char *serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR);
++      const char *serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION);
++      const char *serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS);
++      const char *clientVendor = glXGetClientString(dpy, GLX_VENDOR);
++      const char *clientVersion = glXGetClientString(dpy, GLX_VERSION);
++      const char *clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS);
++      const char *glxExtensions = glXQueryExtensionsString(dpy, scrnum);
++      const char *glVendor = (const char *) glGetString(GL_VENDOR);
++      const char *glRenderer = (const char *) glGetString(GL_RENDERER);
++      const char *glVersion = (const char *) glGetString(GL_VERSION);
++      char *glExtensions = NULL;
++      int glxVersionMajor = 0;
++      int glxVersionMinor = 0;
++      char *displayName = NULL;
++      char *colon = NULL, *period = NULL;
++      struct ext_functions extfuncs;
++
++      CheckError(__LINE__);
++
++      /* Get some ext functions */
++      extfuncs.GetProgramivARB = (GETPROGRAMIVARBPROC)
++         glXGetProcAddressARB((GLubyte *) "glGetProgramivARB");
++      extfuncs.GetStringi = (GETSTRINGIPROC)
++         glXGetProcAddressARB((GLubyte *) "glGetStringi");
++      extfuncs.GetConvolutionParameteriv = (GETCONVOLUTIONPARAMETERIVPROC)
++         glXGetProcAddressARB((GLubyte *) "glGetConvolutionParameteriv");
++
++      if (!glXQueryVersion(dpy, & glxVersionMajor, & glxVersionMinor)) {
++         fprintf(stderr, "Error: glXQueryVersion failed\n");
++         exit(1);
++      }
++
++      /* Get list of GL extensions */
++      if (coreProfile && extfuncs.GetStringi)
++         glExtensions = build_core_profile_extension_list(&extfuncs);
++      if (!glExtensions) {
++         coreProfile = False;
++         glExtensions = (char *) glGetString(GL_EXTENSIONS);
++      }
++
++      CheckError(__LINE__);
++
++      if (!coreWorked) {
++         /* Strip the screen number from the display name, if present. */
++         if (!(displayName = (char *) malloc(strlen(DisplayString(dpy)) + 1))) {
++            fprintf(stderr, "Error: malloc() failed\n");
++            exit(1);
++         }
++         strcpy(displayName, DisplayString(dpy));
++         colon = strrchr(displayName, ':');
++         if (colon) {
++            period = strchr(colon, '.');
++            if (period)
++               *period = '\0';
++         }
++
++         printf("display: %s  screen: %d\n", displayName, scrnum);
++         free(displayName);
++         printf("direct rendering: ");
++         if (glXIsDirect(dpy, ctx)) {
++            printf("Yes\n");
++         }
++         else {
++            if (!opts->allowDirect) {
++               printf("No (-i specified)\n");
++            }
++            else if (getenv("LIBGL_ALWAYS_INDIRECT")) {
++               printf("No (LIBGL_ALWAYS_INDIRECT set)\n");
++            }
++            else {
++               printf("No (If you want to find out why, try setting "
++                      "LIBGL_DEBUG=verbose)\n");
++            }
++         }
++         if (opts->mode != Brief) {
++            printf("server glx vendor string: %s\n", serverVendor);
++            printf("server glx version string: %s\n", serverVersion);
++            printf("server glx extensions:\n");
++            print_extension_list(serverExtensions, opts->singleLine);
++            printf("client glx vendor string: %s\n", clientVendor);
++            printf("client glx version string: %s\n", clientVersion);
++            printf("client glx extensions:\n");
++            print_extension_list(clientExtensions, opts->singleLine);
++            printf("GLX version: %u.%u\n", glxVersionMajor, glxVersionMinor);
++            printf("GLX extensions:\n");
++            print_extension_list(glxExtensions, opts->singleLine);
++         }
++         if (strstr(glxExtensions, "GLX_MESA_query_renderer"))
++	    query_renderer();
++         printf("OpenGL vendor string: %s\n", glVendor);
++         printf("OpenGL renderer string: %s\n", glRenderer);
++      } else
++         printf("\n");
++
++      printf("%s version string: %s\n", oglstring, glVersion);
++
++      version = (glVersion[0] - '0') * 10 + (glVersion[2] - '0');
++
++      CheckError(__LINE__);
++
++#ifdef GL_VERSION_2_0
++      if (version >= 20) {
++         char *v = (char *) glGetString(GL_SHADING_LANGUAGE_VERSION);
++         printf("%s shading language version string: %s\n", oglstring, v);
++      }
++#endif
++      CheckError(__LINE__);
++#ifdef GL_VERSION_3_0
++      if (version >= 30 && !es2Profile) {
++         GLint flags;
++         glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
++         printf("%s context flags: %s\n", oglstring, context_flags_string(flags));
++      }
++#endif
++      CheckError(__LINE__);
++#ifdef GL_VERSION_3_2
++      if (version >= 32 && !es2Profile) {
++         GLint mask;
++         glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
++         printf("%s profile mask: %s\n", oglstring, profile_mask_string(mask));
++      }
++#endif
++
++      CheckError(__LINE__);
++
++      if (opts->mode != Brief) {
++         printf("%s extensions:\n", oglstring);
++         print_extension_list(glExtensions, opts->singleLine);
++      }
++
++      if (limits) {
++         print_limits(glExtensions, oglstring, version, &extfuncs);
++      }
++
++      if (coreProfile)
++         free(glExtensions);
++   }
++   else {
++      fprintf(stderr, "Error: glXMakeCurrent failed\n");
++   }
++
++   glXDestroyContext(dpy, ctx);
++   XFree(visinfo);
++   XDestroyWindow(dpy, win);
++   XSync(dpy, 1);
++   return True;
++}
++
++
++static const char *
++visual_class_name(int cls)
++{
++   switch (cls) {
++      case StaticColor:
++         return "StaticColor";
++      case PseudoColor:
++         return "PseudoColor";
++      case StaticGray:
++         return "StaticGray";
++      case GrayScale:
++         return "GrayScale";
++      case TrueColor:
++         return "TrueColor";
++      case DirectColor:
++         return "DirectColor";
++      default:
++         return "";
++   }
++}
++
++static const char *
++visual_drawable_type(int type)
++{
++   const static struct bit_info bits[] = {
++      { GLX_WINDOW_BIT, "window" },
++      { GLX_PIXMAP_BIT, "pixmap" },
++      { GLX_PBUFFER_BIT, "pbuffer" }
++   };
++
++   return bitmask_to_string(bits, ELEMENTS(bits), type);
++}
++
++static const char *
++visual_class_abbrev(int cls)
++{
++   switch (cls) {
++      case StaticColor:
++         return "sc";
++      case PseudoColor:
++         return "pc";
++      case StaticGray:
++         return "sg";
++      case GrayScale:
++         return "gs";
++      case TrueColor:
++         return "tc";
++      case DirectColor:
++         return "dc";
++      default:
++         return "";
++   }
++}
++
++static const char *
++visual_render_type_name(int type)
++{
++   switch (type) {
++      case GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT:
++         return "ufloat";
++      case GLX_RGBA_FLOAT_BIT_ARB:
++         return "float";
++      case GLX_RGBA_BIT:
++         return "rgba";
++      case GLX_COLOR_INDEX_BIT:
++         return "ci";
++      case GLX_RGBA_BIT | GLX_COLOR_INDEX_BIT:
++         return "rgba|ci";
++      default:
++         return "";
++   }
++}
++
++static const char *
++caveat_string(int caveat)
++{
++   switch (caveat) {
++#ifdef GLX_EXT_visual_rating
++      case GLX_SLOW_VISUAL_EXT:
++         return "Slow";
++      case GLX_NON_CONFORMANT_VISUAL_EXT:
++         return "Ncon";
++      case GLX_NONE_EXT:
++         /* fall-through */
++#endif
++      case 0:
++         /* fall-through */
++      default:
++         return "None";
++   }
++}
++
++
++static Bool
++get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
++                   struct visual_attribs *attribs)
++{
++   const char *ext = glXQueryExtensionsString(dpy, vInfo->screen);
++   int rgba;
++
++   memset(attribs, 0, sizeof(struct visual_attribs));
++
++   attribs->id = vInfo->visualid;
++#if defined(__cplusplus) || defined(c_plusplus)
++   attribs->klass = vInfo->c_class;
++#else
++   attribs->klass = vInfo->class;
++#endif
++   attribs->depth = vInfo->depth;
++   attribs->redMask = vInfo->red_mask;
++   attribs->greenMask = vInfo->green_mask;
++   attribs->blueMask = vInfo->blue_mask;
++   attribs->colormapSize = vInfo->colormap_size;
++   attribs->bitsPerRGB = vInfo->bits_per_rgb;
++
++   if (glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL) != 0 ||
++       !attribs->supportsGL)
++      return False;
++   glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize);
++   glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level);
++   glXGetConfig(dpy, vInfo, GLX_RGBA, &rgba);
++   if (rgba)
++      attribs->render_type = GLX_RGBA_BIT;
++   else
++      attribs->render_type = GLX_COLOR_INDEX_BIT;
++   
++   glXGetConfig(dpy, vInfo, GLX_DRAWABLE_TYPE, &attribs->drawableType);
++   glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
++   glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo);
++   glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers);
++   glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize);
++   glXGetConfig(dpy, vInfo, GLX_GREEN_SIZE, &attribs->greenSize);
++   glXGetConfig(dpy, vInfo, GLX_BLUE_SIZE, &attribs->blueSize);
++   glXGetConfig(dpy, vInfo, GLX_ALPHA_SIZE, &attribs->alphaSize);
++   glXGetConfig(dpy, vInfo, GLX_DEPTH_SIZE, &attribs->depthSize);
++   glXGetConfig(dpy, vInfo, GLX_STENCIL_SIZE, &attribs->stencilSize);
++   glXGetConfig(dpy, vInfo, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
++   glXGetConfig(dpy, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
++   glXGetConfig(dpy, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
++   glXGetConfig(dpy, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
++
++   /* get transparent pixel stuff */
++   glXGetConfig(dpy, vInfo,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
++   if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
++     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
++     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
++     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
++     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
++   }
++   else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
++     glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
++   }
++
++   /* multisample attribs */
++#ifdef GLX_ARB_multisample
++   if (ext && strstr(ext, "GLX_ARB_multisample")) {
++      glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample);
++      glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples);
++   }
++#endif
++   else {
++      attribs->numSamples = 0;
++      attribs->numMultisample = 0;
++   }
++
++#if defined(GLX_EXT_visual_rating)
++   if (ext && strstr(ext, "GLX_EXT_visual_rating")) {
++      glXGetConfig(dpy, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat);
++   }
++   else {
++      attribs->visualCaveat = GLX_NONE_EXT;
++   }
++#else
++   attribs->visualCaveat = 0;
++#endif
++
++#if defined(GLX_EXT_framebuffer_sRGB)
++   if (ext && strstr(ext, "GLX_EXT_framebuffer_sRGB")) {
++      glXGetConfig(dpy, vInfo, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &attribs->srgb);
++   }
++#endif
++
++   return True;
++}
++
++#ifdef GLX_VERSION_1_3
++
++static int
++glx_token_to_visual_class(int visual_type)
++{
++   switch (visual_type) {
++   case GLX_TRUE_COLOR:
++      return TrueColor;
++   case GLX_DIRECT_COLOR:
++      return DirectColor;
++   case GLX_PSEUDO_COLOR:
++      return PseudoColor;
++   case GLX_STATIC_COLOR:
++      return StaticColor;
++   case GLX_GRAY_SCALE:
++      return GrayScale;
++   case GLX_STATIC_GRAY:
++      return StaticGray;
++   case GLX_NONE:
++   default:
++      return None;
++   }
++}
++
++static Bool
++get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
++		     struct visual_attribs *attribs)
++{
++   const char *ext = glXQueryExtensionsString(dpy, 0);
++   int visual_type;
++   XVisualInfo *vInfo;
++
++   memset(attribs, 0, sizeof(struct visual_attribs));
++
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_FBCONFIG_ID, &attribs->id);
++
++   vInfo = glXGetVisualFromFBConfig(dpy, fbconfig);
++
++   if (vInfo != NULL) {
++      attribs->vis_id = vInfo->visualid;
++      attribs->depth = vInfo->depth;
++      attribs->redMask = vInfo->red_mask;
++      attribs->greenMask = vInfo->green_mask;
++      attribs->blueMask = vInfo->blue_mask;
++      attribs->colormapSize = vInfo->colormap_size;
++      attribs->bitsPerRGB = vInfo->bits_per_rgb;
++   }
++
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_X_VISUAL_TYPE, &visual_type);
++   attribs->klass = glx_token_to_visual_class(visual_type);
++
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_DRAWABLE_TYPE, &attribs->drawableType);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_BUFFER_SIZE, &attribs->bufferSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers);
++
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_RED_SIZE, &attribs->redSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_GREEN_SIZE, &attribs->greenSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_BLUE_SIZE, &attribs->blueSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ALPHA_SIZE, &attribs->alphaSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_DEPTH_SIZE, &attribs->depthSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_STENCIL_SIZE, &attribs->stencilSize);
++
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
++
++   /* get transparent pixel stuff */
++   glXGetFBConfigAttrib(dpy, fbconfig,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
++   if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
++     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
++     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
++     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
++     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
++   }
++   else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
++     glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
++   }
++
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLE_BUFFERS, &attribs->numMultisample);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLES, &attribs->numSamples);
++   glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat);
++
++#if defined(GLX_NV_float_buffer)
++   if (ext && strstr(ext, "GLX_NV_float_buffer")) {
++      glXGetFBConfigAttrib(dpy, fbconfig, GLX_FLOAT_COMPONENTS_NV, &attribs->floatComponents);
++   }
++#endif
++#if defined(GLX_ARB_fbconfig_float)
++   if (ext && strstr(ext, "GLX_ARB_fbconfig_float")) {
++      if (attribs->render_type & GLX_RGBA_FLOAT_BIT_ARB) {
++         attribs->floatComponents = True;
++      }
++   }
++#endif
++#if defined(GLX_EXT_fbconfig_packed_float)
++   if (ext && strstr(ext, "GLX_EXT_fbconfig_packed_float")) {
++      if (attribs->render_type & GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT) {
++         attribs->packedfloatComponents = True;
++      }
++   }
++#endif
++
++#if defined(GLX_EXT_framebuffer_sRGB)
++   if (ext && strstr(ext, "GLX_EXT_framebuffer_sRGB")) {
++      glXGetFBConfigAttrib(dpy, fbconfig, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &attribs->srgb);
++   }
++#endif
++   return True;
++}
++
++#endif
++
++
++
++static void
++print_visual_attribs_verbose(const struct visual_attribs *attribs,
++			     int fbconfigs)
++{
++   if (fbconfigs) {
++      printf("FBConfig ID: %x  Visual ID=%x  depth=%d  class=%s, type=%s\n",
++             attribs->id, attribs->vis_id, attribs->depth,
++             visual_class_name(attribs->klass),
++             visual_drawable_type(attribs->drawableType));
++   }
++   else {
++      printf("Visual ID: %x  depth=%d  class=%s, type=%s\n",
++	     attribs->id, attribs->depth, visual_class_name(attribs->klass),
++	     visual_drawable_type(attribs->drawableType));
++   }
++   printf("    bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n",
++          attribs->bufferSize, attribs->level,
++	  visual_render_type_name(attribs->render_type),
++          attribs->doubleBuffer, attribs->stereo);
++   printf("    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d float=%c sRGB=%c\n",
++          attribs->redSize, attribs->greenSize,
++          attribs->blueSize, attribs->alphaSize,
++          attribs->packedfloatComponents ? 'P' : attribs->floatComponents ? 'Y' : 'N',
++          attribs->srgb ? 'Y' : 'N');
++   printf("    auxBuffers=%d depthSize=%d stencilSize=%d\n",
++          attribs->auxBuffers, attribs->depthSize, attribs->stencilSize);
++   printf("    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n",
++          attribs->accumRedSize, attribs->accumGreenSize,
++          attribs->accumBlueSize, attribs->accumAlphaSize);
++   printf("    multiSample=%d  multiSampleBuffers=%d\n",
++          attribs->numSamples, attribs->numMultisample);
++#ifdef GLX_EXT_visual_rating
++   if (attribs->visualCaveat == GLX_NONE_EXT || attribs->visualCaveat == 0)
++      printf("    visualCaveat=None\n");
++   else if (attribs->visualCaveat == GLX_SLOW_VISUAL_EXT)
++      printf("    visualCaveat=Slow\n");
++   else if (attribs->visualCaveat == GLX_NON_CONFORMANT_VISUAL_EXT)
++      printf("    visualCaveat=Nonconformant\n");
++#endif
++   if (attribs->transparentType == GLX_NONE) {
++     printf("    Opaque.\n");
++   }
++   else if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
++     printf("    Transparent RGB: Red=%d Green=%d Blue=%d Alpha=%d\n",attribs->transparentRedValue,attribs->transparentGreenValue,attribs->transparentBlueValue,attribs->transparentAlphaValue);
++   }
++   else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
++     printf("    Transparent index=%d\n",attribs->transparentIndexValue);
++   }
++}
++
++
++static void
++print_visual_attribs_short_header(void)
++{
++ printf("    visual  x   bf lv rg d st  colorbuffer  sr ax dp st accumbuffer  ms  cav\n");
++ printf("  id dep cl sp  sz l  ci b ro  r  g  b  a F gb bf th cl  r  g  b  a ns b eat\n");
++ printf("----------------------------------------------------------------------------\n");
++}
++
++
++static void
++print_visual_attribs_short(const struct visual_attribs *attribs)
++{
++   const char *caveat = caveat_string(attribs->visualCaveat);
++
++   printf("0x%03x %2d %2s %2d %3d %2d %c%c %c %c  %2d %2d %2d %2d %c  %c %2d %2d %2d",
++          attribs->id,
++          attribs->depth,
++          visual_class_abbrev(attribs->klass),
++          attribs->transparentType != GLX_NONE,
++          attribs->bufferSize,
++          attribs->level,
++          (attribs->render_type & GLX_RGBA_BIT) ? 'r' : ' ',
++          (attribs->render_type & GLX_COLOR_INDEX_BIT) ? 'c' : ' ',
++          attribs->doubleBuffer ? 'y' : '.',
++          attribs->stereo ? 'y' : '.',
++          attribs->redSize, attribs->greenSize,
++          attribs->blueSize, attribs->alphaSize,
++          attribs->packedfloatComponents ? 'u' : attribs->floatComponents ? 'f' : '.',
++          attribs->srgb ? 's' : '.',
++          attribs->auxBuffers,
++          attribs->depthSize,
++          attribs->stencilSize
++          );
++
++   printf(" %2d %2d %2d %2d %2d %1d %s\n",
++          attribs->accumRedSize, attribs->accumGreenSize,
++          attribs->accumBlueSize, attribs->accumAlphaSize,
++          attribs->numSamples, attribs->numMultisample,
++          caveat
++          );
++}
++
++
++static void
++print_visual_attribs_long_header(void)
++{
++ printf("Vis   Vis   Visual Trans  buff lev render DB ste  r   g   b   a      s  aux dep ste  accum buffer   MS   MS         \n");
++ printf(" ID  Depth   Type  parent size el   type     reo sz  sz  sz  sz flt rgb buf th  ncl  r   g   b   a  num bufs caveats\n");
++ printf("--------------------------------------------------------------------------------------------------------------------\n");
++}
++
++
++static void
++print_visual_attribs_long(const struct visual_attribs *attribs)
++{
++   const char *caveat = caveat_string(attribs->visualCaveat);
++
++   printf("0x%3x %2d %-11s %2d    %3d %2d  %4s %3d %3d %3d %3d %3d %3d",
++          attribs->id,
++          attribs->depth,
++          visual_class_name(attribs->klass),
++          attribs->transparentType != GLX_NONE,
++          attribs->bufferSize,
++          attribs->level,
++          visual_render_type_name(attribs->render_type),
++          attribs->doubleBuffer,
++          attribs->stereo,
++          attribs->redSize, attribs->greenSize,
++          attribs->blueSize, attribs->alphaSize
++          );
++
++   printf("  %c   %c %3d %4d %2d %3d %3d %3d %3d  %2d  %2d %6s\n",
++          attribs->floatComponents ? 'f' : '.',
++          attribs->srgb ? 's' : '.',
++          attribs->auxBuffers,
++          attribs->depthSize,
++          attribs->stencilSize,
++          attribs->accumRedSize, attribs->accumGreenSize,
++          attribs->accumBlueSize, attribs->accumAlphaSize,
++          attribs->numSamples, attribs->numMultisample,
++          caveat
++          );
++}
++
++
++static void
++print_visual_info(Display *dpy, int scrnum, InfoMode mode)
++{
++   XVisualInfo theTemplate;
++   XVisualInfo *visuals;
++   int numVisuals, numGlxVisuals;
++   long mask;
++   int i;
++   struct visual_attribs attribs;
++
++   /* get list of all visuals on this screen */
++   theTemplate.screen = scrnum;
++   mask = VisualScreenMask;
++   visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals);
++
++   numGlxVisuals = 0;
++   for (i = 0; i < numVisuals; i++) {
++      if (get_visual_attribs(dpy, &visuals[i], &attribs))
++	 numGlxVisuals++;
++   }
++
++   if (numGlxVisuals == 0)
++      return;
++
++   printf("%d GLX Visuals\n", numGlxVisuals);
++
++   if (mode == Normal)
++      print_visual_attribs_short_header();
++   else if (mode == Wide)
++      print_visual_attribs_long_header();
++
++   for (i = 0; i < numVisuals; i++) {
++      if (!get_visual_attribs(dpy, &visuals[i], &attribs))
++	 continue;
++
++      if (mode == Verbose)
++	 print_visual_attribs_verbose(&attribs, False);
++      else if (mode == Normal)
++         print_visual_attribs_short(&attribs);
++      else if (mode == Wide) 
++         print_visual_attribs_long(&attribs);
++   }
++   printf("\n");
++
++   XFree(visuals);
++}
++
++#ifdef GLX_VERSION_1_3
++
++static void
++print_fbconfig_info(Display *dpy, int scrnum, InfoMode mode)
++{
++   int numFBConfigs = 0;
++   struct visual_attribs attribs;
++   GLXFBConfig *fbconfigs;
++   int i;
++
++   /* get list of all fbconfigs on this screen */
++   fbconfigs = glXGetFBConfigs(dpy, scrnum, &numFBConfigs);
++
++   if (numFBConfigs == 0) {
++      XFree(fbconfigs);
++      return;
++   }
++
++   printf("%d GLXFBConfigs:\n", numFBConfigs);
++   if (mode == Normal)
++      print_visual_attribs_short_header();
++   else if (mode == Wide)
++      print_visual_attribs_long_header();
++
++   for (i = 0; i < numFBConfigs; i++) {
++      get_fbconfig_attribs(dpy, fbconfigs[i], &attribs);
++
++      if (mode == Verbose) 
++         print_visual_attribs_verbose(&attribs, True);
++      else if (mode == Normal)
++	 print_visual_attribs_short(&attribs);
++      else if (mode == Wide)
++         print_visual_attribs_long(&attribs);
++   }
++   printf("\n");
++
++   XFree(fbconfigs);
++}
++
++#endif
++
++/*
++ * Stand-alone Mesa doesn't really implement the GLX protocol so it
++ * doesn't really know the GLX attributes associated with an X visual.
++ * The first time a visual is presented to Mesa's pseudo-GLX it
++ * attaches ancilliary buffers to it (like depth and stencil).
++ * But that usually only works if glXChooseVisual is used.
++ * This function calls glXChooseVisual() to sort of "prime the pump"
++ * for Mesa's GLX so that the visuals that get reported actually
++ * reflect what applications will see.
++ * This has no effect when using true GLX.
++ */
++static void
++mesa_hack(Display *dpy, int scrnum)
++{
++   static int attribs[] = {
++      GLX_RGBA,
++      GLX_RED_SIZE, 1,
++      GLX_GREEN_SIZE, 1,
++      GLX_BLUE_SIZE, 1,
++      GLX_DEPTH_SIZE, 1,
++      GLX_STENCIL_SIZE, 1,
++      GLX_ACCUM_RED_SIZE, 1,
++      GLX_ACCUM_GREEN_SIZE, 1,
++      GLX_ACCUM_BLUE_SIZE, 1,
++      GLX_ACCUM_ALPHA_SIZE, 1,
++      GLX_DOUBLEBUFFER,
++      None
++   };
++   XVisualInfo *visinfo;
++
++   visinfo = glXChooseVisual(dpy, scrnum, attribs);
++   if (visinfo)
++      XFree(visinfo);
++}
++
++
++/*
++ * Examine all visuals to find the so-called best one.
++ * We prefer deepest RGBA buffer with depth, stencil and accum
++ * that has no caveats.
++ */
++static int
++find_best_visual(Display *dpy, int scrnum)
++{
++   XVisualInfo theTemplate;
++   XVisualInfo *visuals;
++   int numVisuals;
++   long mask;
++   int i;
++   struct visual_attribs bestVis;
++
++   /* get list of all visuals on this screen */
++   theTemplate.screen = scrnum;
++   mask = VisualScreenMask;
++   visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals);
++
++   /* init bestVis with first visual info */
++   get_visual_attribs(dpy, &visuals[0], &bestVis);
++
++   /* try to find a "better" visual */
++   for (i = 1; i < numVisuals; i++) {
++      struct visual_attribs vis;
++
++      get_visual_attribs(dpy, &visuals[i], &vis);
++
++      /* always skip visuals with caveats */
++      if (vis.visualCaveat != GLX_NONE_EXT)
++         continue;
++
++      /* see if this vis is better than bestVis */
++      if ((!bestVis.supportsGL && vis.supportsGL) ||
++          (bestVis.visualCaveat != GLX_NONE_EXT) ||
++          (!(bestVis.render_type & GLX_RGBA_BIT) && (vis.render_type & GLX_RGBA_BIT)) ||
++          (!bestVis.doubleBuffer && vis.doubleBuffer) ||
++          (bestVis.redSize < vis.redSize) ||
++          (bestVis.greenSize < vis.greenSize) ||
++          (bestVis.blueSize < vis.blueSize) ||
++          (bestVis.alphaSize < vis.alphaSize) ||
++          (bestVis.depthSize < vis.depthSize) ||
++          (bestVis.stencilSize < vis.stencilSize) ||
++          (bestVis.accumRedSize < vis.accumRedSize)) {
++         /* found a better visual */
++         bestVis = vis;
++      }
++   }
++
++   XFree(visuals);
++
++   return bestVis.id;
++}
++
++
++int
++main(int argc, char *argv[])
++{
++   Display *dpy;
++   int numScreens, scrnum;
++   struct options opts;
++   Bool coreWorked;
++
++   parse_args(argc, argv, &opts);
++
++   dpy = XOpenDisplay(opts.displayName);
++   if (!dpy) {
++      fprintf(stderr, "Error: unable to open display %s\n",
++              XDisplayName(opts.displayName));
++      return -1;
++   }
++
++   if (opts.findBest) {
++      int b;
++      mesa_hack(dpy, 0);
++      b = find_best_visual(dpy, 0);
++      printf("%d\n", b);
++   }
++   else {
++      numScreens = ScreenCount(dpy);
++      print_display_info(dpy);
++      for (scrnum = 0; scrnum < numScreens; scrnum++) {
++         mesa_hack(dpy, scrnum);
++         coreWorked = print_screen_info(dpy, scrnum, &opts,
++                                        True, False, opts.limits, False);
++         print_screen_info(dpy, scrnum, &opts, False, False,
++                           opts.limits, coreWorked);
++         print_screen_info(dpy, scrnum, &opts, False, True, False, True);
++
++         printf("\n");
++
++         if (opts.mode != Brief) {
++            print_visual_info(dpy, scrnum, opts.mode);
++#ifdef GLX_VERSION_1_3
++            print_fbconfig_info(dpy, scrnum, opts.mode);
++#endif
++         }
++
++         if (scrnum + 1 < numScreens)
++            printf("\n\n");
++      }
++   }
++
++   XCloseDisplay(dpy);
++
++   return 0;
++}
+diff -Naur a/xdemos/Makefile b/xdemos/Makefile
+--- a/xdemos/Makefile	1969-12-31 21:00:00.000000000 -0300
++++ b/xdemos/Makefile	2015-10-17 11:47:19.104139689 -0300
+@@ -0,0 +1,42 @@
++ifeq ("$(DEMOS_PREFIX)", "")
++	DEMOS_PREFIX=/usr
++endif
++
++ifneq ($(CC),)
++	CC=gcc
++endif
++
++ifeq ($(V),)
++ VB = @
++else
++ VB =
++endif
++
++LIBRARY_PATH=../lib$(EXT)
++
++X11_INCLUDES = $(shell pkg-config --cflags x11)
++X11_LIBS =  $(shell pkg-config --libs x11)
++
++DEMOS_CFLAGS = -g -O2 -I../include $(X11_INCLUDES)
++DEMOS_LDFLAGS = -L../lib$(EXT) -lGL $(X11_LIBS) -lm
++
++default: glxgears glxinfo
++
++glxgears:
++	@echo CC $@
++	$(VB)$(CC) $(CFLAGS) $(DEMOS_CFLAGS) $(DEMOS_LDFLAGS) -o glxgears$(EXT) glxgears.c
++
++glxinfo:
++	@echo CC $@
++	$(VB)$(CC) $(CFLAGS) $(DEMOS_CFLAGS) $(DEMOS_LDFLAGS) -o glxinfo$(EXT) glxinfo.c glinfo_common.c
++
++clean:
++	rm -f glxgears$(EXT) glxinfo$(EXT)
++
++install: default
++	test -e $(DESTDIR)$(DEMOS_PREFIX)/bin || install -dm755 $(DESTDIR)$(DEMOS_PREFIX)/bin
++	test -e $(DESTDIR)$(DEMOS_PREFIX)/share/man/man1 || install -dm755 $(DESTDIR)$(DEMOS_PREFIX)/share/man/man1
++	install -m755 glxgears$(EXT) glxinfo$(EXT) $(DESTDIR)$(DEMOS_PREFIX)/bin
++	install -m644 glxgears.1 glxinfo.1 $(DESTDIR)$(DEMOS_PREFIX)/share/man/man1
++
++.phony: default glxgears glxinfo clean install


More information about the patches mailing list