contrib/gregbook/rpng-x.c

   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     - 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 }