From http://www.jwz.org/xscreensaver/xscreensaver-5.30.tar.gz
[xscreensaver] / hacks / memscroller.c
1 /* xscreensaver, Copyright (c) 2002-2014 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  * Memscroller -- scrolls a dump of its own RAM across the screen.
12  */
13
14 #include "screenhack.h"
15 #include <stdio.h>
16
17 #ifdef HAVE_XSHM_EXTENSION
18 #include "xshm.h"
19 #endif
20
21 #undef countof
22 #define countof(x) (sizeof(x)/sizeof(*(x)))
23
24 #ifndef USE_IPHONE
25 # define READ_FILES
26 #endif
27
28 typedef struct {
29   int which;
30   XRectangle rect;
31   XImage *image;
32   int rez;
33   int speed;
34   int scroll_tick;
35   unsigned int value;
36   unsigned char *data;
37   int count_zero;
38 } scroller;
39
40 typedef struct {
41   Display *dpy;
42   Window window;
43   XWindowAttributes xgwa;
44   GC draw_gc, erase_gc, text_gc;
45   XFontStruct *fonts[6];
46   int border;
47
48   enum { SEED_RAM, SEED_RANDOM, SEED_FILE } seed_mode;
49   enum { DRAW_COLOR, DRAW_MONO } draw_mode;
50
51   char *filename;
52   FILE *in;
53
54   int nscrollers;
55   scroller *scrollers;
56
57 # ifdef HAVE_XSHM_EXTENSION
58   Bool shm_p;
59   XShmSegmentInfo shm_info;
60 # endif
61
62   int delay;
63
64 } state;
65
66
67 static void reshape_memscroller (state *st);
68
69
70 static void *
71 memscroller_init (Display *dpy, Window window)
72 {
73   int i;
74   XGCValues gcv;
75   state *st = (state *) calloc (1, sizeof (*st));
76   char *s;
77   st->dpy = dpy;
78   st->window = window;
79   st->delay = get_integer_resource (dpy, "delay", "Integer");
80
81   XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
82
83   /* Fill up the colormap with random colors.
84      We don't actually use these explicitly, but in 8-bit mode,
85      they will be used implicitly by the random image bits. */
86   {
87     int ncolors = 255;
88     XColor colors[256];
89     make_random_colormap (st->xgwa.screen, st->xgwa.visual, st->xgwa.colormap,
90                           colors, &ncolors, True, True, 0, False);
91   }
92
93   st->border = get_integer_resource (dpy, "borderSize", "BorderSize");
94
95   {
96     int i;
97     int nfonts = countof (st->fonts);
98     for (i = nfonts-1; i >= 0; i--)
99       {
100         char *fontname;
101         char res[20];
102         sprintf (res, "font%d", i+1);
103         fontname = get_string_resource (dpy, res, "Font");
104         /* Each resource can be a comma-separated list of font names.
105            We use the first one that exists. */
106         if (fontname && *fontname) 
107           {
108             char *f2 = strdup(fontname);
109             char *f, *token = f2;
110             while ((f = strtok(token, ",")) && !st->fonts[i])
111               {
112                 token = 0;
113                 while (*f == ' ' || *f == '\t') f++;
114                 st->fonts[i] = XLoadQueryFont (dpy, f);
115               }
116             free (f2);
117             if (!st->fonts[i] && i < nfonts-1)
118               {
119                 fprintf (stderr, "%s: unable to load font: \"%s\"\n",
120                          progname, fontname);
121                 st->fonts[i] = st->fonts[i+1];
122               }
123           }
124       }
125
126     if (!st->fonts[0])
127       st->fonts[0] = XLoadQueryFont (dpy, "fixed");
128
129     if (!st->fonts[0])
130       {
131         fprintf (stderr, "%s: unable to load any fonts!", progname);
132         exit (1);
133       }
134   }
135
136   gcv.line_width = st->border;
137
138   gcv.background = get_pixel_resource(st->dpy, st->xgwa.colormap,
139                                       "background", "Background");
140   gcv.foreground = get_pixel_resource(st->dpy, st->xgwa.colormap,
141                                       "textColor", "Foreground");
142   st->text_gc = XCreateGC (st->dpy, st->window,
143                            GCForeground|GCBackground, &gcv);
144
145   gcv.foreground = get_pixel_resource(st->dpy, st->xgwa.colormap,
146                                       "foreground", "Foreground");
147   st->draw_gc = XCreateGC (st->dpy, st->window,
148                            GCForeground|GCBackground|GCLineWidth,
149                            &gcv);
150   gcv.foreground = gcv.background;
151   st->erase_gc = XCreateGC (st->dpy, st->window,
152                             GCForeground|GCBackground, &gcv);
153
154
155   s = get_string_resource (dpy, "drawMode", "DrawMode");
156   if (!s || !*s || !strcasecmp (s, "color"))
157     st->draw_mode = DRAW_COLOR;
158   else if (!strcasecmp (s, "mono"))
159     st->draw_mode = DRAW_MONO;
160   else
161     {
162       fprintf (stderr, "%s: drawMode must be 'mono' or 'color', not '%s'\n",
163                progname, s);
164       exit (1);
165     }
166   if (s) free (s);
167   s = 0;
168
169
170 # ifdef READ_FILES
171   st->filename = get_string_resource (dpy, "filename", "Filename");
172 # endif
173
174   if (!st->filename ||
175       !*st->filename ||
176       !strcasecmp (st->filename, "(ram)") ||
177       !strcasecmp (st->filename, "(mem)") ||
178       !strcasecmp (st->filename, "(memory)"))
179     st->seed_mode = SEED_RAM;
180 # ifdef READ_FILES
181   else if (st->filename &&
182            (!strcasecmp (st->filename, "(rand)") ||
183             !strcasecmp (st->filename, "(random)")))
184     st->seed_mode = SEED_RANDOM;
185   else
186     st->seed_mode = SEED_FILE;
187 # else
188   st->seed_mode = SEED_RANDOM;
189 # endif
190
191   st->nscrollers = 3;
192   st->scrollers = (scroller *) calloc (st->nscrollers, sizeof(scroller));
193
194   for (i = 0; i < st->nscrollers; i++)
195     {
196       scroller *sc = &st->scrollers[i];
197       int max_height = 4096;
198
199       sc->which = i;
200       sc->speed = i+1;
201
202       sc->image = 0;
203 # ifdef HAVE_XSHM_EXTENSION
204       st->shm_p = get_boolean_resource (dpy, "useSHM", "Boolean");
205       if (st->shm_p)
206         {
207           sc->image = create_xshm_image (st->dpy, st->xgwa.visual,
208                                          st->xgwa.depth,
209                                          ZPixmap, 0, &st->shm_info,
210                                          1, max_height);
211           if (! sc->image)
212             st->shm_p = False;
213         }
214 # endif /* HAVE_XSHM_EXTENSION */
215
216       if (!sc->image)
217         sc->image = XCreateImage (st->dpy, st->xgwa.visual, st->xgwa.depth,
218                                   ZPixmap, 0, 0, 1, max_height, 8, 0);
219
220       if (sc->image && !sc->image->data)
221         sc->image->data = (char *)
222           malloc (sc->image->bytes_per_line * sc->image->height + 1);
223
224       if (!sc->image || !sc->image->data)
225         {
226           fprintf (stderr, "%s: out of memory (allocating 1x%d image)\n",
227                    progname, sc->image->height);
228           exit (1);
229         }
230     }
231
232   reshape_memscroller (st);
233   return st;
234 }
235
236
237 static void
238 reshape_memscroller (state *st)
239 {
240   int i;
241
242   XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
243
244   for (i = 0; i < st->nscrollers; i++)
245     {
246       scroller *sc = &st->scrollers[i];
247
248       if (i == 0)
249         {
250           sc->rez = 6;  /* #### */
251
252           sc->rect.width  = (((int) (st->xgwa.width * 0.8)
253                               / sc->rez) * sc->rez);
254           sc->rect.height = (((int) (st->xgwa.height * 0.3)
255                               / sc->rez) * sc->rez);
256
257           sc->rect.x = (st->xgwa.width  - sc->rect.width)  / 2;
258           sc->rect.y = (st->xgwa.height - sc->rect.height) / 2;
259         }
260       else
261         {
262           scroller *sc0 = &st->scrollers[i-1];
263           sc->rez = sc0->rez * 1.8;
264
265           sc->rect.x      = sc0->rect.x;
266           sc->rect.y      = (sc0->rect.y + sc0->rect.height + st->border
267                              + (st->border + 2) * 7);
268           sc->rect.width  = sc0->rect.width;
269           sc->rect.height = (((int) (st->xgwa.height * 0.1)
270                               / sc->rez) * sc->rez);
271         }
272
273       XDrawRectangle (st->dpy, st->window, st->draw_gc,
274                       sc->rect.x - st->border*2,
275                       sc->rect.y - st->border*2,
276                       sc->rect.width  + st->border*4,
277                       sc->rect.height + st->border*4);
278     }
279 }
280
281
282
283 # ifdef READ_FILES
284 static void
285 open_file (state *st)
286 {
287   if (st->in)
288     {
289       fclose (st->in);
290       st->in = 0;
291     }
292
293   st->in = fopen (st->filename, "r");
294   if (!st->in)
295     {
296       char buf[1024];
297       sprintf (buf, "%s: %s", progname, st->filename);
298       perror (buf);
299       exit (1);
300     }
301 }
302 #endif
303
304
305 static unsigned int
306 more_bits (state *st, scroller *sc)
307 {
308   static unsigned char *lomem = 0;
309   static unsigned char *himem = 0;
310   unsigned char r, g, b;
311
312   /* vv: Each incoming byte rolls through all 4 bytes of this (it is sc->value)
313          This is the number displayed at the top.
314      pv: the pixel color value.  incoming bytes land in R,G,B, or maybe just G.
315    */
316   unsigned int vv, pv;
317
318   unsigned int rmsk = st->scrollers[0].image->red_mask;
319   unsigned int gmsk = st->scrollers[0].image->green_mask;
320   unsigned int bmsk = st->scrollers[0].image->blue_mask;
321   unsigned int amsk = ~(rmsk | gmsk | bmsk);
322
323   vv = sc->value;
324
325   /* Pack RGB into a pixel according to the XImage component masks;
326      set the remaining bits to 1 for the benefit of HAVE_COCOA alpha.
327    */
328 # undef PACK
329 # define PACK() ((((r << 24) | (r << 16) | (r << 8) | r) & rmsk) | \
330                  (((g << 24) | (g << 16) | (g << 8) | g) & gmsk) | \
331                  (((b << 24) | (b << 16) | (b << 8) | b) & bmsk) | \
332                  amsk)
333
334   switch (st->seed_mode)
335     {
336     case SEED_RAM:
337       if (himem == 0)
338         {
339           lomem = (unsigned char *) progname; /* not first malloc, but early */
340           himem = (unsigned char *)           /* not last malloc, but late */
341             st->scrollers[st->nscrollers-1].image->data;
342         }
343
344       if (sc->data < lomem)
345         sc->data = lomem;
346
347 # ifdef HAVE_SBRK  /* re-get it each time through */
348       /* "The brk and sbrk functions are historical curiosities left over
349          from earlier days before the advent of virtual memory management."
350             -- sbrk(2) man page on MacOS
351        */
352 #  if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)) /* gcc >= 4.2 */
353 #   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
354 #  endif
355       himem = ((unsigned char *) sbrk(0)) - (2 * sizeof(void *));
356 # endif
357
358       if (!lomem || !himem) 
359         {
360           /* bad craziness! give up! */
361           st->seed_mode = SEED_RANDOM;
362           return 0;
363         }
364
365       /* I don't understand what's going on there, but on MacOS X, we're
366          getting insane values for lomem and himem (both Xlib and HAVE_COCOA).
367          Does malloc() draw from more than one heap? */
368       if ((unsigned long) himem - (unsigned long) lomem > 0x0FFFFFFF) {
369 # if 0
370         fprintf (stderr, "%s: wonky: 0x%08x - 0x%08x = 0x%08x\n", progname,
371                  (unsigned int) himem,  (unsigned int) lomem,
372                  (unsigned int) himem - (unsigned int) lomem);
373 # endif
374         himem = lomem + 0xFFFF;
375       }
376
377       if (lomem >= himem) abort();
378
379     RETRY:
380       if (sc->data >= himem)
381         sc->data = lomem;
382
383       switch (st->draw_mode)
384         {
385         case DRAW_COLOR:
386           r = *sc->data++;
387           g = *sc->data++;
388           b = *sc->data++;
389           vv = (vv << 24) | (r << 16) | (g << 8) | b;
390           break;
391         case DRAW_MONO:
392           r = 0;
393           g = *sc->data++;
394           b = 0;
395           vv = (vv << 8) | g;
396           break;
397         default:
398           abort();
399         }
400
401       pv = PACK();
402
403       /* avoid having many seconds of blackness: truncate zeros at 24K.
404        */
405       if (vv == 0)
406         sc->count_zero++;
407       else
408         sc->count_zero = 0;
409       if (sc->count_zero > 1024 * (st->draw_mode == DRAW_COLOR ? 24 : 8))
410         goto RETRY;
411
412       break;
413
414     case SEED_RANDOM:
415       vv = random();
416       switch (st->draw_mode)
417         {
418         case DRAW_COLOR:
419           r = (vv >> 16) & 0xFF;
420           g = (vv >>  8) & 0xFF;
421           b = (vv      ) & 0xFF;
422           break;
423         case DRAW_MONO:
424           r = 0;
425           g = vv & 0xFF;
426           b = 0;
427           break;
428         default:
429           abort();
430         }
431       pv = PACK();
432       break;
433
434 # ifdef READ_FILES
435     case SEED_FILE:
436       {
437         int i;
438
439   /* this one returns only bytes from the file */
440 # define GETC(V) \
441             do { \
442               i = fgetc (st->in); \
443             } while (i == EOF \
444                      ? (open_file (st), 1) \
445                      : 0); \
446             V = i
447
448   /* this one returns a null at EOF -- else we hang on zero-length files */
449 # undef GETC
450 # define GETC(V) \
451             i = fgetc (st->in); \
452             if (i == EOF) { i = 0; open_file (st); } \
453             V = i
454
455         if (!st->in)
456           open_file (st);
457
458         switch (st->draw_mode)
459           {
460           case DRAW_COLOR:
461             GETC(r);
462             GETC(g);
463             GETC(b);
464             vv = (vv << 24) | (r << 16) | (g << 8) | b;
465             break;
466           case DRAW_MONO:
467             r = 0;
468             GETC(g);
469             b = 0;
470             vv = (vv << 8) | g;
471             break;
472           default:
473             abort();
474           }
475 # undef GETC
476         pv = PACK();
477       }
478       break;
479 # endif /* READ_FILES */
480
481     default:
482       abort();
483     }
484
485 # undef PACK
486
487   sc->value = vv;
488   return pv;
489 }
490
491
492 static void
493 draw_string (state *st)
494 {
495   char buf[40];
496   int direction, ascent, descent;
497   int bot = st->scrollers[0].rect.y;
498   const char *fmt = "%08X";
499   int i;
500
501   /* Draw the first font that fits.
502    */
503   for (i = 0; i < countof (st->fonts); i++)
504     {
505       XCharStruct overall;
506       int x, y, w, h;
507
508       if (! st->fonts[i]) continue;
509
510       sprintf (buf, fmt, 0);
511       XTextExtents (st->fonts[i], buf, strlen(buf), 
512                     &direction, &ascent, &descent, &overall);
513       sprintf (buf, "%08X", st->scrollers[0].value);
514
515       w = overall.width;
516       h = ascent + descent + 1;
517       x = (st->xgwa.width - w) / 2;
518       y = (bot - h) / 2;
519
520       if (y + h + 10 <= bot && x > -10)
521         {
522           XSetFont (st->dpy, st->text_gc, st->fonts[i]->fid);
523           XFillRectangle (st->dpy, st->window, st->erase_gc,
524                           x-w, y, w*3, h);
525           XDrawString (st->dpy, st->window, st->text_gc,
526                        x, y + ascent, buf, strlen(buf));
527           break;
528         }
529     }
530 }
531
532
533 static unsigned long
534 memscroller_draw (Display *dpy, Window window, void *closure)
535 {
536   state *st = (state *) closure;
537   int i;
538   draw_string (st);
539
540   for (i = 0; i < st->nscrollers; i++)
541     {
542       scroller *sc = &st->scrollers[i];
543       int j;
544
545       XCopyArea (st->dpy, st->window, st->window, st->draw_gc,
546                  sc->rect.x + sc->speed, sc->rect.y,
547                  sc->rect.width - sc->speed, sc->rect.height,
548                  sc->rect.x, sc->rect.y);
549
550       if (sc->scroll_tick == 0)
551         {
552           int top = ((sc->image->bytes_per_line * sc->rect.height) /
553                      (4 * sc->rez));
554           unsigned int *out = (unsigned int *) sc->image->data;
555           for (j = 0; j < top; j++)
556             {
557               unsigned int v = more_bits(st, sc);
558               int k;
559               for (k = 0; k < sc->rez; k++)
560                 *out++ = v;
561             }
562         }
563
564       sc->scroll_tick++;
565       if (sc->scroll_tick * sc->speed >= sc->rez)
566         sc->scroll_tick = 0;
567
568       for (j = 0; j < sc->speed; j++)
569         {
570 # ifdef HAVE_XSHM_EXTENSION
571           if (st->shm_p)
572             XShmPutImage (st->dpy, st->window, st->draw_gc, sc->image,
573                           0, 0,
574                           sc->rect.x + sc->rect.width - sc->image->width - j,
575                           sc->rect.y,
576                           sc->rect.width, sc->rect.height,
577                           False);
578           else
579 # endif /* HAVE_XSHM_EXTENSION */
580             XPutImage (st->dpy, st->window, st->draw_gc, sc->image,
581                        0, 0,
582                        sc->rect.x + sc->rect.width - sc->image->width - j,
583                        sc->rect.y,
584                        sc->rect.width, sc->rect.height);
585         }
586     }
587
588   return st->delay;
589 }
590
591
592 static void
593 memscroller_reshape (Display *dpy, Window window, void *closure, 
594                  unsigned int w, unsigned int h)
595 {
596   state *st = (state *) closure;
597   XClearWindow (st->dpy, st->window);
598   reshape_memscroller (st);
599 }
600
601 static Bool
602 memscroller_event (Display *dpy, Window window, void *closure, XEvent *event)
603 {
604   return False;
605 }
606
607
608 static void
609 memscroller_free (Display *dpy, Window window, void *closure)
610 {
611 }
612
613
614 static const char *memscroller_defaults [] = {
615   ".background:            black",
616   "*drawMode:              color",
617   "*fpsSolid:              true",
618   "*fpsTop:                true",
619   "*filename:              (RAM)",
620   ".textColor:             #00FF00",
621   ".foreground:            #00FF00",
622   "*borderSize:            2",
623
624 #if defined(HAVE_COCOA) && !defined(USE_IPHONE)
625   ".font1:                 OCR A Std 192, Lucida Console 192, Monaco 192",
626   ".font2:                 OCR A Std 144, Lucida Console 144, Monaco 144",
627   ".font3:                 OCR A Std 128, Lucida Console 128, Monaco 128",
628   ".font4:                 OCR A Std 96,  Lucida Console 96,  Monaco 96",
629   ".font5:                 OCR A Std 48,  Lucida Console 48,  Monaco 48",
630   ".font6:                 OCR A Std 24,  Lucida Console 24,  Monaco 24",
631 #else  /* !HAVE_COCOA */
632   ".font1:                 -*-courier-bold-r-*-*-*-1440-*-*-m-*-*-*",
633   ".font2:                 -*-courier-bold-r-*-*-*-960-*-*-m-*-*-*",
634   ".font3:                 -*-courier-bold-r-*-*-*-480-*-*-m-*-*-*",
635   ".font4:                 -*-courier-bold-r-*-*-*-320-*-*-m-*-*-*",
636   ".font5:                 -*-courier-bold-r-*-*-*-180-*-*-m-*-*-*",
637   ".font6:                 fixed",
638 #endif /* !HAVE_COCOA */
639
640   "*delay:                 10000",
641   "*offset:                0",
642   0
643 };
644
645 static XrmOptionDescRec memscroller_options [] = {
646   { "-delay",           ".delay",               XrmoptionSepArg, 0 },
647   { "-font",            ".font",                XrmoptionSepArg, 0 },
648   { "-filename",        ".filename",            XrmoptionSepArg, 0 },
649   { "-color",           ".drawMode",            XrmoptionNoArg, "color"    },
650   { "-mono",            ".drawMode",            XrmoptionNoArg, "mono"     },
651   { "-ram",             ".filename",            XrmoptionNoArg, "(RAM)"    },
652   { "-random",          ".filename",            XrmoptionNoArg, "(RANDOM)" },
653   { 0, 0, 0, 0 }
654 };
655
656 XSCREENSAVER_MODULE ("MemScroller", memscroller)