git.hungrycats.org Git - xscreensaver/blob - hacks/glx/grab-ximage.c

   1 /* grab-ximage.c --- grab the screen to an XImage for use with OpenGL.
   2  * xscreensaver, Copyright (c) 2001, 2003, 2005 Jamie Zawinski <jwz@jwz.org>
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation.  No representations are made about the suitability of this
   9  * software for any purpose.  It is provided "as is" without express or
  10  * implied warranty.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <X11/Xlib.h>
  21 #include <X11/Xutil.h>
  22 #include <GL/gl.h>      /* only for GLfloat */
  23 #include <GL/glu.h>     /* for gluBuild2DMipmaps */
  24
  25 #include "grabscreen.h"
  26 #include "visual.h"
  27
  28 /* If REFORMAT_IMAGE_DATA is defined, then we convert Pixmaps to textures
  29    like this:
  30
  31      - get Pixmap as an XImage in whatever form the server hands us;
  32      - convert that XImage to 32-bit RGBA in client-local endianness;
  33      - make the texture using RGBA, UNSIGNED_BYTE.
  34
  35    If undefined, we do this:
  36
  37      - get Pixmap as an XImage in whatever form the server hands us;
  38      - figure out what OpenGL texture packing parameters correspond to
  39        the image data that the server sent us and use that, e.g.,
  40        BGRA, INT_8_8_8_8_REV.
  41
  42    You might expect the second method to be faster, since we're not making
  43    a second copy of the data and iterating each pixel before we hand it
  44    to GL.  But, you'd be wrong.  The first method is almost 6x faster.
  45    I guess GL is reformatting it *again*, and doing it very inefficiently!
  46 */
  47 #define REFORMAT_IMAGE_DATA
  48
  49
  50 #ifdef HAVE_XSHM_EXTENSION
  51 # include "resources.h"
  52 # include "xshm.h"
  53 #endif /* HAVE_XSHM_EXTENSION */
  54
  55 extern char *progname;
  56
  57 #include <X11/Xutil.h>
  58 #include <sys/time.h>
  59
  60 #undef MAX
  61 #define MAX(a,b) ((a)>(b)?(a):(b))
  62
  63 #undef countof
  64 #define countof(x) (sizeof((x))/sizeof((*x)))
  65
  66
  67 static int debug_p = 0;
  68
  69 static Bool
  70 bigendian (void)
  71 {
  72   union { int i; char c[sizeof(int)]; } u;
  73   u.i = 1;
  74   return !u.c[0];
  75 }
  76
  77
  78 #ifdef REFORMAT_IMAGE_DATA
  79
  80 /* Given a bitmask, returns the position and width of the field.
  81  */
  82 static void
  83 decode_mask (unsigned int mask, unsigned int *pos_ret, unsigned int *size_ret)
  84 {
  85   int i;
  86   for (i = 0; i < 32; i++)
  87     if (mask & (1L << i))
  88       {
  89         int j = 0;
  90         *pos_ret = i;
  91         for (; i < 32; i++, j++)
  92           if (! (mask & (1L << i)))
  93             break;
  94         *size_ret = j;
  95         return;
  96       }
  97 }
  98
  99
 100 /* Given a value and a field-width, expands the field to fill out 8 bits.
 101  */
 102 static unsigned char
 103 spread_bits (unsigned char value, unsigned char width)
 104 {
 105   switch (width)
 106     {
 107     case 8: return value;
 108     case 7: return (value << 1) | (value >> 6);
 109     case 6: return (value << 2) | (value >> 4);
 110     case 5: return (value << 3) | (value >> 2);
 111     case 4: return (value << 4) | (value);
 112     case 3: return (value << 5) | (value << 2) | (value >> 2);
 113     case 2: return (value << 6) | (value << 4) | (value);
 114     default: abort(); break;
 115     }
 116 }
 117
 118
 119 static XImage *
 120 convert_ximage_to_rgba32 (Screen *screen, XImage *image)
 121 {
 122   Display *dpy = DisplayOfScreen (screen);
 123   Visual *visual = DefaultVisualOfScreen (screen);
 124
 125   int x, y;
 126   unsigned int crpos=0, cgpos=0, cbpos=0, capos=0; /* bitfield positions */
 127   unsigned int srpos=0, sgpos=0, sbpos=0;
 128   unsigned int srmsk=0, sgmsk=0, sbmsk=0;
 129   unsigned int srsiz=0, sgsiz=0, sbsiz=0;
 130   int i;
 131   XColor *colors = 0;
 132   unsigned char spread_map[3][256];
 133
 134   /* Note: height+2 in "to" to be to work around an array bounds overrun
 135      in gluBuild2DMipmaps / gluScaleImage.
 136    */
 137   XImage *from = image;
 138   XImage *to = XCreateImage (dpy, visual, 32,  /* depth */
 139                              ZPixmap, 0, 0, from->width, from->height + 2,
 140                              32, /* bitmap pad */
 141                              0);
 142   to->data = (char *) calloc (to->height, to->bytes_per_line);
 143
 144   if (visual_class (screen, visual) == PseudoColor ||
 145       visual_class (screen, visual) == GrayScale)
 146     {
 147       Colormap cmap = DefaultColormapOfScreen (screen);
 148       int ncolors = visual_cells (screen, visual);
 149       int i;
 150       colors = (XColor *) calloc (sizeof (*colors), ncolors+1);
 151       for (i = 0; i < ncolors; i++)
 152         colors[i].pixel = i;
 153       XQueryColors (dpy, cmap, colors, ncolors);
 154     }
 155
 156   if (colors == 0)  /* truecolor */
 157     {
 158       srmsk = to->red_mask;
 159       sgmsk = to->green_mask;
 160       sbmsk = to->blue_mask;
 161
 162       decode_mask (srmsk, &srpos, &srsiz);
 163       decode_mask (sgmsk, &sgpos, &sgsiz);
 164       decode_mask (sbmsk, &sbpos, &sbsiz);
 165     }
 166
 167   /* Pack things in "RGBA" order in client endianness. */
 168   if (bigendian())
 169     crpos = 24, cgpos = 16, cbpos =  8, capos =  0;
 170   else
 171     crpos =  0, cgpos =  8, cbpos = 16, capos = 24;
 172
 173   if (colors == 0)  /* truecolor */
 174     {
 175       for (i = 0; i < 256; i++)
 176         {
 177           spread_map[0][i] = spread_bits (i, srsiz);
 178           spread_map[1][i] = spread_bits (i, sgsiz);
 179           spread_map[2][i] = spread_bits (i, sbsiz);
 180         }
 181     }
 182
 183   for (y = 0; y < from->height; y++)
 184     for (x = 0; x < from->width; x++)
 185       {
 186         unsigned long sp = XGetPixel (from, x, y);
 187         unsigned char sr, sg, sb;
 188         unsigned long cp;
 189
 190         if (colors)
 191           {
 192             sr = colors[sp].red   & 0xFF;
 193             sg = colors[sp].green & 0xFF;
 194             sb = colors[sp].blue  & 0xFF;
 195           }
 196         else
 197           {
 198             sr = (sp & srmsk) >> srpos;
 199             sg = (sp & sgmsk) >> sgpos;
 200             sb = (sp & sbmsk) >> sbpos;
 201
 202             sr = spread_map[0][sr];
 203             sg = spread_map[1][sg];
 204             sb = spread_map[2][sb];
 205           }
 206
 207         cp = ((sr << crpos) |
 208               (sg << cgpos) |
 209               (sb << cbpos) |
 210               (0xFF << capos));
 211
 212         XPutPixel (to, x, y, cp);
 213       }
 214
 215   if (colors) free (colors);
 216
 217   return to;
 218 }
 219
 220 #endif /* REFORMAT_IMAGE_DATA */
 221
 222 /* Shrinks the XImage by a factor of two.
 223    We use this when mipmapping fails on large textures.
 224  */
 225 static void
 226 halve_image (XImage *ximage, XRectangle *geom)
 227 {
 228   int w2 = ximage->width/2;
 229   int h2 = ximage->height/2;
 230   int x, y;
 231   XImage *ximage2;
 232
 233   if (w2 <= 32 || h2 <= 32)   /* let's not go crazy here, man. */
 234     return;
 235
 236   if (debug_p)
 237     fprintf (stderr, "%s: shrinking image %dx%d -> %dx%d\n",
 238              progname, ximage->width, ximage->height, w2, h2);
 239
 240   ximage2 = (XImage *) calloc (1, sizeof (*ximage2));
 241   *ximage2 = *ximage;
 242   ximage2->width = w2;
 243   ximage2->height = h2;
 244   ximage2->bytes_per_line = 0;
 245   ximage2->data = 0;
 246   XInitImage (ximage2);
 247
 248   ximage2->data = (char *) calloc (h2, ximage2->bytes_per_line);
 249   if (!ximage2->data)
 250     {
 251       fprintf (stderr, "%s: out of memory (scaling %dx%d image to %dx%d)\n",
 252                progname, ximage->width, ximage->height, w2, h2);
 253       exit (1);
 254     }
 255
 256   for (y = 0; y < h2; y++)
 257     for (x = 0; x < w2; x++)
 258       XPutPixel (ximage2, x, y, XGetPixel (ximage, x*2, y*2));
 259
 260   free (ximage->data);
 261   *ximage = *ximage2;
 262   ximage2->data = 0;
 263   XFree (ximage2);
 264
 265   if (geom)
 266     {
 267       geom->x /= 2;
 268       geom->y /= 2;
 269       geom->width  /= 2;
 270       geom->height /= 2;
 271     }
 272 }
 273
 274
 275 #ifdef REFORMAT_IMAGE_DATA
 276
 277 /* Pulls the Pixmap bits from the server and returns an XImage
 278    in some format acceptable to OpenGL.
 279  */
 280 static XImage *
 281 pixmap_to_gl_ximage (Screen *screen, Window window, Pixmap pixmap)
 282 {
 283   Display *dpy = DisplayOfScreen (screen);
 284   Visual *visual = DefaultVisualOfScreen (screen);
 285   unsigned int width, height, depth;
 286
 287 # ifdef HAVE_XSHM_EXTENSION
 288   Bool use_shm = get_boolean_resource ("useSHM", "Boolean");
 289   XShmSegmentInfo shm_info;
 290 # endif /* HAVE_XSHM_EXTENSION */
 291
 292   XImage *server_ximage = 0;
 293   XImage *client_ximage = 0;
 294
 295   {
 296     Window root;
 297     int x, y;
 298     unsigned int bw;
 299     XGetGeometry (dpy, pixmap, &root, &x, &y, &width, &height, &bw, &depth);
 300   }
 301
 302   /* Convert the server-side Pixmap to a client-side GL-ordered XImage.
 303    */
 304 # ifdef HAVE_XSHM_EXTENSION
 305   if (use_shm)
 306     {
 307       server_ximage = create_xshm_image (dpy, visual, depth,
 308                                          ZPixmap, 0, &shm_info,
 309                                          width, height);
 310       if (server_ximage)
 311         XShmGetImage (dpy, pixmap, server_ximage, 0, 0, ~0L);
 312       else
 313         use_shm = False;
 314     }
 315 # endif /* HAVE_XSHM_EXTENSION */
 316
 317   if (!server_ximage)
 318     server_ximage = XGetImage (dpy, pixmap, 0, 0, width, height, ~0L, ZPixmap);
 319
 320   client_ximage = convert_ximage_to_rgba32 (screen, server_ximage);
 321
 322 # ifdef HAVE_XSHM_EXTENSION
 323   if (use_shm)
 324     destroy_xshm_image (dpy, server_ximage, &shm_info);
 325   else
 326 # endif /* HAVE_XSHM_EXTENSION */
 327     XDestroyImage (server_ximage);
 328
 329   return client_ximage;
 330 }
 331
 332
 333 # else /* ! REFORMAT_IMAGE_DATA */
 334
 335 typedef struct {
 336   unsigned int depth, red_mask, green_mask, blue_mask;  /* when this... */
 337   GLint type, format;                                   /* ...use this. */
 338 } conversion_table;
 339
 340 /* Abbreviate these so that the table entries all fit on one line...
 341  */
 342 #define BYTE               GL_UNSIGNED_BYTE
 343 #define BYTE_2_3_3_REV     GL_UNSIGNED_BYTE_2_3_3_REV
 344 #define BYTE_3_3_2         GL_UNSIGNED_BYTE_3_3_2
 345 #define INT_10_10_10_2     GL_UNSIGNED_INT_10_10_10_2
 346 #define INT_2_10_10_10_REV GL_UNSIGNED_INT_2_10_10_10_REV
 347 #define INT_8_8_8_8        GL_UNSIGNED_INT_8_8_8_8
 348 #define INT_8_8_8_8_REV    GL_UNSIGNED_INT_8_8_8_8_REV
 349 #define SHORT_1_5_5_5_REV  GL_UNSIGNED_SHORT_1_5_5_5_REV
 350 #define SHORT_4_4_4_4      GL_UNSIGNED_SHORT_4_4_4_4
 351 #define SHORT_4_4_4_4_REV  GL_UNSIGNED_SHORT_4_4_4_4_REV
 352 #define SHORT_5_5_5_1      GL_UNSIGNED_SHORT_5_5_5_1
 353 #define SHORT_5_6_5        GL_UNSIGNED_SHORT_5_6_5
 354 #define SHORT_5_6_5_REV    GL_UNSIGNED_SHORT_5_6_5_REV
 355
 356 static conversion_table ctable[] = {
 357   { 8,  0x000000E0, 0x0000001C, 0x00000003, BYTE_3_3_2,         GL_RGB      },
 358   { 8,  0x00000007, 0x00000038, 0x000000C0, BYTE_2_3_3_REV,     GL_RGB      },
 359   { 16, 0x0000F800, 0x000007E0, 0x0000001F, SHORT_5_6_5,        GL_RGB      },
 360   { 16, 0x0000001F, 0x000007E0, 0x0000F800, SHORT_5_6_5_REV,    GL_RGB      },
 361   { 16, 0x0000F000, 0x00000F00, 0x000000F0, SHORT_4_4_4_4,      GL_RGBA     },
 362   { 16, 0x000000F0, 0x00000F00, 0x0000F000, SHORT_4_4_4_4,      GL_BGRA     },
 363   { 16, 0x0000000F, 0x000000F0, 0x00000F00, SHORT_4_4_4_4,      GL_ABGR_EXT },
 364   { 16, 0x0000000F, 0x000000F0, 0x00000F00, SHORT_4_4_4_4_REV,  GL_RGBA     },
 365   { 16, 0x00000F00, 0x000000F0, 0x0000000F, SHORT_4_4_4_4_REV,  GL_BGRA     },
 366   { 16, 0x0000F800, 0x000007C0, 0x0000003E, SHORT_5_5_5_1,      GL_RGBA     },
 367   { 16, 0x0000003E, 0x000007C0, 0x0000F800, SHORT_5_5_5_1,      GL_BGRA     },
 368   { 16, 0x00000001, 0x0000003E, 0x000007C0, SHORT_5_5_5_1,      GL_ABGR_EXT },
 369   { 16, 0x0000001F, 0x000003E0, 0x00007C00, SHORT_1_5_5_5_REV,  GL_RGBA     },
 370   { 16, 0x00007C00, 0x000003E0, 0x0000001F, SHORT_1_5_5_5_REV,  GL_BGRA     },
 371   { 32, 0xFF000000, 0x00FF0000, 0x0000FF00, INT_8_8_8_8,        GL_RGBA     },
 372   { 32, 0x0000FF00, 0x00FF0000, 0xFF000000, INT_8_8_8_8,        GL_BGRA     },
 373   { 32, 0x000000FF, 0x0000FF00, 0x00FF0000, INT_8_8_8_8,        GL_ABGR_EXT },
 374   { 32, 0x000000FF, 0x0000FF00, 0x00FF0000, INT_8_8_8_8_REV,    GL_RGBA     },
 375   { 32, 0x00FF0000, 0x0000FF00, 0x000000FF, INT_8_8_8_8_REV,    GL_BGRA     },
 376   { 32, 0xFFC00000, 0x003FF000, 0x00000FFC, INT_10_10_10_2,     GL_RGBA     },
 377   { 32, 0x00000FFC, 0x003FF000, 0xFFC00000, INT_10_10_10_2,     GL_BGRA     },
 378   { 32, 0x00000003, 0x00000FFC, 0x003FF000, INT_10_10_10_2,     GL_ABGR_EXT },
 379   { 32, 0x000003FF, 0x000FFC00, 0x3FF00000, INT_2_10_10_10_REV, GL_RGBA     },
 380   { 32, 0x3FF00000, 0x000FFC00, 0x000003FF, INT_2_10_10_10_REV, GL_BGRA     },
 381   { 24, 0x000000FF, 0x0000FF00, 0x00FF0000, BYTE,               GL_RGB      },
 382   { 24, 0x00FF0000, 0x0000FF00, 0x000000FF, BYTE,               GL_BGR      },
 383 };
 384
 385
 386 /* Given an XImage, returns the GL settings to use its data as a texture.
 387  */
 388 static void
 389 gl_settings_for_ximage (XImage *image,
 390                         GLint *type_ret, GLint *format_ret, GLint *swap_ret)
 391 {
 392   int i;
 393   for (i = 0; i < countof(ctable); ++i)
 394     {
 395       if (image->bits_per_pixel == ctable[i].depth &&
 396           image->red_mask       == ctable[i].red_mask &&
 397           image->green_mask     == ctable[i].green_mask &&
 398           image->blue_mask      == ctable[i].blue_mask)
 399         {
 400           *type_ret   = ctable[i].type;
 401           *format_ret = ctable[i].format;
 402
 403           if (image->bits_per_pixel == 24)
 404             {
 405               /* don't know how to test this... */
 406               *type_ret = (ctable[i].type == GL_RGB) ? GL_BGR : GL_RGB;
 407               *swap_ret = 0;
 408             }
 409           else
 410             {
 411               *swap_ret = !!(image->byte_order == MSBFirst) ^ !!bigendian();
 412             }
 413
 414           if (debug_p)
 415             {
 416               fprintf (stderr, "%s: using %s %s %d for %d %08lX %08lX %08lX\n",
 417                        progname,
 418                        (*format_ret == GL_RGB      ? "RGB" :
 419                         *format_ret == GL_BGR      ? "BGR" :
 420                         *format_ret == GL_RGBA     ? "RGBA" :
 421                         *format_ret == GL_BGRA     ? "BGRA" :
 422                         *format_ret == GL_ABGR_EXT ? "ABGR_EXT" :
 423                         "???"),
 424                        (*type_ret == BYTE               ? "BYTE" :
 425                         *type_ret == BYTE_3_3_2         ? "BYTE_3_3_2" :
 426                         *type_ret == BYTE_2_3_3_REV     ? "BYTE_2_3_3_REV" :
 427                         *type_ret == INT_8_8_8_8        ? "INT_8_8_8_8" :
 428                         *type_ret == INT_8_8_8_8_REV    ? "INT_8_8_8_8_REV" :
 429                         *type_ret == INT_10_10_10_2     ? "INT_10_10_10_2" :
 430                         *type_ret == INT_2_10_10_10_REV ? "INT_2_10_10_10_REV":
 431                         *type_ret == SHORT_4_4_4_4      ? "SHORT_4_4_4_4" :
 432                         *type_ret == SHORT_4_4_4_4_REV  ? "SHORT_4_4_4_4_REV" :
 433                         *type_ret == SHORT_5_5_5_1      ? "SHORT_5_5_5_1" :
 434                         *type_ret == SHORT_1_5_5_5_REV  ? "SHORT_1_5_5_5_REV" :
 435                         *type_ret == SHORT_5_6_5        ? "SHORT_5_6_5" :
 436                         *type_ret == SHORT_5_6_5_REV    ? "SHORT_5_6_5_REV" :
 437                         "???"),
 438                        *swap_ret,
 439                        image->bits_per_pixel,
 440                        image->red_mask, image->green_mask, image->blue_mask);
 441             }
 442
 443           return;
 444         }
 445     }
 446
 447   /* Unknown RGB fields? */
 448   abort();
 449 }
 450
 451 #endif /* ! REFORMAT_IMAGE_DATA */
 452
 453 typedef struct {
 454   Pixmap pixmap;
 455   int pix_width, pix_height, pix_depth;
 456   int texid;
 457   Bool mipmap_p;
 458   double load_time;
 459
 460   /* Used in async mode
 461    */
 462   void (*callback) (const char *filename, XRectangle *geometry,
 463                     int iw, int ih, int tw, int th,
 464                     void *closure);
 465   void *closure;
 466
 467   /* Used in sync mode
 468    */
 469   char **filename_return;
 470   XRectangle *geometry_return;
 471   int *image_width_return;
 472   int *image_height_return;
 473   int *texture_width_return;
 474   int *texture_height_return;
 475
 476 } img_closure;
 477
 478
 479 /* Returns the current time in seconds as a double.
 480  */
 481 static double
 482 double_time (void)
 483 {
 484   struct timeval now;
 485 # ifdef GETTIMEOFDAY_TWO_ARGS
 486   struct timezone tzp;
 487   gettimeofday(&now, &tzp);
 488 # else
 489   gettimeofday(&now);
 490 # endif
 491
 492   return (now.tv_sec + ((double) now.tv_usec * 0.000001));
 493 }
 494
 495
 496 /* return the next larger power of 2. */
 497 static int
 498 to_pow2 (int i)
 499 {
 500   static unsigned int pow2[] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,
 501                                  2048, 4096, 8192, 16384, 32768, 65536 };
 502   int j;
 503   for (j = 0; j < countof(pow2); j++)
 504     if (pow2[j] >= i) return pow2[j];
 505   abort();  /* too big! */
 506 }
 507
 508
 509 /* Loads the given XImage into GL's texture memory.
 510    The image may be of any size.
 511    If mipmap_p is true, then make mipmaps instead of just a single texture.
 512    Writes to stderr and returns False on error.
 513  */
 514 static Bool
 515 ximage_to_texture (XImage *ximage,
 516                    GLint type, GLint format,
 517                    int *width_return,
 518                    int *height_return,
 519                    XRectangle *geometry,
 520                    Bool mipmap_p)
 521 {
 522   int max_reduction = 7;
 523   int err_count = 0;
 524   GLenum err = 0;
 525   int orig_width = ximage->width;
 526   int orig_height = ximage->height;
 527   int tex_width = 0;
 528   int tex_height = 0;
 529
 530  AGAIN:
 531
 532   if (mipmap_p)
 533     {
 534       /* gluBuild2DMipmaps doesn't require textures to be a power of 2. */
 535       tex_width  = ximage->width;
 536       tex_height = ximage->height;
 537
 538       if (debug_p)
 539         fprintf (stderr, "%s: mipmap %d x %d\n",
 540                  progname, ximage->width, ximage->height);
 541
 542       gluBuild2DMipmaps (GL_TEXTURE_2D, 3, ximage->width, ximage->height,
 543                          format, type, ximage->data);
 544       err = glGetError();
 545     }
 546   else
 547     {
 548       /* glTexImage2D() requires the texture sizes to be powers of 2.
 549          So first, create a texture of that size (but don't write any
 550          data into it.)
 551        */
 552       tex_width  = to_pow2 (ximage->width);
 553       tex_height = to_pow2 (ximage->height);
 554
 555       if (debug_p)
 556         fprintf (stderr, "%s: texture %d x %d (%d x %d)\n",
 557                  progname, ximage->width, ximage->height,
 558                  tex_width, tex_height);
 559
 560       glTexImage2D (GL_TEXTURE_2D, 0, 3, tex_width, tex_height, 0,
 561                     format, type, 0);
 562       err = glGetError();
 563
 564       /* Now load our non-power-of-2 image data into the existing texture. */
 565       if (!err)
 566         {
 567           glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
 568                            ximage->width, ximage->height,
 569                            GL_RGBA, GL_UNSIGNED_BYTE, ximage->data);
 570           err = glGetError();
 571         }
 572     }
 573
 574   if (err)
 575     {
 576       char buf[100];
 577       const char *s = (char *) gluErrorString (err);
 578
 579       if (!s || !*s)
 580         {
 581           sprintf (buf, "unknown error %d", err);
 582           s = buf;
 583         }
 584
 585       while (glGetError() != GL_NO_ERROR)
 586         ;  /* clear any lingering errors */
 587
 588       if (++err_count > max_reduction)
 589         {
 590           fprintf (stderr,
 591                    "\n"
 592                    "%s: %dx%d texture failed, even after reducing to %dx%d:\n"
 593                    "%s: The error was: \"%s\".\n"
 594                    "%s: probably this means "
 595                    "\"your video card is worthless and weak\"?\n\n",
 596                    progname, orig_width, orig_height,
 597                    ximage->width, ximage->height,
 598                    progname, s,
 599                    progname);
 600           return False;
 601         }
 602       else
 603         {
 604           if (debug_p)
 605             fprintf (stderr, "%s: mipmap error (%dx%d): %s\n",
 606                      progname, ximage->width, ximage->height, s);
 607           halve_image (ximage, geometry);
 608           goto AGAIN;
 609         }
 610     }
 611
 612   if (width_return)  *width_return  = tex_width;
 613   if (height_return) *height_return = tex_height;
 614   return True;
 615 }
 616
 617
 618 static void screen_to_texture_async_cb (Screen *screen,
 619                                         Window window, Drawable drawable,
 620                                         const char *name, XRectangle *geometry,
 621                                         void *closure);
 622
 623
 624 /* Grabs an image of the desktop (or another random image file) and
 625    loads tht image into GL's texture memory.
 626    Writes to stderr and returns False on error.
 627  */
 628 Bool
 629 screen_to_texture (Screen *screen, Window window,
 630                    int desired_width, int desired_height,
 631                    Bool mipmap_p,
 632                    char **filename_return,
 633                    XRectangle *geometry_return,
 634                    int *image_width_return,
 635                    int *image_height_return,
 636                    int *texture_width_return,
 637                    int *texture_height_return)
 638 {
 639   Display *dpy = DisplayOfScreen (screen);
 640   img_closure *data = (img_closure *) calloc (1, sizeof(*data));
 641   XWindowAttributes xgwa;
 642   char *filename = 0;
 643   XRectangle geom = { 0, 0, 0, 0 };
 644   int wret;
 645
 646   if (! image_width_return)
 647     image_width_return = &wret;
 648
 649   if (debug_p)
 650     data->load_time = double_time();
 651
 652   data->texid     = -1;
 653   data->mipmap_p  = mipmap_p;
 654   data->filename_return       = filename_return;
 655   data->geometry_return       = geometry_return;
 656   data->image_width_return    = image_width_return;
 657   data->image_height_return   = image_height_return;
 658   data->texture_width_return  = texture_width_return;
 659   data->texture_height_return = texture_height_return;
 660
 661   XGetWindowAttributes (dpy, window, &xgwa);
 662   data->pix_width  = xgwa.width;
 663   data->pix_height = xgwa.height;
 664   data->pix_depth  = xgwa.depth;
 665
 666   if (desired_width  && desired_width  < xgwa.width)
 667     data->pix_width  = desired_width;
 668   if (desired_height && desired_height < xgwa.height)
 669     data->pix_height = desired_height;
 670
 671   data->pixmap = XCreatePixmap (dpy, window, data->pix_width, data->pix_height,
 672                                 data->pix_depth);
 673   load_random_image (screen, window, data->pixmap, &filename, &geom);
 674   screen_to_texture_async_cb (screen, window, data->pixmap, filename, &geom,
 675                               data);
 676
 677   return (*image_width_return != 0);
 678 }
 679
 680
 681 /* Like the above, but the image is loaded in a background process,
 682    and a callback is run when the loading is complete.
 683    When the callback is called, the image data will have been loaded
 684    into texture number `texid' (via glBindTexture.)
 685
 686    If an error occurred, width/height will be 0.
 687  */
 688 void
 689 screen_to_texture_async (Screen *screen, Window window,
 690                          int desired_width, int desired_height,
 691                          Bool mipmap_p,
 692                          GLuint texid,
 693                          void (*callback) (const char *filename,
 694                                            XRectangle *geometry,
 695                                            int image_width,
 696                                            int image_height,
 697                                            int texture_width,
 698                                            int texture_height,
 699                                            void *closure),
 700                          void *closure)
 701 {
 702   Display *dpy = DisplayOfScreen (screen);
 703   XWindowAttributes xgwa;
 704   img_closure *data = (img_closure *) calloc (1, sizeof(*data));
 705
 706   if (debug_p)
 707     data->load_time = double_time();
 708
 709   data->texid     = texid;
 710   data->mipmap_p  = mipmap_p;
 711   data->callback  = callback;
 712   data->closure   = closure;
 713
 714   XGetWindowAttributes (dpy, window, &xgwa);
 715   data->pix_width  = xgwa.width;
 716   data->pix_height = xgwa.height;
 717   data->pix_depth  = xgwa.depth;
 718
 719   if (desired_width  && desired_width  < xgwa.width)
 720     data->pix_width  = desired_width;
 721   if (desired_height && desired_height < xgwa.height)
 722     data->pix_height = desired_height;
 723
 724   data->pixmap = XCreatePixmap (dpy, window, data->pix_width, data->pix_height,
 725                                 data->pix_depth);
 726   fork_load_random_image (screen, window, data->pixmap,
 727                           screen_to_texture_async_cb, data);
 728 }
 729
 730
 731 /* Once we have an XImage, this loads it into GL.
 732    This is used in both synchronous and asynchronous mode.
 733  */
 734 static void
 735 screen_to_texture_async_cb (Screen *screen, Window window, Drawable drawable,
 736                             const char *name, XRectangle *geometry,
 737                             void *closure)
 738 {
 739   Display *dpy = DisplayOfScreen (screen);
 740   Bool ok;
 741   XImage *ximage;
 742   GLint type, format;
 743   int iw=0, ih=0, tw=0, th=0;
 744   double cvt_time=0, tex_time=0, done_time=0;
 745   img_closure *data = (img_closure *) closure;
 746   /* copy closure data to stack and free the original before running cb */
 747   img_closure dd = *data;
 748   memset (data, 0, sizeof (*data));
 749   free (data);
 750   data = 0;
 751
 752   if (geometry->width <= 0 || geometry->height <= 0)
 753     {
 754       /* This can happen if an old version of xscreensaver-getimage
 755          is installed. */
 756       geometry->x = 0;
 757       geometry->y = 0;
 758       geometry->width  = dd.pix_width;
 759       geometry->height = dd.pix_height;
 760     }
 761
 762   if (geometry->width <= 0 || geometry->height <= 0)
 763     abort();
 764
 765   if (debug_p)
 766     cvt_time = double_time();
 767
 768 # ifdef REFORMAT_IMAGE_DATA
 769   ximage = pixmap_to_gl_ximage (screen, window, dd.pixmap);
 770   format = GL_RGBA;
 771   type = GL_UNSIGNED_BYTE;
 772
 773 #else /* ! REFORMAT_IMAGE_DATA */
 774   {
 775     Visual *visual = DefaultVisualOfScreen (screen);
 776     GLint swap;
 777
 778     ximage = XCreateImage (dpy, visual, dd.pix_depth, ZPixmap, 0, 0,
 779                            dd.pix_width, dd.pix_height, 32, 0);
 780
 781     /* Note: height+2 in "to" to be to work around an array bounds overrun
 782        in gluBuild2DMipmaps / gluScaleImage. */
 783     ximage->data = (char *) calloc (ximage->height+2, ximage->bytes_per_line);
 784
 785     if (!ximage->data ||
 786         !XGetSubImage (dpy, dd.pixmap, 0, 0, ximage->width, ximage->height,
 787                        ~0L, ximage->format, ximage, 0, 0))
 788       {
 789         XDestroyImage (ximage);
 790         ximage = 0;
 791       }
 792
 793     gl_settings_for_ximage (ximage, &type, &format, &swap);
 794     glPixelStorei (GL_UNPACK_SWAP_BYTES, !swap);
 795   }
 796 #endif /* REFORMAT_IMAGE_DATA */
 797
 798   XFreePixmap (dpy, dd.pixmap);
 799   dd.pixmap = 0;
 800
 801   if (debug_p)
 802     tex_time = double_time();
 803
 804   if (! ximage)
 805     ok = False;
 806   else
 807     {
 808       iw = ximage->width;
 809       ih = ximage->height;
 810       if (dd.texid != -1)
 811         glBindTexture (GL_TEXTURE_2D, dd.texid);
 812
 813       glPixelStorei (GL_UNPACK_ALIGNMENT, ximage->bitmap_pad / 8);
 814       ok = ximage_to_texture (ximage, type, format, &tw, &th, geometry,
 815                               dd.mipmap_p);
 816       if (ok)
 817         {
 818           iw = ximage->width;   /* in case the image was shrunk */
 819           ih = ximage->height;
 820         }
 821     }
 822
 823   if (ximage) XDestroyImage (ximage);
 824
 825   if (! ok)
 826     iw = ih = tw = th = 0;
 827
 828   if (debug_p)
 829     done_time = double_time();
 830
 831   if (debug_p)
 832     fprintf (stderr,
 833              /* prints: A + B + C = D
 834                 A = file I/O time (happens in background)
 835                 B = time to pull bits from server (this process)
 836                 C = time to convert bits to GL textures (this process)
 837                 D = total elapsed time from "want image" to "see image"
 838
 839                 B+C is responsible for any frame-rate glitches.
 840               */
 841              "%s: loading elapsed: %.2f + %.2f + %.2f = %.2f sec\n",
 842              progname,
 843              cvt_time  - dd.load_time,
 844              tex_time  - cvt_time,
 845              done_time - tex_time,
 846              done_time - dd.load_time);
 847
 848   if (dd.callback)
 849     /* asynchronous mode */
 850     dd.callback (name, geometry, iw, ih, tw, th, dd.closure);
 851   else
 852     {
 853       /* synchronous mode */
 854       if (dd.filename_return)       *dd.filename_return       = (char *) name;
 855       if (dd.geometry_return)       *dd.geometry_return       = *geometry;
 856       if (dd.image_width_return)    *dd.image_width_return    = iw;
 857       if (dd.image_height_return)   *dd.image_height_return   = ih;
 858       if (dd.texture_width_return)  *dd.texture_width_return  = tw;
 859       if (dd.texture_height_return) *dd.texture_height_return = th;
 860     }
 861 }