/* xscreensaver, Copyright (c) 2008-2015 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.
*
* Draws repetitive patterns that should undo burned in LCD screens.
* Concept shamelessly cloned from
* http://toastycode.com/blog/2008/02/05/lcd-scrub/
*/
#include "screenhack.h"
#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))
struct state {
Display *dpy;
Window window;
XWindowAttributes xgwa;
enum { HORIZ_W, HORIZ_B,
VERT_W, VERT_B,
DIAG_W, DIAG_B,
WHITE, BLACK,
RGB,
RANDOM,
END } mode;
unsigned int enabled_mask;
int count;
GC fg, bg, bg2;
int color_tick;
int delay;
int spread;
int cycles;
XImage *collisions;
long ncollisions;
};
static void
pick_mode (struct state *st)
{
st->count = 0;
while (1)
{
if (++st->mode == END)
st->mode = 0;
if (st->enabled_mask & (1 << st->mode))
break;
}
}
static void *
lcdscrub_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
unsigned long fgp, bgp;
st->dpy = dpy;
st->window = window;
st->delay = get_integer_resource (st->dpy, "delay", "Integer");
st->spread = get_integer_resource (st->dpy, "spread", "Integer");
st->cycles = get_integer_resource (st->dpy, "cycles", "Integer");
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
fgp = get_pixel_resource (st->dpy, st->xgwa.colormap,
"foreground", "Foreground");
bgp = get_pixel_resource (st->dpy, st->xgwa.colormap,
"background", "Background");
gcv.foreground = bgp;
gcv.background = fgp;
st->bg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
st->bg2 = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
gcv.foreground = fgp;
gcv.background = bgp;
st->fg = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
#ifdef HAVE_JWXYZ
jwxyz_XSetAntiAliasing (st->dpy, st->fg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg, False);
jwxyz_XSetAntiAliasing (st->dpy, st->bg2, False);
#endif
st->enabled_mask = 0;
# define PREF(R,F) \
if (get_boolean_resource (st->dpy, R, "Mode")) st->enabled_mask |= (1 << F)
PREF("modeHW", HORIZ_W);
PREF("modeHB", HORIZ_B);
PREF("modeVW", VERT_W);
PREF("modeVB", VERT_B);
PREF("modeDW", DIAG_W);
PREF("modeDB", DIAG_B);
PREF("modeW", WHITE);
PREF("modeB", BLACK);
PREF("modeRGB", RGB);
PREF("modeRandom", RANDOM);
# undef PREF
if (! st->enabled_mask)
{
fprintf (stderr, "%s: no modes enabled\n", progname);
exit (1);
}
pick_mode (st);
return st;
}
/* A test harness for visualizing different random number generators.
This doesn't really belong in lcdscrub, but it was a convenient
place to put it.
*/
#if 0 /* mwc1616 */
static unsigned long mwc1616_x = 1;
static unsigned long mwc1616_y = 2;
static void
mwc1616_srand (unsigned long seed)
{
mwc1616_x = seed | 1;
mwc1616_y = seed | 2;
}
static unsigned long
mwc1616 (void)
{
mwc1616_x = 18000 * (mwc1616_x & 0xFFFF) + (mwc1616_x >> 16);
mwc1616_y = 30903 * (mwc1616_y & 0xFFFF) + (mwc1616_y >> 16);
return (mwc1616_x << 16) + (mwc1616_y & 0xFFFF);
}
# undef random
# undef srand
# define srand mwc1616_srand
# define random() ((unsigned int) (mwc1616() & (unsigned int) (~0)))
#elif 0 /* xorshift128plus */
static uint64_t xo_state0 = 1;
static uint64_t xo_state1 = 2;
static void
xorshift128plus_srand (unsigned long seed)
{
xo_state0 = seed | 1;
xo_state1 = seed | 2;
}
static uint64_t
xorshift128plus (void)
{
register uint64_t s1 = xo_state0;
register uint64_t s0 = xo_state1;
xo_state0 = s0;
s1 ^= s1 << 23;
s1 ^= s1 >> 17;
s1 ^= s0;
s1 ^= s0 >> 26;
xo_state1 = s1;
return s1;
}
# undef random
# undef srand
# define srand xorshift128plus_srand
# define random() ((unsigned int) (xorshift128plus() & (unsigned int) (~0)))
#else /* ya_random */
# undef srand
# define srand(n)
#endif /* ya_random */
/* If you see patterns in this image, the PRNG sucks.
*/
static void
lcdscrub_random (struct state *st)
{
unsigned long steps_per_frame = 3000000;
unsigned long segments = 0x8000; /* 2^15 */
if (! st->collisions)
{
struct timeval tp;
# if GETTIMEOFDAY_TWO_ARGS
gettimeofday (&tp, 0);
# else
gettimeofday (&tp);
# endif
srand ((unsigned int) (tp.tv_sec ^ tp.tv_usec));
st->collisions =
XCreateImage (st->dpy, st->xgwa.visual, 1, XYPixmap,
0, NULL, segments, segments, 8, 0);
if (! st->collisions) abort();
st->collisions->data = (char *)
calloc (segments, st->collisions->bytes_per_line); /* 128 MB */
if (! st->collisions->data) abort();
}
while (--steps_per_frame)
{
unsigned long x = random() & (segments-1);
unsigned long y = random() & (segments-1);
unsigned long p = XGetPixel (st->collisions, x, y) ? 0 : 1;
XPutPixel (st->collisions, x, y, p);
st->ncollisions += (p ? 1 : -1);
}
{
int w, h;
Pixmap p;
GC gc;
XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
w = st->xgwa.width;
h = st->xgwa.height;
p = XCreatePixmap (st->dpy, st->window, w, h, 1);
gc = XCreateGC (st->dpy, p, 0, 0);
XSetBackground (st->dpy, gc, 0);
XSetForeground (st->dpy, gc, 1);
XPutImage (st->dpy, p, gc, st->collisions, 0, 0, 0, 0, w, h);
XFreeGC (st->dpy, gc);
gc = st->fg;
XClearWindow (st->dpy, st->window);
XSetClipMask (st->dpy, gc, p);
XFillRectangle (st->dpy, st->window, gc, 0, 0, w, h);
XFreePixmap (st->dpy, p);
}
/*
fprintf(stderr, "%.2f\n", st->ncollisions / (float) (segments*segments));
*/
}
static unsigned long
lcdscrub_draw (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
int count = st->count % st->spread;
int i;
GC fg = (st->mode & 1 ? st->fg : st->bg);
GC bg = (st->mode & 1 ? st->bg : st->fg);
switch (st->mode) {
case HORIZ_W:
case HORIZ_B:
XFillRectangle (st->dpy, st->window, bg, 0, 0,
st->xgwa.width, st->xgwa.height);
for (i = count; i < st->xgwa.height; i += st->spread)
XDrawLine (st->dpy, st->window, fg, 0, i, st->xgwa.width, i);
break;
case VERT_W:
case VERT_B:
XFillRectangle (st->dpy, st->window, bg, 0, 0,
st->xgwa.width, st->xgwa.height);
for (i = count; i < st->xgwa.width; i += st->spread)
XDrawLine (st->dpy, st->window, fg, i, 0, i, st->xgwa.height);
break;
case DIAG_W:
case DIAG_B:
XFillRectangle (st->dpy, st->window, bg, 0, 0,
st->xgwa.width, st->xgwa.height);
for (i = count; i < st->xgwa.width; i += st->spread)
XDrawLine (st->dpy, st->window, fg, i, 0,
i + st->xgwa.width, st->xgwa.width);
for (i = -count; i < st->xgwa.height; i += st->spread)
XDrawLine (st->dpy, st->window, fg, 0, i,
st->xgwa.height, i + st->xgwa.height);
break;
case RGB:
{
int scale = 10 * 8; /* 8 sec */
static const unsigned short colors[][3] = {
{ 0xFFFF, 0x0000, 0x0000 },
{ 0x0000, 0xFFFF, 0x0000 },
{ 0x0000, 0x0000, 0xFFFF },
{ 0xFFFF, 0xFFFF, 0x0000 },
{ 0xFFFF, 0x0000, 0xFFFF },
{ 0x0000, 0xFFFF, 0xFFFF },
{ 0xFFFF, 0xFFFF, 0xFFFF },
{ 0x0000, 0x0000, 0x0000 },
};
static unsigned long last = 0;
XColor xc;
bg = st->bg2;
xc.red = colors[st->color_tick / scale][0];
xc.green = colors[st->color_tick / scale][1];
xc.blue = colors[st->color_tick / scale][2];
if (last) XFreeColors (st->dpy, st->xgwa.colormap, &last, 1, 0);
XAllocColor (st->dpy, st->xgwa.colormap, &xc);
last = xc.pixel;
XSetForeground (st->dpy, bg, xc.pixel);
st->color_tick = (st->color_tick + 1) % (countof(colors) * scale);
/* fall through */
}
case WHITE:
case BLACK:
XFillRectangle (st->dpy, st->window, bg, 0, 0,
st->xgwa.width, st->xgwa.height);
break;
case RANDOM:
lcdscrub_random (st);
break;
default:
abort();
break;
}
st->count++;
if (st->count > st->spread * st->cycles)
pick_mode (st);
return st->delay;
}
static void
lcdscrub_reshape (Display *dpy, Window window, void *closure,
unsigned int w, unsigned int h)
{
}
static Bool
lcdscrub_event (Display *dpy, Window window, void *closure, XEvent *event)
{
return False;
}
static void
lcdscrub_free (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
XFreeGC (dpy, st->fg);
XFreeGC (dpy, st->bg);
XFreeGC (dpy, st->bg2);
if (st->collisions)
{
free (st->collisions->data);
st->collisions->data = 0;
XDestroyImage (st->collisions);
}
free (st);
}
static const char *lcdscrub_defaults [] = {
".background: black",
".foreground: white",
"*fpsSolid: True",
"*delay: 100000",
"*spread: 8",
"*cycles: 60",
"*modeHW: True",
"*modeHB: True",
"*modeVW: True",
"*modeVB: True",
"*modeDW: True",
"*modeDB: True",
"*modeW: True",
"*modeB: True",
"*modeRGB: True",
"*modeRandom: False",
0
};
static XrmOptionDescRec lcdscrub_options [] = {
{ "-delay", ".delay", XrmoptionSepArg, 0 },
{ "-spread", ".spread", XrmoptionSepArg, 0 },
{ "-cycles", ".cycles", XrmoptionSepArg, 0 },
{ "-no-hw", ".modeHW", XrmoptionNoArg, "False" },
{ "-no-hb", ".modeHB", XrmoptionNoArg, "False" },
{ "-no-vw", ".modeVW", XrmoptionNoArg, "False" },
{ "-no-vb", ".modeVB", XrmoptionNoArg, "False" },
{ "-no-dw", ".modeDW", XrmoptionNoArg, "False" },
{ "-no-db", ".modeDB", XrmoptionNoArg, "False" },
{ "-no-w", ".modeW", XrmoptionNoArg, "False" },
{ "-no-b", ".modeB", XrmoptionNoArg, "False" },
{ "-no-rgb", ".modeRGB", XrmoptionNoArg, "False" },
{ "-random", ".modeRandom", XrmoptionNoArg, "True" },
{ 0, 0, 0, 0 }
};
XSCREENSAVER_MODULE ("LCDscrub", lcdscrub)
