progs/xdemos/glsync.c

   1 /*
   2  * Copyright © 2007 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Jesse Barnes <jesse.barnes@intel.com>
  25  *
  26  */
  27
  28 /** @file glsync.c
  29  * The program is simple:  it paints a window alternating colors (red &
  30  * white) either as fast as possible or synchronized to vblank events
  31  *
  32  * If run normally, the program should display a window that exhibits
  33  * significant tearing between red and white colors (e.g. you might get
  34  * a "waterfall" effect of red and white horizontal bars).
  35  *
  36  * If run with the '-s b' option, the program should synchronize the
  37  * window color changes with the vertical blank period, resulting in a
  38  * window that looks orangish with a high frequency flicker (which may
  39  * be invisible).  If the window is moved to another screen, this
  40  * property should be preserved.  If the window spans two screens, it
  41  * shouldn't tear on whichever screen most of the window is on; the
  42  * portion on the other screen may show some tearing (like the
  43  * waterfall effect above).
  44  *
  45  * Other options include '-w <width>' and '-h <height' to set the
  46  * window size.
  47  */
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <unistd.h>
  52 #include <GL/gl.h>
  53 #include <GL/glu.h>
  54 #include <GL/glx.h>
  55 #include <GL/glxext.h>
  56 #include <X11/X.h>
  57 #include <X11/Xlib.h>
  58 #include <X11/Xutil.h>
  59
  60 void (*video_sync_get)();
  61 void (*video_sync)();
  62 void (*swap_interval)();
  63
  64 static int GLXExtensionSupported(Display *dpy, const char *extension)
  65 {
  66         const char *extensionsString, *pos;
  67
  68         extensionsString = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
  69
  70         pos = strstr(extensionsString, extension);
  71
  72         if (pos != NULL && (pos == extensionsString || pos[-1] == ' ') &&
  73             (pos[strlen(extension)] == ' ' || pos[strlen(extension)] == '\0'))
  74                 return 1;
  75
  76         return 0;
  77 }
  78
  79 extern char *optarg;
  80 extern int optind, opterr, optopt;
  81 static char optstr[] = "w:h:s:vi:";
  82
  83 enum sync_type {
  84         none = 0,
  85         sgi_video_sync,
  86         buffer_swap
  87 };
  88
  89 static void usage(char *name)
  90 {
  91         printf("usage: %s [-w <width>] [-h <height>] [-s<sync method>] "
  92                "[-v]\n", name);
  93         printf("\t-s<sync method>:\n");
  94         printf("\t\tn: none\n");
  95         printf("\t\ts: SGI video sync extension\n");
  96         printf("\t\tb: buffer swap\n");
  97         printf("\t-i<swap interval>\n");
  98         printf("\t-v: verbose (print count)\n");
  99         exit(-1);
 100 }
 101
 102 int main(int argc, char *argv[])
 103 {
 104         Display *disp;
 105         XVisualInfo *pvi;
 106         XSetWindowAttributes swa;
 107         GLint last_val = -1, count = 0;
 108         Window winGL;
 109         GLXContext context;
 110         int dummy;
 111         Atom wmDelete;
 112         enum sync_type waitforsync = none;
 113         int width = 500, height = 500, verbose = 0, interval = 1;
 114         int c, i = 1;
 115         int ret;
 116         int attribs[] = { GLX_RGBA,
 117                      GLX_RED_SIZE, 1,
 118                      GLX_GREEN_SIZE, 1,
 119                      GLX_BLUE_SIZE, 1,
 120                      None };
 121         int db_attribs[] = { GLX_RGBA,
 122                      GLX_RED_SIZE, 1,
 123                      GLX_GREEN_SIZE, 1,
 124                      GLX_BLUE_SIZE, 1,
 125                      GLX_DOUBLEBUFFER,
 126                      GLX_DEPTH_SIZE, 1,
 127                      None };
 128         XSizeHints sizehints;
 129
 130         opterr = 0;
 131         while ((c = getopt(argc, argv, optstr)) != -1) {
 132                 switch (c) {
 133                 case 'w':
 134                         width = atoi(optarg);
 135                         break;
 136                 case 'h':
 137                         height = atoi(optarg);
 138                         break;
 139                 case 's':
 140                         switch (optarg[0]) {
 141                         case 'n':
 142                                 waitforsync = none;
 143                                 break;
 144                         case 's':
 145                                 waitforsync = sgi_video_sync;
 146                                 break;
 147                         case 'b':
 148                                 waitforsync = buffer_swap;
 149                                 break;
 150                         default:
 151                                 usage(argv[0]);
 152                                 break;
 153                         }
 154                         break;
 155                 case 'v':
 156                         verbose = 1;
 157                         break;
 158                 case 'i':
 159                         interval = atoi(optarg);
 160                         break;
 161                 default:
 162                         usage(argv[0]);
 163                         break;
 164                 }
 165         }
 166
 167         disp = XOpenDisplay(NULL);
 168         if (!disp) {
 169                 fprintf(stderr, "failed to open display\n");
 170                 return -1;
 171         }
 172
 173         if (!glXQueryExtension(disp, &dummy, &dummy)) {
 174                 fprintf(stderr, "glXQueryExtension failed\n");
 175                 return -1;
 176         }
 177
 178         if (!GLXExtensionSupported(disp, "GLX_SGI_video_sync")) {
 179                 fprintf(stderr, "GLX_SGI_video_sync not supported, exiting\n");
 180                 return -1;
 181         }
 182
 183         if (waitforsync != buffer_swap) {
 184                 pvi = glXChooseVisual(disp, DefaultScreen(disp), attribs);
 185         } else {
 186                 pvi = glXChooseVisual(disp, DefaultScreen(disp), db_attribs);
 187         }
 188
 189         if (!pvi) {
 190                 fprintf(stderr, "failed to choose visual, exiting\n");
 191                 return -1;
 192         }
 193
 194         pvi->screen = DefaultScreen(disp);
 195
 196         swa.colormap = XCreateColormap(disp, RootWindow(disp, pvi->screen),
 197                                        pvi->visual, AllocNone);
 198         swa.border_pixel = 0;
 199         swa.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
 200                 StructureNotifyMask;
 201         winGL = XCreateWindow(disp, RootWindow(disp, pvi->screen),
 202                               0, 0,
 203                               width, height,
 204                               0, pvi->depth, InputOutput, pvi->visual,
 205                               CWBorderPixel | CWColormap | CWEventMask, &swa);
 206         if (!winGL) {
 207                 fprintf(stderr, "window creation failed\n");
 208                 return -1;
 209         }
 210         wmDelete = XInternAtom(disp, "WM_DELETE_WINDOW", True);
 211         XSetWMProtocols(disp, winGL, &wmDelete, 1);
 212
 213         sizehints.x = 0;
 214         sizehints.y = 0;
 215         sizehints.width  = width;
 216         sizehints.height = height;
 217         sizehints.flags = USSize | USPosition;
 218
 219         XSetNormalHints(disp, winGL, &sizehints);
 220         XSetStandardProperties(disp, winGL, "glsync test", "glsync text",
 221                                None, NULL, 0, &sizehints);
 222
 223         context = glXCreateContext(disp, pvi, NULL, GL_TRUE);
 224         if (!context) {
 225                 fprintf(stderr, "failed to create glx context\n");
 226                 return -1;
 227         }
 228
 229         XMapWindow(disp, winGL);
 230         ret = glXMakeCurrent(disp, winGL, context);
 231         if (!ret) {
 232                 fprintf(stderr, "failed to make context current: %d\n", ret);
 233         }
 234
 235         video_sync_get = glXGetProcAddress((unsigned char *)"glXGetVideoSyncSGI");
 236         video_sync = glXGetProcAddress((unsigned char *)"glXWaitVideoSyncSGI");
 237
 238         swap_interval = glXGetProcAddress((unsigned char *)"glXSwapIntervalSGI");
 239
 240         if (!video_sync_get || !video_sync || !swap_interval) {
 241                 fprintf(stderr, "failed to get sync functions\n");
 242                 return -1;
 243         }
 244
 245         if (waitforsync == buffer_swap) {
 246                 swap_interval(interval);
 247                 fprintf(stderr, "set swap interval to %d\n", interval);
 248         }
 249         video_sync_get(&count);
 250         count++;
 251         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 252         while (i++) {
 253                 /* Alternate colors to make tearing obvious */
 254                 if (i & 1) {
 255                         glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
 256                         glColor3f(1.0f, 1.0f, 1.0f);
 257                 } else {
 258                         glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
 259                         glColor3f(1.0f, 0.0f, 0.0f);
 260                 }
 261
 262                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 263                 glRectf(0, 0, width, height);
 264
 265                 /* Wait for vsync */
 266                 if (waitforsync == sgi_video_sync) {
 267                         if (verbose)
 268                                 fprintf(stderr, "waiting on count %d\n", count);
 269                         video_sync(2, (count + 1) % 2, &count);
 270                         if (count < last_val)
 271                                 fprintf(stderr, "error:  vblank count went backwards: %d -> %d\n", last_val, count);
 272                         if (count == last_val)
 273                                 fprintf(stderr, "error:  count didn't change: %d\n", count);
 274                         last_val = count;
 275                         glFlush();
 276                 } else if (waitforsync == buffer_swap) {
 277                         glXSwapBuffers(disp, winGL);
 278                 } else {
 279                         video_sync_get(&count);
 280                         sleep(1);
 281                         glFinish();
 282                 }
 283
 284                 if (verbose) {
 285                         video_sync_get(&count);
 286                         fprintf(stderr, "current count: %d\n", count);
 287                 }
 288         }
 289
 290         XDestroyWindow(disp, winGL);
 291         glXDestroyContext(disp, context);
 292         XCloseDisplay(disp);
 293
 294         return 0;
 295 }