all new version of glxinfo

1 files changed, 415 insertions, 45 deletions

diff --git a/progs/xdemos/glxinfo.c b/progs/xdemos/glxinfo.c
index e9ac47462c..b7b4fafa17 100644
--- a/progs/xdemos/glxinfo.c
+++ b/progs/xdemos/glxinfo.c
@@ -1,57 +1,141 @@
-/* $Id: glxinfo.c,v 1.1 1999/09/16 16:40:46 brianp Exp $ */
-
+/* $Id: glxinfo.c,v 1.2 2000/01/27 16:43:56 brianp Exp $ */
 
 /*
- * Query GLX extensions, version, vendor, etc.
- * This program is in the public domain.
- * brian_paul@mesa3d.org
+ * Copyright (C) 1999  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
+ *
+ * Brian Paul  26 January 2000
+ */
+
 
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
 #include <GL/gl.h>
-#include <GL/glx.h>
 #include <GL/glu.h>
+#include <GL/glx.h>
 #include <stdio.h>
-#include <stdlib.h>
+#include <string.h>
 
 
+typedef enum
+{
+   Normal,
+   Wide,
+   Verbose
+} InfoMode;
+
+
+struct visual_attribs
+{
+   /* X visual attribs */
+   int id;
+   int klass;
+   int depth;
+   int redMask, greenMask, blueMask;
+   int colormapSize;
+   int bitsPerRGB;
+
+   /* GL visual attribs */
+   int supportsGL;
+   int transparent;
+   int bufferSize;
+   int level;
+   int rgba;
+   int doubleBuffer;
+   int stereo;
+   int auxBuffers;
+   int redSize, greenSize, blueSize, alphaSize;
+   int depthSize;
+   int stencilSize;
+   int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
+   int numSamples, numMultisample;
+};
 
+   
+/*
+ * Print a list of extensions, with word-wrapping.
+ */
 static void
-query_glx( Display *dpy, int scr )
+print_extension_list(const char *ext)
 {
-   printf("GL_VERSION: %s\n", (char *) glGetString(GL_VERSION));
-   printf("GL_EXTENSIONS: %s\n", (char *) glGetString(GL_EXTENSIONS));
-   printf("GL_RENDERER: %s\n", (char *) glGetString(GL_RENDERER));
-   printf("GL_VENDOR: %s\n", (char *) glGetString(GL_VENDOR));
-   printf("GLU_VERSION: %s\n", (char *) gluGetString(GLU_VERSION));
-   printf("GLU_EXTENSIONS: %s\n", (char *) gluGetString(GLU_EXTENSIONS));
-
-   printf("server GLX_VENDOR: %s\n", (char *) glXQueryServerString( dpy, scr, GLX_VENDOR));
-   printf("server GLX_VERSION: %s\n", (char *) glXQueryServerString( dpy, scr, GLX_VERSION));
-   printf("server GLX_EXTENSIONS: %s\n", (char *) glXQueryServerString( dpy, scr, GLX_EXTENSIONS));
-
-   printf("client GLX_VENDOR: %s\n", (char *) glXGetClientString( dpy, GLX_VENDOR));
-   printf("client GLX_VERSION: %s\n", (char *) glXGetClientString( dpy, GLX_VERSION));
-   printf("client GLX_EXTENSIONS: %s\n", (char *) glXGetClientString( dpy, GLX_EXTENSIONS));
-
-   printf("GLX extensions: %s\n", (char *) glXQueryExtensionsString(dpy, scr));
-}
+   const char *indentString = "    ";
+   const int indent = 4;
+   const int max = 79;
+   int width, i, j;
 
+   if (!ext || !ext[0])
+      return;
 
+   width = indent;
+   printf(indentString);
+   i = j = 0;
+   while (1) {
+      if (ext[j] == ' ' || ext[j] == 0) {
+         /* found end of an extension name */
+         const int len = j - i;
+         if (width + len > max) {
+            /* start a new line */
+            printf("\n");
+            width = indent;
+            printf(indentString);
+         }
+         /* print the extension name between ext[i] and ext[j] */
+         while (i < j) {
+            printf("%c", ext[i]);
+            i++;
+         }
+         /* either we're all done, or we'll continue with next extension */
+         width += len + 1;
+         if (ext[j] == 0) {
+            break;
+         }
+         else {
+            i++;
+            j++;
+            printf(", ");
+            width += 2;
+         }
+      }
+      j++;
+   }
+   printf("\n");
+}
 
 
-int
-main( int argc, char *argv[] )
+static void
+print_screen_info(Display *dpy, int scrnum)
 {
-   Display *dpy;
    Window win;
    int attrib[] = { GLX_RGBA,
 		    GLX_RED_SIZE, 1,
 		    GLX_GREEN_SIZE, 1,
 		    GLX_BLUE_SIZE, 1,
 		    None };
-   int scrnum;
    XSetWindowAttributes attr;
    unsigned long mask;
    Window root;
@@ -59,40 +143,326 @@ main( int argc, char *argv[] )
    XVisualInfo *visinfo;
    int width = 100, height = 100;
 
-   dpy = XOpenDisplay(NULL);
-   if (!dpy) {
-      fprintf(stderr, "Unable to open default display!\n");
-      return 1;
-   }
-
-   scrnum = DefaultScreen( dpy );
-   root = RootWindow( dpy, scrnum );
+   root = RootWindow(dpy, scrnum);
 
-   visinfo = glXChooseVisual( dpy, scrnum, attrib );
+   visinfo = glXChooseVisual(dpy, scrnum, attrib);
    if (!visinfo) {
       fprintf(stderr, "Error: couldn't find RGB GLX visual!\n");
-      return 1;
+      return;
    }
 
-   /* window attributes */
    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 );
+   win = XCreateWindow(dpy, root, 0, 0, width, height,
+		       0, visinfo->depth, InputOutput,
+		       visinfo->visual, mask, &attr);
 
    ctx = glXCreateContext( dpy, visinfo, NULL, True );
 
    glXMakeCurrent( dpy, win, ctx );
 
-   query_glx(dpy, scrnum);
+
+   {
+      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 *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);
+      const char *glExtensions = (const char *) glGetString(GL_EXTENSIONS);
+      const char *gluVersion = (const char *) gluGetString(GLU_VERSION);
+      const char *gluExtensions = (const char *) gluGetString(GLU_EXTENSIONS);
+      printf("display: %s  screen:%d\n", DisplayString(dpy), scrnum);
+      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);
+      printf("client glx version: %s\n", clientVersion);
+      printf("client glx extensions:\n");
+      print_extension_list(clientExtensions);
+      printf("GLX extensions:\n");
+      print_extension_list(glxExtensions);
+      printf("OpenGL vendor string: %s\n", glVendor);
+      printf("OpenGL renderer string: %s\n", glRenderer);
+      printf("OpenGL version string: %s\n", glVersion);
+      printf("OpenGL extensions:\n");
+      print_extension_list(glExtensions);
+      printf("glu version: %s\n", gluVersion);
+      printf("glu extensions:\n");
+      print_extension_list(gluExtensions);
+   }
 
    glXDestroyContext(dpy, ctx);
    XDestroyWindow(dpy, win);
+}
+
+
+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_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 void
+get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
+                   struct visual_attribs *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;
+
+   attribs->transparent = 0;
+   glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL);
+   glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize);
+   glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level);
+   glXGetConfig(dpy, vInfo, GLX_RGBA, &attribs->rgba);
+   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);
+
+   attribs->numSamples = 0;
+   attribs->numMultisample = 0;
+}
+
+
+static void
+print_visual_attribs_verbose(const struct visual_attribs *attribs)
+{
+   printf("Visual ID: %x  depth=%d  class=%s\n",
+          attribs->id, attribs->depth, visual_class_name(attribs->klass));
+   printf("    bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n",
+          attribs->bufferSize, attribs->level, attribs->rgba ? "rgba" : "ci",
+          attribs->doubleBuffer, attribs->stereo);
+   printf("    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n",
+          attribs->redSize, attribs->greenSize,
+          attribs->blueSize, attribs->alphaSize);
+   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);
+   printf("    %s\n", attribs->transparent ? "Transparent." : "Opaque.");
+}
+
+
+static void
+print_visual_attribs_short_header(void)
+{
+ printf("   visual  x  bf lv rg d st  r  g  b  a ax dp st accum buffs  ms \n");
+ printf(" id dep cl sp sz l  ci b ro sz sz sz sz bf th cl  r  g  b  a ns b\n");
+ printf("-----------------------------------------------------------------\n");
+}
+
+
+static void
+print_visual_attribs_short(const struct visual_attribs *attribs)
+{
+   printf("0x%2x %2d %2s %2d %2d %2d %1s %2s %2s %2d %2d %2d %2d %2d %2d %2d",
+          attribs->id,
+          attribs->depth,
+          visual_class_abbrev(attribs->klass),
+          attribs->transparent,
+          attribs->bufferSize,
+          attribs->level,
+          attribs->rgba ? "r" : "c",
+          attribs->doubleBuffer ? "y" : ".",
+          attribs->stereo ? "y" : ".",
+          attribs->redSize, attribs->greenSize,
+          attribs->blueSize, attribs->alphaSize,
+          attribs->auxBuffers,
+          attribs->depthSize,
+          attribs->stencilSize
+          );
+
+   printf(" %2d %2d %2d %2d %2d %1d\n",
+          attribs->accumRedSize, attribs->accumGreenSize,
+          attribs->accumBlueSize, attribs->accumAlphaSize,
+          attribs->numSamples, attribs->numMultisample
+          );
+}
+
+
+static void
+print_visual_attribs_long_header(void)
+{
+ printf("Vis  Vis   Visual Trans  buff lev render DB ste  r   g   b   a  aux dep ste  accum buffers  MS   MS\n");
+ printf(" ID Depth   Type  parent size el   type     reo sz  sz  sz  sz  buf th  ncl  r   g   b   a  num bufs\n");
+ printf("----------------------------------------------------------------------------------------------------\n");
+}
+
+
+static void
+print_visual_attribs_long(const struct visual_attribs *attribs)
+{
+   printf("0x%2x %2d %-11s %2d     %2d %2d  %4s %3d %3d %3d %3d %3d %3d",
+          attribs->id,
+          attribs->depth,
+          visual_class_name(attribs->klass),
+          attribs->transparent,
+          attribs->bufferSize,
+          attribs->level,
+          attribs->rgba ? "rgba" : "ci  ",
+          attribs->doubleBuffer,
+          attribs->stereo,
+          attribs->redSize, attribs->greenSize,
+          attribs->blueSize, attribs->alphaSize
+          );
+
+   printf(" %3d %4d %2d %3d %3d %3d %3d  %2d  %2d\n",
+          attribs->auxBuffers,
+          attribs->depthSize,
+          attribs->stencilSize,
+          attribs->accumRedSize, attribs->accumGreenSize,
+          attribs->accumBlueSize, attribs->accumAlphaSize,
+          attribs->numSamples, attribs->numMultisample
+          );
+}
+
+
+static void
+print_visual_info(Display *dpy, int scrnum, InfoMode mode)
+{
+   XVisualInfo template;
+   XVisualInfo *visuals;
+   int numVisuals;
+   long mask;
+   int i;
+
+   /* get list of all visuals on this screen */
+   template.screen = scrnum;
+   mask = VisualScreenMask;
+   visuals = XGetVisualInfo(dpy, mask, &template, &numVisuals);
+
+   if (mode == Verbose) {
+      for (i = 0; i < numVisuals; i++) {
+         struct visual_attribs attribs;
+         get_visual_attribs(dpy, &visuals[i], &attribs);
+         print_visual_attribs_verbose(&attribs);
+      }
+   }
+   else if (mode == Normal) {
+      print_visual_attribs_short_header();
+      for (i = 0; i < numVisuals; i++) {
+         struct visual_attribs attribs;
+         get_visual_attribs(dpy, &visuals[i], &attribs);
+         print_visual_attribs_short(&attribs);
+      }
+   }
+   else if (mode == Wide) {
+      print_visual_attribs_long_header();
+      for (i = 0; i < numVisuals; i++) {
+         struct visual_attribs attribs;
+         get_visual_attribs(dpy, &visuals[i], &attribs);
+         print_visual_attribs_long(&attribs);
+      }
+   }
+
+   XFree(visuals);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+   char *displayName = ":0";
+   Display *dpy;
+   int numScreens, scrnum;
+   InfoMode mode = Normal;
+   int i;
+
+   for (i = 1; i < argc; i++) {
+      if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
+         displayName = argv[i + 1];
+         i++;
+      }
+      else if (strcmp(argv[i], "-t") == 0) {
+         mode = Wide;
+      }
+      else if (strcmp(argv[i], "-v") == 0) {
+         mode = Verbose;
+      }
+   }
+
+   dpy = XOpenDisplay(displayName);
+   if (!dpy) {
+      fprintf(stderr, "Error: unable to open display %s\n", displayName);
+      return -1;
+   }
+
+   numScreens = ScreenCount(dpy);
+   for (scrnum = 0; scrnum < numScreens; scrnum++) {
+      print_screen_info(dpy, 0);
+      printf("\n");
+      print_visual_info(dpy, 0, mode);
+      if (scrnum + 1 < numScreens)
+         printf("\n\n");
+   }
+
    XCloseDisplay(dpy);
 
    return 0;