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