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)
 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
 266
 267 #ifdef REFORMAT_IMAGE_DATA
 268
 269 /* Pulls the Pixmap bits from the server and returns an XImage
 270    in some format acceptable to OpenGL.
 271  */
 272 static XImage *
 273 pixmap_to_gl_ximage (Screen *screen, Window window, Pixmap pixmap)
 274 {
 275   Display *dpy = DisplayOfScreen (screen);
 276   Visual *visual = DefaultVisualOfScreen (screen);
 277   unsigned int width, height, depth;
 278
 279 # ifdef HAVE_XSHM_EXTENSION
 280   Bool use_shm = get_boolean_resource ("useSHM", "Boolean");
 281   XShmSegmentInfo shm_info;
 282 # endif /* HAVE_XSHM_EXTENSION */
 283
 284   XImage *server_ximage = 0;
 285   XImage *client_ximage = 0;
 286
 287   {
 288     Window root;
 289     int x, y;
 290     unsigned int bw;
 291     XGetGeometry (dpy, pixmap, &root, &x, &y, &width, &height, &bw, &depth);
 292   }
 293
 294   /* Convert the server-side Pixmap to a client-side GL-ordered XImage.
 295    */
 296 # ifdef HAVE_XSHM_EXTENSION
 297   if (use_shm)
 298     {
 299       server_ximage = create_xshm_image (dpy, visual, depth,
 300                                          ZPixmap, 0, &shm_info,
 301                                          width, height);
 302       if (server_ximage)
 303         XShmGetImage (dpy, pixmap, server_ximage, 0, 0, ~0L);
 304       else
 305         use_shm = False;
 306     }
 307 # endif /* HAVE_XSHM_EXTENSION */
 308
 309   if (!server_ximage)
 310     server_ximage = XGetImage (dpy, pixmap, 0, 0, width, height, ~0L, ZPixmap);
 311
 312   client_ximage = convert_ximage_to_rgba32 (screen, server_ximage);
 313
 314 # ifdef HAVE_XSHM_EXTENSION
 315   if (use_shm)
 316     destroy_xshm_image (dpy, server_ximage, &shm_info);
 317   else
 318 # endif /* HAVE_XSHM_EXTENSION */
 319     XDestroyImage (server_ximage);
 320
 321   return client_ximage;
 322 }
 323
 324
 325 # else /* ! REFORMAT_IMAGE_DATA */
 326
 327 typedef struct {
 328   unsigned int depth, red_mask, green_mask, blue_mask;  /* when this... */
 329   GLint type, format;                                   /* ...use this. */
 330 } conversion_table;
 331
 332 /* Abbreviate these so that the table entries all fit on one line...
 333  */
 334 #define BYTE               GL_UNSIGNED_BYTE
 335 #define BYTE_2_3_3_REV     GL_UNSIGNED_BYTE_2_3_3_REV
 336 #define BYTE_3_3_2         GL_UNSIGNED_BYTE_3_3_2
 337 #define INT_10_10_10_2     GL_UNSIGNED_INT_10_10_10_2
 338 #define INT_2_10_10_10_REV GL_UNSIGNED_INT_2_10_10_10_REV
 339 #define INT_8_8_8_8        GL_UNSIGNED_INT_8_8_8_8
 340 #define INT_8_8_8_8_REV    GL_UNSIGNED_INT_8_8_8_8_REV
 341 #define SHORT_1_5_5_5_REV  GL_UNSIGNED_SHORT_1_5_5_5_REV
 342 #define SHORT_4_4_4_4      GL_UNSIGNED_SHORT_4_4_4_4
 343 #define SHORT_4_4_4_4_REV  GL_UNSIGNED_SHORT_4_4_4_4_REV
 344 #define SHORT_5_5_5_1      GL_UNSIGNED_SHORT_5_5_5_1
 345 #define SHORT_5_6_5        GL_UNSIGNED_SHORT_5_6_5
 346 #define SHORT_5_6_5_REV    GL_UNSIGNED_SHORT_5_6_5_REV
 347
 348 static conversion_table ctable[] = {
 349   { 8,  0x000000E0, 0x0000001C, 0x00000003, BYTE_3_3_2,         GL_RGB      },
 350   { 8,  0x00000007, 0x00000038, 0x000000C0, BYTE_2_3_3_REV,     GL_RGB      },
 351   { 16, 0x0000F800, 0x000007E0, 0x0000001F, SHORT_5_6_5,        GL_RGB      },
 352   { 16, 0x0000001F, 0x000007E0, 0x0000F800, SHORT_5_6_5_REV,    GL_RGB      },
 353   { 16, 0x0000F000, 0x00000F00, 0x000000F0, SHORT_4_4_4_4,      GL_RGBA     },
 354   { 16, 0x000000F0, 0x00000F00, 0x0000F000, SHORT_4_4_4_4,      GL_BGRA     },
 355   { 16, 0x0000000F, 0x000000F0, 0x00000F00, SHORT_4_4_4_4,      GL_ABGR_EXT },
 356   { 16, 0x0000000F, 0x000000F0, 0x00000F00, SHORT_4_4_4_4_REV,  GL_RGBA     },
 357   { 16, 0x00000F00, 0x000000F0, 0x0000000F, SHORT_4_4_4_4_REV,  GL_BGRA     },
 358   { 16, 0x0000F800, 0x000007C0, 0x0000003E, SHORT_5_5_5_1,      GL_RGBA     },
 359   { 16, 0x0000003E, 0x000007C0, 0x0000F800, SHORT_5_5_5_1,      GL_BGRA     },
 360   { 16, 0x00000001, 0x0000003E, 0x000007C0, SHORT_5_5_5_1,      GL_ABGR_EXT },
 361   { 16, 0x0000001F, 0x000003E0, 0x00007C00, SHORT_1_5_5_5_REV,  GL_RGBA     },
 362   { 16, 0x00007C00, 0x000003E0, 0x0000001F, SHORT_1_5_5_5_REV,  GL_BGRA     },
 363   { 32, 0xFF000000, 0x00FF0000, 0x0000FF00, INT_8_8_8_8,        GL_RGBA     },
 364   { 32, 0x0000FF00, 0x00FF0000, 0xFF000000, INT_8_8_8_8,        GL_BGRA     },
 365   { 32, 0x000000FF, 0x0000FF00, 0x00FF0000, INT_8_8_8_8,        GL_ABGR_EXT },
 366   { 32, 0x000000FF, 0x0000FF00, 0x00FF0000, INT_8_8_8_8_REV,    GL_RGBA     },
 367   { 32, 0x00FF0000, 0x0000FF00, 0x000000FF, INT_8_8_8_8_REV,    GL_BGRA     },
 368   { 32, 0xFFC00000, 0x003FF000, 0x00000FFC, INT_10_10_10_2,     GL_RGBA     },
 369   { 32, 0x00000FFC, 0x003FF000, 0xFFC00000, INT_10_10_10_2,     GL_BGRA     },
 370   { 32, 0x00000003, 0x00000FFC, 0x003FF000, INT_10_10_10_2,     GL_ABGR_EXT },
 371   { 32, 0x000003FF, 0x000FFC00, 0x3FF00000, INT_2_10_10_10_REV, GL_RGBA     },
 372   { 32, 0x3FF00000, 0x000FFC00, 0x000003FF, INT_2_10_10_10_REV, GL_BGRA     },
 373   { 24, 0x000000FF, 0x0000FF00, 0x00FF0000, BYTE,               GL_RGB      },
 374   { 24, 0x00FF0000, 0x0000FF00, 0x000000FF, BYTE,               GL_BGR      },
 375 };
 376
 377
 378 /* Given an XImage, returns the GL settings to use its data as a texture.
 379  */
 380 static void
 381 gl_settings_for_ximage (XImage *image,
 382                         GLint *type_ret, GLint *format_ret, GLint *swap_ret)
 383 {
 384   int i;
 385   for (i = 0; i < countof(ctable); ++i)
 386     {
 387       if (image->bits_per_pixel == ctable[i].depth &&
 388           image->red_mask       == ctable[i].red_mask &&
 389           image->green_mask     == ctable[i].green_mask &&
 390           image->blue_mask      == ctable[i].blue_mask)
 391         {
 392           *type_ret   = ctable[i].type;
 393           *format_ret = ctable[i].format;
 394
 395           if (image->bits_per_pixel == 24)
 396             {
 397               /* don't know how to test this... */
 398               *type_ret = (ctable[i].type == GL_RGB) ? GL_BGR : GL_RGB;
 399               *swap_ret = 0;
 400             }
 401           else
 402             {
 403               *swap_ret = !!(image->byte_order == MSBFirst) ^ !!bigendian();
 404             }
 405
 406           if (debug_p)
 407             {
 408               fprintf (stderr, "%s: using %s %s %d for %d %08lX %08lX %08lX\n",
 409                        progname,
 410                        (*format_ret == GL_RGB      ? "RGB" :
 411                         *format_ret == GL_BGR      ? "BGR" :
 412                         *format_ret == GL_RGBA     ? "RGBA" :
 413                         *format_ret == GL_BGRA     ? "BGRA" :
 414                         *format_ret == GL_ABGR_EXT ? "ABGR_EXT" :
 415                         "???"),
 416                        (*type_ret == BYTE               ? "BYTE" :
 417                         *type_ret == BYTE_3_3_2         ? "BYTE_3_3_2" :
 418                         *type_ret == BYTE_2_3_3_REV     ? "BYTE_2_3_3_REV" :
 419                         *type_ret == INT_8_8_8_8        ? "INT_8_8_8_8" :
 420                         *type_ret == INT_8_8_8_8_REV    ? "INT_8_8_8_8_REV" :
 421                         *type_ret == INT_10_10_10_2     ? "INT_10_10_10_2" :
 422                         *type_ret == INT_2_10_10_10_REV ? "INT_2_10_10_10_REV":
 423                         *type_ret == SHORT_4_4_4_4      ? "SHORT_4_4_4_4" :
 424                         *type_ret == SHORT_4_4_4_4_REV  ? "SHORT_4_4_4_4_REV" :
 425                         *type_ret == SHORT_5_5_5_1      ? "SHORT_5_5_5_1" :
 426                         *type_ret == SHORT_1_5_5_5_REV  ? "SHORT_1_5_5_5_REV" :
 427                         *type_ret == SHORT_5_6_5        ? "SHORT_5_6_5" :
 428                         *type_ret == SHORT_5_6_5_REV    ? "SHORT_5_6_5_REV" :
 429                         "???"),
 430                        *swap_ret,
 431                        image->bits_per_pixel,
 432                        image->red_mask, image->green_mask, image->blue_mask);
 433             }
 434
 435           return;
 436         }
 437     }
 438
 439   /* Unknown RGB fields? */
 440   abort();
 441 }
 442
 443 #endif /* ! REFORMAT_IMAGE_DATA */
 444
 445 typedef struct {
 446   Pixmap pixmap;
 447   int pix_width, pix_height, pix_depth;
 448   int texid;
 449   Bool mipmap_p;
 450   double load_time;
 451
 452   /* Used in async mode
 453    */
 454   void (*callback) (const char *filename, XRectangle *geometry,
 455                     int iw, int ih, int tw, int th,
 456                     void *closure);
 457   void *closure;
 458
 459   /* Used in sync mode
 460    */
 461   char **filename_return;
 462   XRectangle *geometry_return;
 463   int *image_width_return;
 464   int *image_height_return;
 465   int *texture_width_return;
 466   int *texture_height_return;
 467
 468 } img_closure;
 469
 470
 471 /* Returns the current time in seconds as a double.
 472  */
 473 static double
 474 double_time (void)
 475 {
 476   struct timeval now;
 477 # ifdef GETTIMEOFDAY_TWO_ARGS
 478   struct timezone tzp;
 479   gettimeofday(&now, &tzp);
 480 # else
 481   gettimeofday(&now);
 482 # endif
 483
 484   return (now.tv_sec + ((double) now.tv_usec * 0.000001));
 485 }
 486
 487
 488 /* return the next larger power of 2. */
 489 static int
 490 to_pow2 (int i)
 491 {
 492   static unsigned int pow2[] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,
 493                                  2048, 4096, 8192, 16384, 32768, 65536 };
 494   int j;
 495   for (j = 0; j < countof(pow2); j++)
 496     if (pow2[j] >= i) return pow2[j];
 497   abort();  /* too big! */
 498 }
 499
 500
 501 /* Loads the given XImage into GL's texture memory.
 502    The image may be of any size.
 503    If mipmap_p is true, then make mipmaps instead of just a single texture.
 504    Writes to stderr and returns False on error.
 505  */
 506 static Bool
 507 ximage_to_texture (XImage *ximage,
 508                    GLint type, GLint format,
 509                    int *width_return,
 510                    int *height_return,
 511                    Bool mipmap_p)
 512 {
 513   int max_reduction = 7;
 514   int err_count = 0;
 515   GLenum err = 0;
 516   int orig_width = ximage->width;
 517   int orig_height = ximage->height;
 518   int tex_width = 0;
 519   int tex_height = 0;
 520
 521  AGAIN:
 522
 523   if (mipmap_p)
 524     {
 525       /* gluBuild2DMipmaps doesn't require textures to be a power of 2. */
 526       tex_width  = ximage->width;
 527       tex_height = ximage->height;
 528
 529       if (debug_p)
 530         fprintf (stderr, "%s: mipmap %d x %d\n",
 531                  progname, ximage->width, ximage->height);
 532
 533       gluBuild2DMipmaps (GL_TEXTURE_2D, 3, ximage->width, ximage->height,
 534                          format, type, ximage->data);
 535       err = glGetError();
 536     }
 537   else
 538     {
 539       /* glTexImage2D() requires the texture sizes to be powers of 2.
 540          So first, create a texture of that size (but don't write any
 541          data into it.)
 542        */
 543       tex_width  = to_pow2 (ximage->width);
 544       tex_height = to_pow2 (ximage->height);
 545
 546       if (debug_p)
 547         fprintf (stderr, "%s: texture %d x %d (%d x %d)\n",
 548                  progname, ximage->width, ximage->height,
 549                  tex_width, tex_height);
 550
 551       glTexImage2D (GL_TEXTURE_2D, 0, 3, tex_width, tex_height, 0,
 552                     format, type, 0);
 553       err = glGetError();
 554
 555       /* Now load our non-power-of-2 image data into the existing texture. */
 556       if (!err)
 557         {
 558           glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
 559                            ximage->width, ximage->height,
 560                            GL_RGBA, GL_UNSIGNED_BYTE, ximage->data);
 561           err = glGetError();
 562         }
 563     }
 564
 565   if (err)
 566     {
 567       char buf[100];
 568       const char *s = (char *) gluErrorString (err);
 569
 570       if (!s || !*s)
 571         {
 572           sprintf (buf, "unknown error %d", err);
 573           s = buf;
 574         }
 575
 576       while (glGetError() != GL_NO_ERROR)
 577         ;  /* clear any lingering errors */
 578
 579       if (++err_count > max_reduction)
 580         {
 581           fprintf (stderr,
 582                    "\n"
 583                    "%s: %dx%d texture failed, even after reducing to %dx%d:\n"
 584                    "%s: The error was: \"%s\".\n"
 585                    "%s: probably this means "
 586                    "\"your video card is worthless and weak\"?\n\n",
 587                    progname, orig_width, orig_height,
 588                    ximage->width, ximage->height,
 589                    progname, s,
 590                    progname);
 591           return False;
 592         }
 593       else
 594         {
 595           if (debug_p)
 596             fprintf (stderr, "%s: mipmap error (%dx%d): %s\n",
 597                      progname, ximage->width, ximage->height, s);
 598           halve_image (ximage);
 599           goto AGAIN;
 600         }
 601     }
 602
 603   if (width_return)  *width_return  = tex_width;
 604   if (height_return) *height_return = tex_height;
 605   return True;
 606 }
 607
 608
 609 static void screen_to_texture_async_cb (Screen *screen,
 610                                         Window window, Drawable drawable,
 611                                         const char *name, XRectangle *geometry,
 612                                         void *closure);
 613
 614
 615 /* Grabs an image of the desktop (or another random image file) and
 616    loads tht image into GL's texture memory.
 617    Writes to stderr and returns False on error.
 618  */
 619 Bool
 620 screen_to_texture (Screen *screen, Window window,
 621                    int desired_width, int desired_height,
 622                    Bool mipmap_p,
 623                    char **filename_return,
 624                    XRectangle *geometry_return,
 625                    int *image_width_return,
 626                    int *image_height_return,
 627                    int *texture_width_return,
 628                    int *texture_height_return)
 629 {
 630   Display *dpy = DisplayOfScreen (screen);
 631   img_closure *data = (img_closure *) calloc (1, sizeof(*data));
 632   XWindowAttributes xgwa;
 633   char *filename = 0;
 634   XRectangle geom = { 0, 0, 0, 0 };
 635   int wret;
 636
 637   if (! image_width_return)
 638     image_width_return = &wret;
 639
 640   if (debug_p)
 641     data->load_time = double_time();
 642
 643   data->texid     = -1;
 644   data->mipmap_p  = mipmap_p;
 645   data->filename_return       = filename_return;
 646   data->geometry_return       = geometry_return;
 647   data->image_width_return    = image_width_return;
 648   data->image_height_return   = image_height_return;
 649   data->texture_width_return  = texture_width_return;
 650   data->texture_height_return = texture_height_return;
 651
 652   XGetWindowAttributes (dpy, window, &xgwa);
 653   data->pix_width  = xgwa.width;
 654   data->pix_height = xgwa.height;
 655   data->pix_depth  = xgwa.depth;
 656
 657   if (desired_width  && desired_width  < xgwa.width)
 658     data->pix_width  = desired_width;
 659   if (desired_height && desired_height < xgwa.height)
 660     data->pix_height = desired_height;
 661
 662   data->pixmap = XCreatePixmap (dpy, window, data->pix_width, data->pix_height,
 663                                 data->pix_depth);
 664   load_random_image (screen, window, data->pixmap, &filename, &geom);
 665   screen_to_texture_async_cb (screen, window, data->pixmap, filename, &geom,
 666                               data);
 667
 668   return (*image_width_return != 0);
 669 }
 670
 671
 672 /* Like the above, but the image is loaded in a background process,
 673    and a callback is run when the loading is complete.
 674    When the callback is called, the image data will have been loaded
 675    into texture number `texid' (via glBindTexture.)
 676
 677    If an error occurred, width/height will be 0.
 678  */
 679 void
 680 screen_to_texture_async (Screen *screen, Window window,
 681                          int desired_width, int desired_height,
 682                          Bool mipmap_p,
 683                          GLuint texid,
 684                          void (*callback) (const char *filename,
 685                                            XRectangle *geometry,
 686                                            int image_width,
 687                                            int image_height,
 688                                            int texture_width,
 689                                            int texture_height,
 690                                            void *closure),
 691                          void *closure)
 692 {
 693   Display *dpy = DisplayOfScreen (screen);
 694   XWindowAttributes xgwa;
 695   img_closure *data = (img_closure *) calloc (1, sizeof(*data));
 696
 697   if (debug_p)
 698     data->load_time = double_time();
 699
 700   data->texid     = texid;
 701   data->mipmap_p  = mipmap_p;
 702   data->callback  = callback;
 703   data->closure   = closure;
 704
 705   XGetWindowAttributes (dpy, window, &xgwa);
 706   data->pix_width  = xgwa.width;
 707   data->pix_height = xgwa.height;
 708   data->pix_depth  = xgwa.depth;
 709
 710   if (desired_width  && desired_width  < xgwa.width)
 711     data->pix_width  = desired_width;
 712   if (desired_height && desired_height < xgwa.height)
 713     data->pix_height = desired_height;
 714
 715   data->pixmap = XCreatePixmap (dpy, window, data->pix_width, data->pix_height,
 716                                 data->pix_depth);
 717   fork_load_random_image (screen, window, data->pixmap,
 718                           screen_to_texture_async_cb, data);
 719 }
 720
 721
 722 /* Once we have an XImage, this loads it into GL.
 723    This is used in both synchronous and asynchronous mode.
 724  */
 725 static void
 726 screen_to_texture_async_cb (Screen *screen, Window window, Drawable drawable,
 727                             const char *name, XRectangle *geometry,
 728                             void *closure)
 729 {
 730   Display *dpy = DisplayOfScreen (screen);
 731   Bool ok;
 732   XImage *ximage;
 733   GLint type, format;
 734   int iw=0, ih=0, tw=0, th=0;
 735   double cvt_time=0, tex_time=0, done_time=0;
 736   img_closure *data = (img_closure *) closure;
 737   /* copy closure data to stack and free the original before running cb */
 738   img_closure dd = *data;
 739   memset (data, 0, sizeof (*data));
 740   free (data);
 741   data = 0;
 742
 743   if (geometry->width <= 0 || geometry->height <= 0)
 744     {
 745       /* This can happen if an old version of xscreensaver-getimage
 746          is installed. */
 747       geometry->x = 0;
 748       geometry->y = 0;
 749       geometry->width  = dd.pix_width;
 750       geometry->height = dd.pix_height;
 751     }
 752
 753   if (geometry->width <= 0 || geometry->height <= 0)
 754     abort();
 755
 756   if (debug_p)
 757     cvt_time = double_time();
 758
 759 # ifdef REFORMAT_IMAGE_DATA
 760   ximage = pixmap_to_gl_ximage (screen, window, dd.pixmap);
 761   format = GL_RGBA;
 762   type = GL_UNSIGNED_BYTE;
 763
 764 #else /* ! REFORMAT_IMAGE_DATA */
 765   {
 766     Visual *visual = DefaultVisualOfScreen (screen);
 767     GLint swap;
 768
 769     ximage = XCreateImage (dpy, visual, dd.pix_depth, ZPixmap, 0, 0,
 770                            dd.pix_width, dd.pix_height, 32, 0);
 771
 772     /* Note: height+2 in "to" to be to work around an array bounds overrun
 773        in gluBuild2DMipmaps / gluScaleImage. */
 774     ximage->data = (char *) calloc (ximage->height+2, ximage->bytes_per_line);
 775
 776     if (!ximage->data ||
 777         !XGetSubImage (dpy, dd.pixmap, 0, 0, ximage->width, ximage->height,
 778                        ~0L, ximage->format, ximage, 0, 0))
 779       {
 780         XDestroyImage (ximage);
 781         ximage = 0;
 782       }
 783
 784     gl_settings_for_ximage (ximage, &type, &format, &swap);
 785     glPixelStorei (GL_UNPACK_SWAP_BYTES, !swap);
 786   }
 787 #endif /* REFORMAT_IMAGE_DATA */
 788
 789   XFreePixmap (dpy, dd.pixmap);
 790   dd.pixmap = 0;
 791
 792   if (debug_p)
 793     tex_time = double_time();
 794
 795   if (! ximage)
 796     ok = False;
 797   else
 798     {
 799       iw = ximage->width;
 800       ih = ximage->height;
 801       if (dd.texid != -1)
 802         glBindTexture (GL_TEXTURE_2D, dd.texid);
 803
 804       glPixelStorei (GL_UNPACK_ALIGNMENT, ximage->bitmap_pad / 8);
 805       ok = ximage_to_texture (ximage, type, format, &tw, &th, dd.mipmap_p);
 806     }
 807
 808   if (ximage) XDestroyImage (ximage);
 809
 810   if (! ok)
 811     iw = ih = tw = th = 0;
 812
 813   if (debug_p)
 814     done_time = double_time();
 815
 816   if (debug_p)
 817     fprintf (stderr,
 818              /* prints: A + B + C = D
 819                 A = file I/O time (happens in background)
 820                 B = time to pull bits from server (this process)
 821                 C = time to convert bits to GL textures (this process)
 822                 D = total elapsed time from "want image" to "see image"
 823
 824                 B+C is responsible for any frame-rate glitches.
 825               */
 826              "%s: loading elapsed: %.2f + %.2f + %.2f = %.2f sec\n",
 827              progname,
 828              cvt_time  - dd.load_time,
 829              tex_time  - cvt_time,
 830              done_time - tex_time,
 831              done_time - dd.load_time);
 832
 833   if (dd.callback)
 834     /* asynchronous mode */
 835     dd.callback (name, geometry, iw, ih, tw, th, dd.closure);
 836   else
 837     {
 838       /* synchronous mode */
 839       if (dd.filename_return)       *dd.filename_return       = (char *) name;
 840       if (dd.geometry_return)       *dd.geometry_return       = *geometry;
 841       if (dd.image_width_return)    *dd.image_width_return    = iw;
 842       if (dd.image_height_return)   *dd.image_height_return   = ih;
 843       if (dd.texture_width_return)  *dd.texture_width_return  = tw;
 844       if (dd.texture_height_return) *dd.texture_height_return = th;
 845     }
 846 }