• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*---------------------------------------------------------------------------
2 
3    rpng - simple PNG display program                               rpng-x.c
4 
5    This program decodes and displays PNG images, with gamma correction and
6    optionally with a user-specified background color (in case the image has
7    transparency).  It is very nearly the most basic PNG viewer possible.
8    This version is for the X Window System (tested by author under Unix and
9    by Martin Zinser under OpenVMS; may work under OS/2 with some tweaking).
10 
11    to do:
12     - 8-bit (colormapped) X support
13     - use %.1023s to simplify truncation of title-bar string?
14 
15   ---------------------------------------------------------------------------
16 
17    Changelog:
18     - 1.01:  initial public release
19     - 1.02:  modified to allow abbreviated options; fixed long/ulong mis-
20               match; switched to png_jmpbuf() macro
21     - 1.10:  added support for non-default visuals; fixed X pixel-conversion
22     - 1.11:  added extra set of parentheses to png_jmpbuf() macro; fixed
23               command-line parsing bug
24     - 1.12:  fixed some small X memory leaks (thanks to Fran�ois Petitjean)
25     - 1.13:  fixed XFreeGC() crash bug (thanks to Patrick Welche)
26     - 1.14:  added support for X resources (thanks to Gerhard Niklasch)
27     - 2.00:  dual-licensed (added GNU GPL)
28     - 2.01:  fixed improper display of usage screen on PNG error(s)
29     - 2.02:  Added "void(argc);" statement to quiet pedantic compiler warnings
30              about unused variable (GR-P)
31 
32   ---------------------------------------------------------------------------
33 
34       Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
35 
36       This software is provided "as is," without warranty of any kind,
37       express or implied.  In no event shall the author or contributors
38       be held liable for any damages arising in any way from the use of
39       this software.
40 
41       The contents of this file are DUAL-LICENSED.  You may modify and/or
42       redistribute this software according to the terms of one of the
43       following two licenses (at your option):
44 
45 
46       LICENSE 1 ("BSD-like with advertising clause"):
47 
48       Permission is granted to anyone to use this software for any purpose,
49       including commercial applications, and to alter it and redistribute
50       it freely, subject to the following restrictions:
51 
52       1. Redistributions of source code must retain the above copyright
53          notice, disclaimer, and this list of conditions.
54       2. Redistributions in binary form must reproduce the above copyright
55          notice, disclaimer, and this list of conditions in the documenta-
56          tion and/or other materials provided with the distribution.
57       3. All advertising materials mentioning features or use of this
58          software must display the following acknowledgment:
59 
60             This product includes software developed by Greg Roelofs
61             and contributors for the book, "PNG: The Definitive Guide,"
62             published by O'Reilly and Associates.
63 
64 
65       LICENSE 2 (GNU GPL v2 or later):
66 
67       This program is free software; you can redistribute it and/or modify
68       it under the terms of the GNU General Public License as published by
69       the Free Software Foundation; either version 2 of the License, or
70       (at your option) any later version.
71 
72       This program is distributed in the hope that it will be useful,
73       but WITHOUT ANY WARRANTY; without even the implied warranty of
74       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
75       GNU General Public License for more details.
76 
77       You should have received a copy of the GNU General Public License
78       along with this program; if not, write to the Free Software Foundation,
79       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
80 
81   ---------------------------------------------------------------------------*/
82 
83 #define PROGNAME  "rpng-x"
84 #define LONGNAME  "Simple PNG Viewer for X"
85 #define VERSION   "2.02 of 15 June 2014"
86 #define RESNAME   "rpng"        /* our X resource application name */
87 #define RESCLASS  "Rpng"        /* our X resource class name */
88 
89 #include <stdio.h>
90 #include <stdlib.h>
91 #include <string.h>
92 #include <time.h>
93 #include <X11/Xlib.h>
94 #include <X11/Xutil.h>
95 #include <X11/Xos.h>
96 #include <X11/keysym.h>
97 
98 /* #define DEBUG  :  this enables the Trace() macros */
99 
100 #include "readpng.h"   /* typedefs, common macros, readpng prototypes */
101 
102 
103 /* could just include png.h, but this macro is the only thing we need
104  * (name and typedefs changed to local versions); note that side effects
105  * only happen with alpha (which could easily be avoided with
106  * "ush acopy = (alpha);") */
107 
108 #define alpha_composite(composite, fg, alpha, bg) {               \
109     ush temp = ((ush)(fg)*(ush)(alpha) +                          \
110                 (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
111     (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
112 }
113 
114 
115 /* local prototypes */
116 static int  rpng_x_create_window(void);
117 static int  rpng_x_display_image(void);
118 static void rpng_x_cleanup(void);
119 static int  rpng_x_msb(ulg u32val);
120 
121 
122 static char titlebar[1024], *window_name = titlebar;
123 static char *appname = LONGNAME;
124 static char *icon_name = PROGNAME;
125 static char *res_name = RESNAME;
126 static char *res_class = RESCLASS;
127 static char *filename;
128 static FILE *infile;
129 
130 static char *bgstr;
131 static uch bg_red=0, bg_green=0, bg_blue=0;
132 
133 static double display_exponent;
134 
135 static ulg image_width, image_height, image_rowbytes;
136 static int image_channels;
137 static uch *image_data;
138 
139 /* X-specific variables */
140 static char *displayname;
141 static XImage *ximage;
142 static Display *display;
143 static int depth;
144 static Visual *visual;
145 static XVisualInfo *visual_list;
146 static int RShift, GShift, BShift;
147 static ulg RMask, GMask, BMask;
148 static Window window;
149 static GC gc;
150 static Colormap colormap;
151 
152 static int have_nondefault_visual = FALSE;
153 static int have_colormap = FALSE;
154 static int have_window = FALSE;
155 static int have_gc = FALSE;
156 /*
157 ulg numcolors=0, pixels[256];
158 ush reds[256], greens[256], blues[256];
159  */
160 
161 
162 
163 
main(int argc,char ** argv)164 int main(int argc, char **argv)
165 {
166 #ifdef sgi
167     char tmpline[80];
168 #endif
169     char *p;
170     int rc, alen, flen;
171     int error = 0;
172     int have_bg = FALSE;
173     double LUT_exponent;               /* just the lookup table */
174     double CRT_exponent = 2.2;         /* just the monitor */
175     double default_display_exponent;   /* whole display system */
176     XEvent e;
177     KeySym k;
178 
179 
180     displayname = (char *)NULL;
181     filename = (char *)NULL;
182 
183 
184     /* First set the default value for our display-system exponent, i.e.,
185      * the product of the CRT exponent and the exponent corresponding to
186      * the frame-buffer's lookup table (LUT), if any.  This is not an
187      * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
188      * ones), but it should cover 99% of the current possibilities. */
189 
190 #if defined(NeXT)
191     LUT_exponent = 1.0 / 2.2;
192     /*
193     if (some_next_function_that_returns_gamma(&next_gamma))
194         LUT_exponent = 1.0 / next_gamma;
195      */
196 #elif defined(sgi)
197     LUT_exponent = 1.0 / 1.7;
198     /* there doesn't seem to be any documented function to get the
199      * "gamma" value, so we do it the hard way */
200     infile = fopen("/etc/config/system.glGammaVal", "r");
201     if (infile) {
202         double sgi_gamma;
203 
204         fgets(tmpline, 80, infile);
205         fclose(infile);
206         sgi_gamma = atof(tmpline);
207         if (sgi_gamma > 0.0)
208             LUT_exponent = 1.0 / sgi_gamma;
209     }
210 #elif defined(Macintosh)
211     LUT_exponent = 1.8 / 2.61;
212     /*
213     if (some_mac_function_that_returns_gamma(&mac_gamma))
214         LUT_exponent = mac_gamma / 2.61;
215      */
216 #else
217     LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
218 #endif
219 
220     /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
221     default_display_exponent = LUT_exponent * CRT_exponent;
222 
223 
224     /* If the user has set the SCREEN_GAMMA environment variable as suggested
225      * (somewhat imprecisely) in the libpng documentation, use that; otherwise
226      * use the default value we just calculated.  Either way, the user may
227      * override this via a command-line option. */
228 
229     if ((p = getenv("SCREEN_GAMMA")) != NULL)
230         display_exponent = atof(p);
231     else
232         display_exponent = default_display_exponent;
233 
234 
235     /* Now parse the command line for options and the PNG filename. */
236 
237     while (*++argv && !error) {
238         if (!strncmp(*argv, "-display", 2)) {
239             if (!*++argv)
240                 ++error;
241             else
242                 displayname = *argv;
243         } else if (!strncmp(*argv, "-gamma", 2)) {
244             if (!*++argv)
245                 ++error;
246             else {
247                 display_exponent = atof(*argv);
248                 if (display_exponent <= 0.0)
249                     ++error;
250             }
251         } else if (!strncmp(*argv, "-bgcolor", 2)) {
252             if (!*++argv)
253                 ++error;
254             else {
255                 bgstr = *argv;
256                 if (strlen(bgstr) != 7 || bgstr[0] != '#')
257                     ++error;
258                 else
259                     have_bg = TRUE;
260             }
261         } else {
262             if (**argv != '-') {
263                 filename = *argv;
264                 if (argv[1])   /* shouldn't be any more args after filename */
265                     ++error;
266             } else
267                 ++error;   /* not expecting any other options */
268         }
269     }
270 
271     if (!filename)
272         ++error;
273 
274 
275     /* print usage screen if any errors up to this point */
276 
277     if (error) {
278         fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
279         readpng_version_info();
280         fprintf(stderr, "\n"
281           "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg] file.png\n"
282           "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
283           "    exp \ttransfer-function exponent (``gamma'') of the display\n"
284           "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n",
285           PROGNAME, default_display_exponent);
286 
287         fprintf(stderr, "\n"
288           "\t\t  to the product of the lookup-table exponent (varies)\n"
289           "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
290           "    bg  \tdesired background color in 7-character hex RGB format\n"
291           "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
292           "\t\t  used with transparent images\n"
293           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
294           "is displayed) to quit.\n");
295         exit(1);
296     }
297 
298 
299     if (!(infile = fopen(filename, "rb"))) {
300         fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
301         ++error;
302     } else {
303         if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
304             switch (rc) {
305                 case 1:
306                     fprintf(stderr, PROGNAME
307                       ":  [%s] is not a PNG file: incorrect signature\n",
308                       filename);
309                     break;
310                 case 2:
311                     fprintf(stderr, PROGNAME
312                       ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
313                     break;
314                 case 4:
315                     fprintf(stderr, PROGNAME ":  insufficient memory\n");
316                     break;
317                 default:
318                     fprintf(stderr, PROGNAME
319                       ":  unknown readpng_init() error\n");
320                     break;
321             }
322             ++error;
323         } else {
324             display = XOpenDisplay(displayname);
325             if (!display) {
326                 readpng_cleanup(TRUE);
327                 fprintf(stderr, PROGNAME ":  can't open X display [%s]\n",
328                   displayname? displayname : "default");
329                 ++error;
330             }
331         }
332         if (error)
333             fclose(infile);
334     }
335 
336 
337     if (error) {
338         fprintf(stderr, PROGNAME ":  aborting.\n");
339         exit(2);
340     }
341 
342 
343     /* set the title-bar string, but make sure buffer doesn't overflow */
344 
345     alen = strlen(appname);
346     flen = strlen(filename);
347     if (alen + flen + 3 > 1023)
348         sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
349     else
350         sprintf(titlebar, "%s:  %s", appname, filename);
351 
352 
353     /* if the user didn't specify a background color on the command line,
354      * check for one in the PNG file--if not, the initialized values of 0
355      * (black) will be used */
356 
357     if (have_bg) {
358         unsigned r, g, b;   /* this approach quiets compiler warnings */
359 
360         sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
361         bg_red   = (uch)r;
362         bg_green = (uch)g;
363         bg_blue  = (uch)b;
364     } else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
365         readpng_cleanup(TRUE);
366         fprintf(stderr, PROGNAME
367           ":  libpng error while checking for background color\n");
368         exit(2);
369     }
370 
371 
372     /* do the basic X initialization stuff, make the window and fill it
373      * with the background color */
374 
375     if (rpng_x_create_window())
376         exit(2);
377 
378 
379     /* decode the image, all at once */
380 
381     Trace((stderr, "calling readpng_get_image()\n"))
382     image_data = readpng_get_image(display_exponent, &image_channels,
383       &image_rowbytes);
384     Trace((stderr, "done with readpng_get_image()\n"))
385 
386 
387     /* done with PNG file, so clean up to minimize memory usage (but do NOT
388      * nuke image_data!) */
389 
390     readpng_cleanup(FALSE);
391     fclose(infile);
392 
393     if (!image_data) {
394         fprintf(stderr, PROGNAME ":  unable to decode PNG image\n");
395         exit(3);
396     }
397 
398 
399     /* display image (composite with background if requested) */
400 
401     Trace((stderr, "calling rpng_x_display_image()\n"))
402     if (rpng_x_display_image()) {
403         free(image_data);
404         exit(4);
405     }
406     Trace((stderr, "done with rpng_x_display_image()\n"))
407 
408 
409     /* wait for the user to tell us when to quit */
410 
411     printf(
412       "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n");
413     fflush(stdout);
414 
415     do
416         XNextEvent(display, &e);
417     while (!(e.type == ButtonPress && e.xbutton.button == Button1) &&
418            !(e.type == KeyPress &&    /*  v--- or 1 for shifted keys */
419              ((k = XLookupKeysym(&e.xkey, 0)) == XK_q || k == XK_Escape) ));
420 
421 
422     /* OK, we're done:  clean up all image and X resources and go away */
423 
424     rpng_x_cleanup();
425 
426     (void)argc; /* Unused */
427 
428     return 0;
429 }
430 
431 
432 
433 
434 
rpng_x_create_window(void)435 static int rpng_x_create_window(void)
436 {
437     uch *xdata;
438     int need_colormap = FALSE;
439     int screen, pad;
440     ulg bg_pixel = 0L;
441     ulg attrmask;
442     Window root;
443     XEvent e;
444     XGCValues gcvalues;
445     XSetWindowAttributes attr;
446     XTextProperty windowName, *pWindowName = &windowName;
447     XTextProperty iconName, *pIconName = &iconName;
448     XVisualInfo visual_info;
449     XSizeHints *size_hints;
450     XWMHints *wm_hints;
451     XClassHint *class_hints;
452 
453 
454     screen = DefaultScreen(display);
455     depth = DisplayPlanes(display, screen);
456     root = RootWindow(display, screen);
457 
458 #ifdef DEBUG
459     XSynchronize(display, True);
460 #endif
461 
462 #if 0
463 /* GRR:  add 8-bit support */
464     if (/* depth != 8 && */ depth != 16 && depth != 24 && depth != 32) {
465         fprintf(stderr,
466           "screen depth %d not supported (only 16-, 24- or 32-bit TrueColor)\n",
467           depth);
468         return 2;
469     }
470 
471     XMatchVisualInfo(display, screen, depth,
472       (depth == 8)? PseudoColor : TrueColor, &visual_info);
473     visual = visual_info.visual;
474 #else
475     if (depth != 16 && depth != 24 && depth != 32) {
476         int visuals_matched = 0;
477 
478         Trace((stderr, "default depth is %d:  checking other visuals\n",
479           depth))
480 
481         /* 24-bit first */
482         visual_info.screen = screen;
483         visual_info.depth = 24;
484         visual_list = XGetVisualInfo(display,
485           VisualScreenMask | VisualDepthMask, &visual_info, &visuals_matched);
486         if (visuals_matched == 0) {
487 /* GRR:  add 15-, 16- and 32-bit TrueColor visuals (also DirectColor?) */
488             fprintf(stderr, "default screen depth %d not supported, and no"
489               " 24-bit visuals found\n", depth);
490             return 2;
491         }
492         Trace((stderr, "XGetVisualInfo() returned %d 24-bit visuals\n",
493           visuals_matched))
494         visual = visual_list[0].visual;
495         depth = visual_list[0].depth;
496 /*
497         colormap_size = visual_list[0].colormap_size;
498         visual_class = visual->class;
499         visualID = XVisualIDFromVisual(visual);
500  */
501         have_nondefault_visual = TRUE;
502         need_colormap = TRUE;
503     } else {
504         XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info);
505         visual = visual_info.visual;
506     }
507 #endif
508 
509     RMask = visual->red_mask;
510     GMask = visual->green_mask;
511     BMask = visual->blue_mask;
512 
513 /* GRR:  add/check 8-bit support */
514     if (depth == 8 || need_colormap) {
515         colormap = XCreateColormap(display, root, visual, AllocNone);
516         if (!colormap) {
517             fprintf(stderr, "XCreateColormap() failed\n");
518             return 2;
519         }
520         have_colormap = TRUE;
521     }
522     if (depth == 15 || depth == 16) {
523         RShift = 15 - rpng_x_msb(RMask);    /* these are right-shifts */
524         GShift = 15 - rpng_x_msb(GMask);
525         BShift = 15 - rpng_x_msb(BMask);
526     } else if (depth > 16) {
527 #define NO_24BIT_MASKS
528 #ifdef NO_24BIT_MASKS
529         RShift = rpng_x_msb(RMask) - 7;     /* these are left-shifts */
530         GShift = rpng_x_msb(GMask) - 7;
531         BShift = rpng_x_msb(BMask) - 7;
532 #else
533         RShift = 7 - rpng_x_msb(RMask);     /* these are right-shifts, too */
534         GShift = 7 - rpng_x_msb(GMask);
535         BShift = 7 - rpng_x_msb(BMask);
536 #endif
537     }
538     if (depth >= 15 && (RShift < 0 || GShift < 0 || BShift < 0)) {
539         fprintf(stderr, "rpng internal logic error:  negative X shift(s)!\n");
540         return 2;
541     }
542 
543 /*---------------------------------------------------------------------------
544     Finally, create the window.
545   ---------------------------------------------------------------------------*/
546 
547     attr.backing_store = Always;
548     attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
549     attrmask = CWBackingStore | CWEventMask;
550     if (have_nondefault_visual) {
551         attr.colormap = colormap;
552         attr.background_pixel = 0;
553         attr.border_pixel = 1;
554         attrmask |= CWColormap | CWBackPixel | CWBorderPixel;
555     }
556 
557     window = XCreateWindow(display, root, 0, 0, image_width, image_height, 0,
558       depth, InputOutput, visual, attrmask, &attr);
559 
560     if (window == None) {
561         fprintf(stderr, "XCreateWindow() failed\n");
562         return 2;
563     } else
564         have_window = TRUE;
565 
566     if (depth == 8)
567         XSetWindowColormap(display, window, colormap);
568 
569     if (!XStringListToTextProperty(&window_name, 1, pWindowName))
570         pWindowName = NULL;
571     if (!XStringListToTextProperty(&icon_name, 1, pIconName))
572         pIconName = NULL;
573 
574     /* OK if any hints allocation fails; XSetWMProperties() allows NULLs */
575 
576     if ((size_hints = XAllocSizeHints()) != NULL) {
577         /* window will not be resizable */
578         size_hints->flags = PMinSize | PMaxSize;
579         size_hints->min_width = size_hints->max_width = (int)image_width;
580         size_hints->min_height = size_hints->max_height = (int)image_height;
581     }
582 
583     if ((wm_hints = XAllocWMHints()) != NULL) {
584         wm_hints->initial_state = NormalState;
585         wm_hints->input = True;
586      /* wm_hints->icon_pixmap = icon_pixmap; */
587         wm_hints->flags = StateHint | InputHint  /* | IconPixmapHint */ ;
588     }
589 
590     if ((class_hints = XAllocClassHint()) != NULL) {
591         class_hints->res_name = res_name;
592         class_hints->res_class = res_class;
593     }
594 
595     XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0,
596       size_hints, wm_hints, class_hints);
597 
598     /* various properties and hints no longer needed; free memory */
599     if (pWindowName)
600        XFree(pWindowName->value);
601     if (pIconName)
602        XFree(pIconName->value);
603     if (size_hints)
604         XFree(size_hints);
605     if (wm_hints)
606        XFree(wm_hints);
607     if (class_hints)
608        XFree(class_hints);
609 
610     XMapWindow(display, window);
611 
612     gc = XCreateGC(display, window, 0, &gcvalues);
613     have_gc = TRUE;
614 
615 /*---------------------------------------------------------------------------
616     Fill window with the specified background color.
617   ---------------------------------------------------------------------------*/
618 
619     if (depth == 24 || depth == 32) {
620         bg_pixel = ((ulg)bg_red   << RShift) |
621                    ((ulg)bg_green << GShift) |
622                    ((ulg)bg_blue  << BShift);
623     } else if (depth == 16) {
624         bg_pixel = ((((ulg)bg_red   << 8) >> RShift) & RMask) |
625                    ((((ulg)bg_green << 8) >> GShift) & GMask) |
626                    ((((ulg)bg_blue  << 8) >> BShift) & BMask);
627     } else /* depth == 8 */ {
628 
629         /* GRR:  add 8-bit support */
630 
631     }
632 
633     XSetForeground(display, gc, bg_pixel);
634     XFillRectangle(display, window, gc, 0, 0, image_width, image_height);
635 
636 /*---------------------------------------------------------------------------
637     Wait for first Expose event to do any drawing, then flush.
638   ---------------------------------------------------------------------------*/
639 
640     do
641         XNextEvent(display, &e);
642     while (e.type != Expose || e.xexpose.count);
643 
644     XFlush(display);
645 
646 /*---------------------------------------------------------------------------
647     Allocate memory for the X- and display-specific version of the image.
648   ---------------------------------------------------------------------------*/
649 
650     if (depth == 24 || depth == 32) {
651         xdata = (uch *)malloc(4*image_width*image_height);
652         pad = 32;
653     } else if (depth == 16) {
654         xdata = (uch *)malloc(2*image_width*image_height);
655         pad = 16;
656     } else /* depth == 8 */ {
657         xdata = (uch *)malloc(image_width*image_height);
658         pad = 8;
659     }
660 
661     if (!xdata) {
662         fprintf(stderr, PROGNAME ":  unable to allocate image memory\n");
663         return 4;
664     }
665 
666     ximage = XCreateImage(display, visual, depth, ZPixmap, 0,
667       (char *)xdata, image_width, image_height, pad, 0);
668 
669     if (!ximage) {
670         fprintf(stderr, PROGNAME ":  XCreateImage() failed\n");
671         free(xdata);
672         return 3;
673     }
674 
675     /* to avoid testing the byte order every pixel (or doubling the size of
676      * the drawing routine with a giant if-test), we arbitrarily set the byte
677      * order to MSBFirst and let Xlib worry about inverting things on little-
678      * endian machines (like Linux/x86, old VAXen, etc.)--this is not the most
679      * efficient approach (the giant if-test would be better), but in the
680      * interest of clarity, we take the easy way out... */
681 
682     ximage->byte_order = MSBFirst;
683 
684     return 0;
685 
686 } /* end function rpng_x_create_window() */
687 
688 
689 
690 
691 
rpng_x_display_image(void)692 static int rpng_x_display_image(void)
693 {
694     uch *src;
695     char *dest;
696     uch r, g, b, a;
697     ulg i, row, lastrow = 0;
698     ulg pixel;
699     int ximage_rowbytes = ximage->bytes_per_line;
700 /*  int bpp = ximage->bits_per_pixel;  */
701 
702 
703     Trace((stderr, "beginning display loop (image_channels == %d)\n",
704       image_channels))
705     Trace((stderr, "   (width = %ld, rowbytes = %ld, ximage_rowbytes = %d)\n",
706       image_width, image_rowbytes, ximage_rowbytes))
707     Trace((stderr, "   (bpp = %d)\n", ximage->bits_per_pixel))
708     Trace((stderr, "   (byte_order = %s)\n", ximage->byte_order == MSBFirst?
709       "MSBFirst" : (ximage->byte_order == LSBFirst? "LSBFirst" : "unknown")))
710 
711     if (depth == 24 || depth == 32) {
712         ulg red, green, blue;
713 
714         for (lastrow = row = 0;  row < image_height;  ++row) {
715             src = image_data + row*image_rowbytes;
716             dest = ximage->data + row*ximage_rowbytes;
717             if (image_channels == 3) {
718                 for (i = image_width;  i > 0;  --i) {
719                     red   = *src++;
720                     green = *src++;
721                     blue  = *src++;
722 #ifdef NO_24BIT_MASKS
723                     pixel = (red   << RShift) |
724                             (green << GShift) |
725                             (blue  << BShift);
726                     /* recall that we set ximage->byte_order = MSBFirst above */
727                     /* GRR BUG:  this assumes bpp == 32, but may be 24: */
728                     *dest++ = (char)((pixel >> 24) & 0xff);
729                     *dest++ = (char)((pixel >> 16) & 0xff);
730                     *dest++ = (char)((pixel >>  8) & 0xff);
731                     *dest++ = (char)( pixel        & 0xff);
732 #else
733                     red   = (RShift < 0)? red   << (-RShift) : red   >> RShift;
734                     green = (GShift < 0)? green << (-GShift) : green >> GShift;
735                     blue  = (BShift < 0)? blue  << (-BShift) : blue  >> BShift;
736                     pixel = (red & RMask) | (green & GMask) | (blue & BMask);
737                     /* recall that we set ximage->byte_order = MSBFirst above */
738                     *dest++ = (char)((pixel >> 24) & 0xff);
739                     *dest++ = (char)((pixel >> 16) & 0xff);
740                     *dest++ = (char)((pixel >>  8) & 0xff);
741                     *dest++ = (char)( pixel        & 0xff);
742 #endif
743                 }
744             } else /* if (image_channels == 4) */ {
745                 for (i = image_width;  i > 0;  --i) {
746                     r = *src++;
747                     g = *src++;
748                     b = *src++;
749                     a = *src++;
750                     if (a == 255) {
751                         red   = r;
752                         green = g;
753                         blue  = b;
754                     } else if (a == 0) {
755                         red   = bg_red;
756                         green = bg_green;
757                         blue  = bg_blue;
758                     } else {
759                         /* this macro (from png.h) composites the foreground
760                          * and background values and puts the result into the
761                          * first argument */
762                         alpha_composite(red,   r, a, bg_red);
763                         alpha_composite(green, g, a, bg_green);
764                         alpha_composite(blue,  b, a, bg_blue);
765                     }
766                     pixel = (red   << RShift) |
767                             (green << GShift) |
768                             (blue  << BShift);
769                     /* recall that we set ximage->byte_order = MSBFirst above */
770                     *dest++ = (char)((pixel >> 24) & 0xff);
771                     *dest++ = (char)((pixel >> 16) & 0xff);
772                     *dest++ = (char)((pixel >>  8) & 0xff);
773                     *dest++ = (char)( pixel        & 0xff);
774                 }
775             }
776             /* display after every 16 lines */
777             if (((row+1) & 0xf) == 0) {
778                 XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
779                   (int)lastrow, image_width, 16);
780                 XFlush(display);
781                 lastrow = row + 1;
782             }
783         }
784 
785     } else if (depth == 16) {
786         ush red, green, blue;
787 
788         for (lastrow = row = 0;  row < image_height;  ++row) {
789             src = image_data + row*image_rowbytes;
790             dest = ximage->data + row*ximage_rowbytes;
791             if (image_channels == 3) {
792                 for (i = image_width;  i > 0;  --i) {
793                     red   = ((ush)(*src) << 8);
794                     ++src;
795                     green = ((ush)(*src) << 8);
796                     ++src;
797                     blue  = ((ush)(*src) << 8);
798                     ++src;
799                     pixel = ((red   >> RShift) & RMask) |
800                             ((green >> GShift) & GMask) |
801                             ((blue  >> BShift) & BMask);
802                     /* recall that we set ximage->byte_order = MSBFirst above */
803                     *dest++ = (char)((pixel >>  8) & 0xff);
804                     *dest++ = (char)( pixel        & 0xff);
805                 }
806             } else /* if (image_channels == 4) */ {
807                 for (i = image_width;  i > 0;  --i) {
808                     r = *src++;
809                     g = *src++;
810                     b = *src++;
811                     a = *src++;
812                     if (a == 255) {
813                         red   = ((ush)r << 8);
814                         green = ((ush)g << 8);
815                         blue  = ((ush)b << 8);
816                     } else if (a == 0) {
817                         red   = ((ush)bg_red   << 8);
818                         green = ((ush)bg_green << 8);
819                         blue  = ((ush)bg_blue  << 8);
820                     } else {
821                         /* this macro (from png.h) composites the foreground
822                          * and background values and puts the result back into
823                          * the first argument (== fg byte here:  safe) */
824                         alpha_composite(r, r, a, bg_red);
825                         alpha_composite(g, g, a, bg_green);
826                         alpha_composite(b, b, a, bg_blue);
827                         red   = ((ush)r << 8);
828                         green = ((ush)g << 8);
829                         blue  = ((ush)b << 8);
830                     }
831                     pixel = ((red   >> RShift) & RMask) |
832                             ((green >> GShift) & GMask) |
833                             ((blue  >> BShift) & BMask);
834                     /* recall that we set ximage->byte_order = MSBFirst above */
835                     *dest++ = (char)((pixel >>  8) & 0xff);
836                     *dest++ = (char)( pixel        & 0xff);
837                 }
838             }
839             /* display after every 16 lines */
840             if (((row+1) & 0xf) == 0) {
841                 XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
842                   (int)lastrow, image_width, 16);
843                 XFlush(display);
844                 lastrow = row + 1;
845             }
846         }
847 
848     } else /* depth == 8 */ {
849 
850         /* GRR:  add 8-bit support */
851 
852     }
853 
854     Trace((stderr, "calling final XPutImage()\n"))
855     if (lastrow < image_height) {
856         XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
857           (int)lastrow, image_width, image_height-lastrow);
858         XFlush(display);
859     }
860 
861     return 0;
862 }
863 
864 
865 
866 
rpng_x_cleanup(void)867 static void rpng_x_cleanup(void)
868 {
869     if (image_data) {
870         free(image_data);
871         image_data = NULL;
872     }
873 
874     if (ximage) {
875         if (ximage->data) {
876             free(ximage->data);           /* we allocated it, so we free it */
877             ximage->data = (char *)NULL;  /*  instead of XDestroyImage() */
878         }
879         XDestroyImage(ximage);
880         ximage = NULL;
881     }
882 
883     if (have_gc)
884         XFreeGC(display, gc);
885 
886     if (have_window)
887         XDestroyWindow(display, window);
888 
889     if (have_colormap)
890         XFreeColormap(display, colormap);
891 
892     if (have_nondefault_visual)
893         XFree(visual_list);
894 }
895 
896 
897 
898 
899 
rpng_x_msb(ulg u32val)900 static int rpng_x_msb(ulg u32val)
901 {
902     int i;
903 
904     for (i = 31;  i >= 0;  --i) {
905         if (u32val & 0x80000000L)
906             break;
907         u32val <<= 1;
908     }
909     return i;
910 }
911