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 - 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) 32 33 --------------------------------------------------------------------------- 34 35 Copyright (c) 1998-2008, 2017 Greg Roelofs. All rights reserved. 36 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. 41 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): 45 46 47 LICENSE 1 ("BSD-like with advertising clause"): 48 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: 52 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: 60 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. 64 65 66 LICENSE 2 (GNU GPL v2 or later): 67 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. 72 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. 77 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 81 82 ---------------------------------------------------------------------------*/ 83 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 */ 89 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> 98 99 /* #define DEBUG : this enables the Trace() macros */ 100 101 #include "readpng.h" /* typedefs, common macros, readpng prototypes */ 102 103 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);") */ 108 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); \ 113 } 114 115 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); 121 122 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; 130 131 static char *bgstr; 132 static uch bg_red=0, bg_green=0, bg_blue=0; 133 134 static double display_exponent; 135 136 static ulg image_width, image_height, image_rowbytes; 137 static int image_channels; 138 static uch *image_data; 139 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; 152 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; 157 /* 158 ulg numcolors=0, pixels[256]; 159 ush reds[256], greens[256], blues[256]; 160 */ 161 162 163 164 165 int main(int argc, char **argv) 166 { 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; 179 180 181 displayname = (char *)NULL; 182 filename = (char *)NULL; 183 184 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. */ 190 191 #if defined(NeXT) 192 LUT_exponent = 1.0 / 2.2; 193 /* 194 if (some_next_function_that_returns_gamma(&next_gamma)) 195 LUT_exponent = 1.0 / next_gamma; 196 */ 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; 204 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; 210 } 211 #elif defined(Macintosh) 212 LUT_exponent = 1.8 / 2.61; 213 /* 214 if (some_mac_function_that_returns_gamma(&mac_gamma)) 215 LUT_exponent = mac_gamma / 2.61; 216 */ 217 #else 218 LUT_exponent = 1.0; /* assume no LUT: most PCs */ 219 #endif 220 221 /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */ 222 default_display_exponent = LUT_exponent * CRT_exponent; 223 224 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. */ 229 230 if ((p = getenv("SCREEN_GAMMA")) != NULL) 231 display_exponent = atof(p); 232 else 233 display_exponent = default_display_exponent; 234 235 236 /* Now parse the command line for options and the PNG filename. */ 237 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; 251 } 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; 261 } 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 */ 269 } 270 } 271 272 if (!filename) 273 ++error; 274 275 276 /* print usage screen if any errors up to this point */ 277 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); 287 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); 297 } 298 299 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; 322 } 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; 331 } 332 } 333 if (error) 334 fclose(infile); 335 } 336 337 338 if (error) { 339 fprintf(stderr, PROGNAME ": aborting.\n"); 340 exit(2); 341 } 342 343 344 /* set the title-bar string, but make sure buffer doesn't overflow */ 345 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); 352 353 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 */ 357 358 if (have_bg) { 359 unsigned r, g, b; /* this approach quiets compiler warnings */ 360 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); 370 } 371 372 373 /* do the basic X initialization stuff, make the window and fill it 374 * with the background color */ 375 376 if (rpng_x_create_window()) 377 exit(2); 378 379 380 /* decode the image, all at once */ 381 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")) 386 387 388 /* done with PNG file, so clean up to minimize memory usage (but do NOT 389 * nuke image_data!) */ 390 391 readpng_cleanup(FALSE); 392 fclose(infile); 393 394 if (!image_data) { 395 fprintf(stderr, PROGNAME ": unable to decode PNG image\n"); 396 exit(3); 397 } 398 399 400 /* display image (composite with background if requested) */ 401 402 Trace((stderr, "calling rpng_x_display_image()\n")) 403 if (rpng_x_display_image()) { 404 free(image_data); 405 exit(4); 406 } 407 Trace((stderr, "done with rpng_x_display_image()\n")) 408 409 410 /* wait for the user to tell us when to quit */ 411 412 printf( 413 "Done. Press Q, Esc or mouse button 1 (within image window) to quit.\n"); 414 fflush(stdout); 415 416 do 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) )); 421 422 423 /* OK, we're done: clean up all image and X resources and go away */ 424 425 rpng_x_cleanup(); 426 427 (void)argc; /* Unused */ 428 429 return 0; 430 } 431 432 433 434 435 436 static int rpng_x_create_window(void) 437 { 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; 453 454 455 screen = DefaultScreen(display); 456 depth = DisplayPlanes(display, screen); 457 root = RootWindow(display, screen); 458 459 #ifdef DEBUG 460 XSynchronize(display, True); 461 #endif 462 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; 470 } 471 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; 478 479 Trace((stderr, "default depth is %d: checking other visuals\n", 480 depth)) 481 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; 492 } 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; 497 /* 498 colormap_size = visual_list[0].colormap_size; 499 visual_class = visual->class; 500 visualID = XVisualIDFromVisual(visual); 501 */ 502 have_nondefault_visual = TRUE; 503 need_colormap = TRUE; 504 } else { 505 XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info); 506 visual = visual_info.visual; 507 } 508 #endif 509 510 RMask = visual->red_mask; 511 GMask = visual->green_mask; 512 BMask = visual->blue_mask; 513 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; 520 } 521 have_colormap = TRUE; 522 } 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 538 } 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; 542 } 543 544 /*--------------------------------------------------------------------------- 545 Finally, create the window. 546 ---------------------------------------------------------------------------*/ 547 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; 556 } 557 558 window = XCreateWindow(display, root, 0, 0, image_width, image_height, 0, 559 depth, InputOutput, visual, attrmask, &attr); 560 561 if (window == None) { 562 fprintf(stderr, "XCreateWindow() failed\n"); 563 return 2; 564 } else 565 have_window = TRUE; 566 567 if (depth == 8) 568 XSetWindowColormap(display, window, colormap); 569 570 if (!XStringListToTextProperty(&window_name, 1, pWindowName)) 571 pWindowName = NULL; 572 if (!XStringListToTextProperty(&icon_name, 1, pIconName)) 573 pIconName = NULL; 574 575 /* OK if any hints allocation fails; XSetWMProperties() allows NULLs */ 576 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; 582 } 583 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 */ ; 589 } 590 591 if ((class_hints = XAllocClassHint()) != NULL) { 592 class_hints->res_name = res_name; 593 class_hints->res_class = res_class; 594 } 595 596 XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0, 597 size_hints, wm_hints, class_hints); 598 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); 610 611 XMapWindow(display, window); 612 613 gc = XCreateGC(display, window, 0, &gcvalues); 614 have_gc = TRUE; 615 616 /*--------------------------------------------------------------------------- 617 Fill window with the specified background color. 618 ---------------------------------------------------------------------------*/ 619 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 */ { 629 630 /* GRR: add 8-bit support */ 631 632 } 633 634 XSetForeground(display, gc, bg_pixel); 635 XFillRectangle(display, window, gc, 0, 0, image_width, image_height); 636 637 /*--------------------------------------------------------------------------- 638 Wait for first Expose event to do any drawing, then flush. 639 ---------------------------------------------------------------------------*/ 640 641 do 642 XNextEvent(display, &e); 643 while (e.type != Expose || e.xexpose.count); 644 645 XFlush(display); 646 647 /*--------------------------------------------------------------------------- 648 Allocate memory for the X- and display-specific version of the image. 649 ---------------------------------------------------------------------------*/ 650 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; 660 } 661 662 if (!xdata) { 663 fprintf(stderr, PROGNAME ": unable to allocate image memory\n"); 664 return 4; 665 } 666 667 ximage = XCreateImage(display, visual, depth, ZPixmap, 0, 668 (char *)xdata, image_width, image_height, pad, 0); 669 670 if (!ximage) { 671 fprintf(stderr, PROGNAME ": XCreateImage() failed\n"); 672 free(xdata); 673 return 3; 674 } 675 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... */ 682 683 ximage->byte_order = MSBFirst; 684 685 return 0; 686 687 } /* end function rpng_x_create_window() */ 688 689 690 691 692 693 static int rpng_x_display_image(void) 694 { 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; */ 702 703 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"))) 711 712 if (depth == 24 || depth == 32) { 713 ulg red, green, blue; 714 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 744 } 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); 766 } 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); 775 } 776 } 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; 783 } 784 } 785 786 } else if (depth == 16) { 787 ush red, green, blue; 788 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); 806 } 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); 831 } 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); 838 } 839 } 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; 846 } 847 } 848 849 } else /* depth == 8 */ { 850 851 /* GRR: add 8-bit support */ 852 853 } 854 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); 860 } 861 862 return 0; 863 } 864 865 866 867 868 static void rpng_x_cleanup(void) 869 { 870 if (image_data) { 871 free(image_data); 872 image_data = NULL; 873 } 874 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() */ 879 } 880 XDestroyImage(ximage); 881 ximage = NULL; 882 } 883 884 if (have_gc) 885 XFreeGC(display, gc); 886 887 if (have_window) 888 XDestroyWindow(display, window); 889 890 if (have_colormap) 891 XFreeColormap(display, colormap); 892 893 if (have_nondefault_visual) 894 XFree(visual_list); 895 } 896 897 898 899 900 901 static int rpng_x_msb(ulg u32val) 902 { 903 int i; 904 905 for (i = 31; i >= 0; --i) { 906 if (u32val & 0x80000000L) 907 break; 908 u32val <<= 1; 909 } 910 return i; 911 } 912
