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