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