git.hungrycats.org Git - xscreensaver/blob - hacks/blitspin.c

   1 /* xscreensaver, Copyright (c) 1992-2008 Jamie Zawinski <jwz@jwz.org>
   2  *
   3  * Permission to use, copy, modify, distribute, and sell this software and its
   4  * documentation for any purpose is hereby granted without fee, provided that
   5  * the above copyright notice appear in all copies and that both that
   6  * copyright notice and this permission notice appear in supporting
   7  * documentation.  No representations are made about the suitability of this
   8  * software for any purpose.  It is provided "as is" without express or
   9  * implied warranty.
  10  */
  11
  12 /* Rotate a bitmap using using bitblts.
  13    The bitmap must be square, and must be a power of 2 in size.
  14    This was translated from SmallTalk code which appeared in the
  15    August 1981 issue of Byte magazine.
  16
  17    The input bitmap may be non-square, it is padded and centered
  18    with the background color.  Another way would be to subdivide
  19    the bitmap into square components and rotate them independently
  20    (and preferably in parallel), but I don't think that would be as
  21    interesting looking.
  22
  23    It's too bad almost nothing uses blitter hardware these days,
  24    or this might actually win.
  25  */
  26
  27 #include "screenhack.h"
  28 #include "xpm-pixmap.h"
  29 #include <stdio.h>
  30
  31 #include "images/som.xbm"
  32
  33 /* Implementing this using XCopyArea doesn't work with color images on OSX.
  34    This means that the Cocoa implementation of XCopyArea in jwxyz.m is
  35    broken with the GXor, GXand, and/or the GXxor GC operations.  This
  36    probably means that (e.g.) "kCGBlendModeDarken" is not close enough
  37    to being "GXand" to use for that.  (It works with monochrome images,
  38    just not color ones).
  39
  40    So, on OSX, we implement the blitter by hand.  It is correct, but
  41    orders of magnitude slower.
  42  */
  43 #ifndef HAVE_COCOA
  44 # define USE_XCOPYAREA
  45 #endif
  46
  47 struct state {
  48   Display *dpy;
  49   Window window;
  50   XWindowAttributes xgwa;
  51   int width, height, size;
  52   Bool scale_up;
  53   Pixmap self, temp, mask;
  54 # ifdef USE_XCOPYAREA
  55   GC gc_set, gc_clear, gc_copy, gc_and, gc_or, gc_xor;
  56 # endif
  57   GC gc;
  58   int delay, delay2;
  59   int duration;
  60   Pixmap bitmap;
  61   unsigned int fg, bg;
  62
  63   int qwad; /* fuckin' C, man... who needs namespaces? */
  64   int first_time;
  65   int last_w, last_h;
  66
  67   time_t start_time;
  68   Bool loaded_p;
  69   Bool load_ext_p;
  70   async_load_state *img_loader;
  71 };
  72
  73 static void display (struct state *, Pixmap);
  74 static void blitspin_init_2 (struct state *);
  75
  76 #define copy_to(from, xoff, yoff, to, op)                               \
  77   bitblt (st, st->from, st->to, op, 0, 0,                               \
  78           st->size-(xoff), st->size-(yoff), (xoff), (yoff))
  79
  80 #define copy_from(to, xoff, yoff, from, op)                             \
  81   bitblt (st, st->from, st->to, op, (xoff), (yoff),                     \
  82           st->size-(xoff), st->size-(yoff), 0, 0)
  83
  84
  85 #ifdef USE_XCOPYAREA
  86 # define bitblt(st, from, to, op, src_x, src_y, w, h, dst_x, dst_y)     \
  87          XCopyArea((st)->dpy, (from), (to), (st)->gc_##op,              \
  88                    (src_x), (src_y), (w), (h), (dst_x), (dst_y))
  89 #else /* !USE_XCOPYAREA */
  90
  91 # define bitblt(st, from, to, op, src_x, src_y, w, h, dst_x, dst_y)     \
  92          do_bitblt((st)->dpy, (from), (to), st->gc, GX##op,             \
  93                    (src_x), (src_y), (w), (h), (dst_x), (dst_y))
  94
  95 static void
  96 do_bitblt (Display *dpy, Drawable src, Drawable dst, GC gc, int op,
  97            int src_x, int src_y,
  98            unsigned int width, unsigned int height,
  99            int dst_x, int dst_y)
 100 {
 101   if (op == GXclear)
 102     {
 103       XSetForeground (dpy, gc, 0xFF000000);  /* ARGB black for Cocoa */
 104       XFillRectangle (dpy, dst, gc, dst_x, dst_y, width, height);
 105     }
 106   else if (op == GXset)
 107     {
 108       XSetForeground (dpy, gc, ~0L);
 109       XFillRectangle (dpy, dst, gc, dst_x, dst_y, width, height);
 110     }
 111   else if (op == GXcopy)
 112     {
 113       XCopyArea (dpy, src, dst, gc, src_x, src_y, width, height, dst_x, dst_y);
 114     }
 115   else
 116     {
 117       XImage *srci = XGetImage (dpy, src, src_x, src_y, width, height,
 118                                 ~0L, ZPixmap);
 119       XImage *dsti = XGetImage (dpy, dst, dst_x, dst_y, width, height,
 120                                 ~0L, ZPixmap);
 121       unsigned long *out = (unsigned long *) dsti->data;
 122       unsigned long *in  = (unsigned long *) srci->data;
 123       unsigned long *end = (in + (height * srci->bytes_per_line
 124                                   / sizeof(unsigned long)));
 125       switch (op)
 126         {
 127         case GXor:  while (in < end) { *out++ |= *in++; } break;
 128         case GXand: while (in < end) { *out++ &= *in++; } break;
 129         case GXxor: while (in < end) { *out++ ^= *in++; } break;
 130         default: abort();
 131         }
 132       XPutImage (dpy, dst, gc, dsti, 0, 0, dst_x, dst_y, width, height);
 133       XDestroyImage (srci);
 134       XDestroyImage (dsti);
 135     }
 136 }
 137
 138 #endif /* !USE_XCOPYAREA */
 139
 140
 141
 142 static unsigned long
 143 blitspin_draw (Display *dpy, Window window, void *closure)
 144 {
 145   struct state *st = (struct state *) closure;
 146   int this_delay = st->delay;
 147   int qwad;
 148
 149   if (st->img_loader)   /* still loading */
 150     {
 151       st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
 152
 153       if (!st->img_loader) { /* just finished */
 154         st->first_time = 0;
 155         st->loaded_p = True;
 156         st->qwad = -1;
 157         st->start_time = time ((time_t) 0);
 158         blitspin_init_2 (st);
 159       }
 160
 161       /* Rotate nothing if the very first image is not yet loaded */
 162       if (! st->loaded_p)
 163         return this_delay;
 164     }
 165
 166   if (!st->img_loader &&
 167       st->load_ext_p &&
 168       st->start_time + st->duration < time ((time_t) 0)) {
 169     /* Start a new image loading, but keep rotating the old image
 170        until the new one arrives. */
 171     st->img_loader = load_image_async_simple (0, st->xgwa.screen, st->window,
 172                                               st->bitmap, 0, 0);
 173   }
 174
 175   if (st->qwad == -1)
 176     {
 177       bitblt(st, st->mask, st->mask, clear,0,0, st->size,    st->size,    0,0);
 178       bitblt(st, st->mask, st->mask, set,  0,0, st->size>>1, st->size>>1, 0,0);
 179       st->qwad = st->size>>1;
 180     }
 181
 182   if (st->first_time)
 183     {
 184       st->first_time = 0;
 185       display (st, st->self);
 186       return st->delay2;
 187     }
 188
 189   /* for (st->qwad = st->size>>1; st->qwad > 0; st->qwad>>=1) */
 190
 191   qwad = st->qwad;
 192
 193   copy_to   (mask, 0,       0,       temp, copy);   /* 1 */
 194   copy_to   (mask, 0,       qwad,    temp, or);     /* 2 */
 195   copy_to   (self, 0,       0,       temp, and);    /* 3 */
 196   copy_to   (temp, 0,       0,       self, xor);    /* 4 */
 197   copy_from (temp, qwad,    0,       self, xor);    /* 5 */
 198   copy_from (self, qwad,    0,       self, or);     /* 6 */
 199   copy_to   (temp, qwad,    0,       self, xor);    /* 7 */
 200   copy_to   (self, 0,       0,       temp, copy);   /* 8 */
 201   copy_from (temp, qwad,    qwad,    self, xor);    /* 9 */
 202   copy_to   (mask, 0,       0,       temp, and);    /* A */
 203   copy_to   (temp, 0,       0,       self, xor);    /* B */
 204   copy_to   (temp, qwad,    qwad,    self, xor);    /* C */
 205   copy_from (mask, qwad>>1, qwad>>1, mask, and);    /* D */
 206   copy_to   (mask, qwad,    0,       mask, or);     /* E */
 207   copy_to   (mask, 0,       qwad,    mask, or);     /* F */
 208   display   (st, st->self);
 209
 210   st->qwad >>= 1;
 211   if (st->qwad == 0)  /* done with this round */
 212     {
 213       st->qwad = -1;
 214       this_delay = st->delay2;
 215     }
 216
 217   return this_delay;
 218 }
 219
 220
 221 static int
 222 to_pow2(struct state *st, int n, Bool up)
 223 {
 224   int powers_of_2[] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,
 225                         2048, 4096, 8192, 16384, 32768, 65536 };
 226   int i = 0;
 227   if (n > 65536) st->size = 65536;
 228   while (n >= powers_of_2[i]) i++;
 229   if (n == powers_of_2[i-1])
 230     return n;
 231   else
 232     return powers_of_2[up ? i : i-1];
 233 }
 234
 235 static void *
 236 blitspin_init (Display *d_arg, Window w_arg)
 237 {
 238   struct state *st = (struct state *) calloc (1, sizeof(*st));
 239   char *bitmap_name;
 240
 241   st->dpy = d_arg;
 242   st->window = w_arg;
 243
 244   XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
 245
 246   st->fg = get_pixel_resource (st->dpy, st->xgwa.colormap,
 247                                "foreground", "Foreground");
 248   st->bg = get_pixel_resource (st->dpy, st->xgwa.colormap,
 249                                "background", "Background");
 250   st->delay = get_integer_resource (st->dpy, "delay", "Integer");
 251   st->delay2 = get_integer_resource (st->dpy, "delay2", "Integer");
 252   st->duration = get_integer_resource (st->dpy, "duration", "Seconds");
 253   if (st->delay < 0) st->delay = 0;
 254   if (st->delay2 < 0) st->delay2 = 0;
 255   if (st->duration < 1) st->duration = 1;
 256
 257   st->start_time = time ((time_t) 0);
 258
 259   bitmap_name = get_string_resource (st->dpy, "bitmap", "Bitmap");
 260   if (! bitmap_name || !*bitmap_name)
 261     bitmap_name = "(default)";
 262
 263   if (!strcasecmp (bitmap_name, "(default)") ||
 264       !strcasecmp (bitmap_name, "default"))
 265     bitmap_name = "(screen)";
 266
 267   if (!strcasecmp (bitmap_name, "(builtin)") ||
 268       !strcasecmp (bitmap_name, "builtin"))
 269     {
 270       st->width = som_width;
 271       st->height = som_height;
 272       st->bitmap = XCreatePixmapFromBitmapData (st->dpy, st->window,
 273                                                 (char *) som_bits,
 274                                                 st->width, st->height,
 275                                                 st->fg, st->bg,
 276                                                 st->xgwa.depth);
 277       st->scale_up = True; /* definitely. */
 278       st->loaded_p = True;
 279       blitspin_init_2 (st);
 280     }
 281   else if (!strcasecmp (bitmap_name, "(screen)") ||
 282            !strcasecmp (bitmap_name, "screen"))
 283     {
 284       st->bitmap = XCreatePixmap (st->dpy, st->window,
 285                                   st->xgwa.width, st->xgwa.height,
 286                                   st->xgwa.depth);
 287       st->width = st->xgwa.width;
 288       st->height = st->xgwa.height;
 289       st->scale_up = True; /* maybe? */
 290       st->load_ext_p = True;
 291       st->img_loader = load_image_async_simple (0, st->xgwa.screen, st->window,
 292                                             st->bitmap, 0, 0);
 293     }
 294   else
 295     {
 296       st->bitmap = xpm_file_to_pixmap (st->dpy, st->window, bitmap_name,
 297                                    &st->width, &st->height, 0);
 298       st->scale_up = True; /* probably? */
 299     }
 300
 301   return st;
 302 }
 303
 304
 305 static void
 306 blitspin_init_2 (struct state *st)
 307 {
 308   XGCValues gcv;
 309
 310   /* make it square */
 311   st->size = (st->width < st->height) ? st->height : st->width;
 312   st->size = to_pow2(st, st->size, st->scale_up); /* round up to power of 2 */
 313   {                                             /* don't exceed screen size */
 314     int s = XScreenNumberOfScreen(st->xgwa.screen);
 315     int w = to_pow2(st, XDisplayWidth(st->dpy, s), False);
 316     int h = to_pow2(st, XDisplayHeight(st->dpy, s), False);
 317     if (st->size > w) st->size = w;
 318     if (st->size > h) st->size = h;
 319   }
 320
 321   if (st->self) XFreePixmap (st->dpy, st->self);
 322   if (st->temp) XFreePixmap (st->dpy, st->temp);
 323   if (st->mask) XFreePixmap (st->dpy, st->mask);
 324
 325   st->self = XCreatePixmap (st->dpy, st->window, st->size, st->size,
 326                             st->xgwa.depth);
 327   st->temp = XCreatePixmap (st->dpy, st->window, st->size, st->size,
 328                             st->xgwa.depth);
 329   st->mask = XCreatePixmap (st->dpy, st->window, st->size, st->size,
 330                             st->xgwa.depth);
 331   gcv.foreground = (st->xgwa.depth == 1 ? 1 : (~0));
 332
 333 # ifdef USE_XCOPYAREA
 334 #  define make_gc(op) \
 335     gcv.function=GX##op; \
 336     if (st->gc_##op) XFreeGC (st->dpy, st->gc_##op); \
 337     st->gc_##op = XCreateGC (st->dpy, st->self, GCFunction|GCForeground, &gcv)
 338   make_gc(set);
 339   make_gc(clear);
 340   make_gc(copy);
 341   make_gc(and);
 342   make_gc(or);
 343   make_gc(xor);
 344 # endif /* USE_XCOPYAREA */
 345
 346   gcv.foreground = gcv.background = st->bg;
 347   if (st->gc) XFreeGC (st->dpy, st->gc);
 348   st->gc = XCreateGC (st->dpy, st->window, GCForeground|GCBackground, &gcv);
 349   /* Clear st->self to the background color (not to 0, which 'clear' does.) */
 350   XFillRectangle (st->dpy, st->self, st->gc, 0, 0, st->size, st->size);
 351   XSetForeground (st->dpy, st->gc, st->fg);
 352
 353   XCopyArea (st->dpy, st->bitmap, st->self, st->gc, 0, 0,
 354              st->width, st->height,
 355              (st->size - st->width)  >> 1,
 356              (st->size - st->height) >> 1);
 357
 358   st->qwad = -1;
 359   st->first_time = 1;
 360 }
 361
 362 static void
 363 display (struct state *st, Pixmap pixmap)
 364 {
 365   XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
 366
 367   if (st->xgwa.width != st->last_w ||
 368       st->xgwa.height != st->last_h)
 369     {
 370       XClearWindow (st->dpy, st->window);
 371       st->last_w = st->xgwa.width;
 372       st->last_h = st->xgwa.height;
 373     }
 374   if (st->xgwa.depth != 1)
 375     XCopyArea (st->dpy, pixmap, st->window, st->gc, 0, 0, st->size, st->size,
 376                (st->xgwa.width - st->size) >> 1,
 377                (st->xgwa.height - st->size) >> 1);
 378   else
 379     XCopyPlane (st->dpy, pixmap, st->window, st->gc, 0, 0, st->size, st->size,
 380                 (st->xgwa.width - st->size) >> 1,
 381                 (st->xgwa.height - st->size) >> 1,
 382                 1);
 383 /*
 384   XDrawRectangle (st->dpy, st->window, st->gc,
 385                   ((st->xgwa.width - st->size) >> 1) - 1,
 386                   ((st->xgwa.height - st->size) >> 1) - 1,
 387                   st->size+2, st->size+2);
 388 */
 389 }
 390
 391 static void
 392 blitspin_reshape (Display *dpy, Window window, void *closure,
 393                   unsigned int w, unsigned int h)
 394 {
 395 }
 396
 397 static Bool
 398 blitspin_event (Display *dpy, Window window, void *closure, XEvent *event)
 399 {
 400   return False;
 401 }
 402
 403 static void
 404 blitspin_free (Display *dpy, Window window, void *closure)
 405 {
 406 }
 407
 408 \f
 409 static const char *blitspin_defaults [] = {
 410   ".background: black",
 411   ".foreground: white",
 412   ".fpsSolid:   true",
 413   "*delay:      500000",
 414   "*delay2:     500000",
 415   "*duration:   120",
 416   "*bitmap:     (default)",
 417   "*geometry:   512x512",
 418   0
 419 };
 420
 421 static XrmOptionDescRec blitspin_options [] = {
 422   { "-delay",           ".delay",       XrmoptionSepArg, 0 },
 423   { "-delay2",          ".delay2",      XrmoptionSepArg, 0 },
 424   { "-duration",        ".duration",    XrmoptionSepArg, 0 },
 425   { "-bitmap",          ".bitmap",      XrmoptionSepArg, 0 },
 426   { 0, 0, 0, 0 }
 427 };
 428
 429
 430 XSCREENSAVER_MODULE ("BlitSpin", blitspin)