--- /dev/null
+/* glitchpeg, Copyright (c) 2018 Jamie Zawinski <jwz@jwz.org>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation. No representations are made about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * Insert errors into an image file, then display the corrupted result.
+ *
+ * This only works on X11 and MacOS because iOS and Android don't have
+ * access to the source files of images, only the decoded image data.
+ */
+
+#include "screenhack.h"
+#include "ximage-loader.h"
+
+#ifndef HAVE_JWXYZ
+# include <X11/Intrinsic.h> /* for XtInputId, etc */
+#endif
+
+#include <sys/stat.h>
+
+#undef countof
+#define countof(x) (sizeof((x))/sizeof((*x)))
+
+struct state {
+ Display *dpy;
+ Window window;
+ GC gc;
+ XWindowAttributes xgwa;
+ int delay;
+ int count;
+ int duration;
+ time_t start_time;
+ unsigned char *image_data; unsigned long image_size;
+ XtInputId pipe_id;
+ FILE *pipe;
+ Bool button_down_p;
+};
+
+
+static Bool
+bigendian (void)
+{
+ union { int i; char c[sizeof(int)]; } u;
+ u.i = 1;
+ return !u.c[0];
+}
+
+
+/* Given a bitmask, returns the position and width of the field.
+ Duplicated from ximage-loader.c.
+ */
+static void
+decode_mask (unsigned long mask, unsigned long *pos_ret,
+ unsigned long *size_ret)
+{
+ int i;
+ for (i = 0; i < 32; i++)
+ if (mask & (1L << i))
+ {
+ int j = 0;
+ *pos_ret = i;
+ for (; i < 32; i++, j++)
+ if (! (mask & (1L << i)))
+ break;
+ *size_ret = j;
+ return;
+ }
+}
+
+
+/* Renders a scaled, cropped version of the RGBA XImage onto the window.
+ */
+static void
+draw_image (Display *dpy, Window window, Visual *v, GC gc,
+ int w, int h, int depth, XImage *in)
+{
+ XImage *out;
+ int x, y, w2, h2, xoff, yoff;
+ double xs, ys, s;
+
+ unsigned long crpos=0, cgpos=0, cbpos=0, capos=0; /* bitfield positions */
+ unsigned long srpos=0, sgpos=0, sbpos=0;
+ unsigned long srmsk=0, sgmsk=0, sbmsk=0;
+ unsigned long srsiz=0, sgsiz=0, sbsiz=0;
+
+# ifdef HAVE_JWXYZ
+ // BlackPixel has alpha: 0xFF000000.
+ unsigned long black = BlackPixelOfScreen (DefaultScreenOfDisplay (dpy));
+#else
+ unsigned long black = 0;
+# endif
+
+ xs = in->width / (double) w;
+ ys = in->height / (double) h;
+ s = (xs > ys ? ys : xs);
+ w2 = in->width / s;
+ h2 = in->height / s;
+ xoff = (w - w2) / 2;
+ yoff = (h - h2) / 2;
+
+ /* Create a new image in the depth and bit-order of the server. */
+ out = XCreateImage (dpy, v, depth, ZPixmap, 0, 0, w, h, 8, 0);
+ out->bitmap_bit_order = in->bitmap_bit_order;
+ out->byte_order = in->byte_order;
+
+ out->bitmap_bit_order = BitmapBitOrder (dpy);
+ out->byte_order = ImageByteOrder (dpy);
+
+ out->data = (char *) malloc (out->height * out->bytes_per_line);
+ if (!out->data) abort();
+
+ /* Find the server's color masks.
+ We could cache this and just do it once, but it's a small number
+ of instructions compared to the per-pixel operations happening next.
+ */
+ srmsk = out->red_mask;
+ sgmsk = out->green_mask;
+ sbmsk = out->blue_mask;
+
+ if (!(srmsk && sgmsk && sbmsk)) abort(); /* No server color masks? */
+
+ decode_mask (srmsk, &srpos, &srsiz);
+ decode_mask (sgmsk, &sgpos, &sgsiz);
+ decode_mask (sbmsk, &sbpos, &sbsiz);
+
+ /* 'in' is RGBA in client endianness. Convert to what the server wants. */
+ if (bigendian())
+ crpos = 24, cgpos = 16, cbpos = 8, capos = 0;
+ else
+ crpos = 0, cgpos = 8, cbpos = 16, capos = 24;
+
+ /* Iterate the destination rectangle and pull in the corresponding
+ scaled and cropped source pixel, or black. Nearest-neighbor is fine.
+ */
+ for (y = 0; y < out->height; y++)
+ {
+ int iy = (out->height - y - yoff - 1) * s;
+ for (x = 0; x < out->width; x++)
+ {
+ int ix = (x - xoff) * s;
+ unsigned long p = (ix >= 0 && ix < in->width &&
+ iy >= 0 && iy < in->height
+ ? XGetPixel (in, ix, iy)
+ : black);
+ /* unsigned char a = (p >> capos) & 0xFF; */
+ unsigned char b = (p >> cbpos) & 0xFF;
+ unsigned char g = (p >> cgpos) & 0xFF;
+ unsigned char r = (p >> crpos) & 0xFF;
+ XPutPixel (out, x, y, ((r << srpos) |
+ (g << sgpos) |
+ (b << sbpos) |
+ black));
+ }
+ }
+
+ XPutImage (dpy, window, gc, out, 0, 0, 0, 0, out->width, out->height);
+ XDestroyImage (out);
+}
+
+
+# define BACKSLASH(c) \
+ (! ((c >= 'a' && c <= 'z') || \
+ (c >= 'A' && c <= 'Z') || \
+ (c >= '0' && c <= '9') || \
+ c == '.' || c == '_' || c == '-' || c == '+' || c == '/'))
+
+/* Gets the name of an image file to load by running xscreensaver-getimage-file
+ at the end of a pipe. This can be very slow!
+ Duplicated from utils/grabclient.c
+ */
+static FILE *
+open_image_name_pipe (void)
+{
+ char *s;
+
+ /* /bin/sh on OS X 10.10 wipes out the PATH. */
+ const char *path = getenv("PATH");
+ char *cmd = s = malloc (strlen(path) * 2 + 100);
+ strcpy (s, "/bin/sh -c 'export PATH=");
+ s += strlen (s);
+ while (*path) {
+ char c = *path++;
+ if (BACKSLASH(c)) *s++ = '\\';
+ *s++ = c;
+ }
+ strcpy (s, "; ");
+ s += strlen (s);
+
+ strcpy (s, "xscreensaver-getimage-file --name --absolute");
+ s += strlen (s);
+
+ strcpy (s, "'");
+ s += strlen (s);
+
+ *s = 0;
+
+ FILE *pipe = popen (cmd, "r");
+ free (cmd);
+ return pipe;
+}
+
+
+/* Duplicated from utils/grabclient.c */
+static void
+xscreensaver_getimage_file_cb (XtPointer closure, int *source, XtInputId *id)
+{
+ /* This is not called from a signal handler, so doing stuff here is fine.
+ */
+ struct state *st = (struct state *) closure;
+ char buf[10240];
+ char *file = buf;
+ FILE *fp;
+ struct stat stat;
+ int n;
+ unsigned char *s;
+ int L;
+
+ *buf = 0;
+ fgets (buf, sizeof(buf)-1, st->pipe);
+ pclose (st->pipe);
+ st->pipe = 0;
+ XtRemoveInput (st->pipe_id);
+ st->pipe_id = 0;
+
+ /* strip trailing newline */
+ L = strlen(buf);
+ while (L > 0 && (buf[L-1] == '\r' || buf[L-1] == '\n'))
+ buf[--L] = 0;
+
+ fp = fopen (file, "r");
+ if (! fp)
+ {
+ fprintf (stderr, "%s: unable to read %s\n", progname, file);
+ return;
+ }
+
+ if (fstat (fileno (fp), &stat))
+ {
+ fprintf (stderr, "%s: %s: stat failed\n", progname, file);
+ return;
+ }
+
+ if (st->image_data) free (st->image_data);
+ st->image_size = stat.st_size;
+ st->image_data = malloc (st->image_size);
+
+ s = st->image_data;
+ do {
+ n = fread (s, 1, st->image_data + st->image_size - s, fp);
+ if (n > 0) s += n;
+ } while (n > 0);
+
+ fclose (fp);
+
+ /* fprintf (stderr, "loaded %s (%lu)\n", file, st->image_size); */
+
+ st->start_time = time((time_t *) 0);
+}
+
+
+static void *
+glitchpeg_init (Display *dpy, Window window)
+{
+ struct state *st = (struct state *) calloc (1, sizeof(*st));
+ XGCValues gcv;
+
+ st->dpy = dpy;
+ st->window = window;
+ st->gc = XCreateGC (dpy, window, 0, &gcv);
+
+ XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
+
+ st->delay = get_integer_resource (st->dpy, "delay", "Integer");
+ if (st->delay < 1) st->delay = 1;
+
+ st->duration = get_integer_resource (st->dpy, "duration", "Integer");
+ if (st->duration < 0) st->duration = 0;
+
+ st->count = get_integer_resource (st->dpy, "count", "Integer");
+ if (st->count < 1) st->count = 1;
+
+ XClearWindow (st->dpy, st->window);
+
+ return st;
+}
+
+
+static unsigned long
+glitchpeg_draw (Display *dpy, Window window, void *closure)
+{
+ struct state *st = (struct state *) closure;
+
+ if ((!st->image_data ||
+ time((time_t *) 0) >= st->start_time + st->duration) &&
+ !st->pipe)
+ {
+ /* Time to reload */
+ st->pipe = open_image_name_pipe();
+ st->pipe_id =
+ XtAppAddInput (XtDisplayToApplicationContext (dpy),
+ fileno (st->pipe),
+ (XtPointer) (XtInputReadMask | XtInputExceptMask),
+ xscreensaver_getimage_file_cb, (XtPointer) st);
+ }
+
+ if (st->image_data && !st->button_down_p)
+ {
+ int n;
+ XImage *image;
+ unsigned char *glitched = malloc (st->image_size);
+ int nn = random() % st->count;
+ if (nn <= 0) nn = 1;
+
+ memcpy (glitched, st->image_data, st->image_size);
+
+ for (n = 0; n < nn; n++)
+ {
+ int start = 255;
+ int end = st->image_size - 255;
+ int size = end - start;
+ Bool byte_p = True; /* random() % 100; */
+ if (size <= 100) break;
+ if (byte_p)
+ {
+ int i = start + (random() % size);
+ if (!(random() % 10))
+ /* Take one random byte and randomize it. */
+ glitched[i] = random() % 0xFF;
+ else
+ /* Take one random byte and add 5% to it. */
+ glitched[i] +=
+ (1 + (random() % 0x0C)) * ((random() & 1) ? 1 : -1);
+ }
+ else
+ {
+ /* Take two randomly-sized chunks of the file and swap them.
+ This tends to just destroy the image. Doesn't look good. */
+ int s2 = 2 + size * 0.05;
+ char *swap = malloc (s2);
+ int start1 = start + (random() % (size - s2));
+ int start2 = start + (random() % (size - s2));
+ memcpy (glitched + start1, swap, s2);
+ memmove (glitched + start2, glitched + start1, s2);
+ memcpy (swap, glitched + start2, s2);
+ free (swap);
+ }
+ }
+
+ image = image_data_to_ximage (dpy, st->xgwa.visual,
+ glitched, st->image_size);
+ free (glitched);
+
+ if (image) /* Might be null if decode fails */
+ {
+ draw_image (dpy, window, st->xgwa.visual, st->gc,
+ st->xgwa.width, st->xgwa.height, st->xgwa.depth,
+ image);
+ XDestroyImage (image);
+ }
+ }
+
+ return st->delay;
+}
+
+
+static void
+glitchpeg_reshape (Display *dpy, Window window, void *closure,
+ unsigned int w, unsigned int h)
+{
+ struct state *st = (struct state *) closure;
+ XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
+}
+
+
+static Bool
+glitchpeg_event (Display *dpy, Window window, void *closure, XEvent *event)
+{
+ struct state *st = (struct state *) closure;
+ if (event->xany.type == ButtonPress)
+ {
+ st->button_down_p = True;
+ return True;
+ }
+ else if (event->xany.type == ButtonRelease)
+ {
+ st->button_down_p = False;
+ return True;
+ }
+ else if (screenhack_event_helper (dpy, window, event))
+ {
+ st->start_time = 0; /* reload */
+ return True;
+ }
+
+ return False;
+}
+
+
+static void
+glitchpeg_free (Display *dpy, Window window, void *closure)
+{
+ struct state *st = (struct state *) closure;
+ XFreeGC (dpy, st->gc);
+ if (st->pipe_id) XtRemoveInput (st->pipe_id);
+ if (st->pipe) fclose (st->pipe);
+ if (st->image_data) free (st->image_data);
+ free (st);
+}
+
+
+static const char *glitchpeg_defaults [] = {
+ ".background: black",
+ ".foreground: white",
+ ".lowrez: True",
+ "*fpsSolid: true",
+ "*delay: 30000",
+ "*duration: 120",
+ "*count: 100",
+ "*grabDesktopImages: False", /* HAVE_JWXYZ */
+ "*chooseRandomImages: True", /* HAVE_JWXYZ */
+#ifdef HAVE_MOBILE
+ "*ignoreRotation: True",
+ "*rotateImages: True",
+#endif
+ 0
+};
+
+static XrmOptionDescRec glitchpeg_options [] = {
+ { "-delay", ".delay", XrmoptionSepArg, 0 },
+ { "-duration", ".duration", XrmoptionSepArg, 0 },
+ { "-count", ".count", XrmoptionSepArg, 0 },
+ { 0, 0, 0, 0 }
+};
+
+XSCREENSAVER_MODULE ("GlitchPEG", glitchpeg)
projects / xscreensaver / blobdiff