1 /*---------------------------------------------------------------------------

     2 

     3    rpng2 - progressive-model PNG display program                  rpng2-x.c

     4 

     5    This program decodes and displays PNG files progressively, as if it were

     6    a web browser (though the front end is only set up to read from files).

     7    It supports gamma correction, user-specified background colors, and user-

     8    specified background patterns (for transparent images).  This version is

     9    for the X Window System (tested by the author under Unix and by Martin

    10    Zinser under OpenVMS; may work under OS/2 with a little tweaking).

    11 

    12    Thanks to Adam Costello and Pieter S. van der Meulen for the "diamond"

    13    and "radial waves" patterns, respectively.

    14 

    15    to do (someday, maybe):

    16     - fix expose/redraw code:  don't draw entire row if only part exposed

    17     - 8-bit (colormapped) X support

    18     - finish resizable checkerboard-gradient (sizes 4-128?)

    19     - use %.1023s to simplify truncation of title-bar string?

    20 

    21   ---------------------------------------------------------------------------

    22 

    23    Changelog:

    24     - 1.01:  initial public release

    25     - 1.02:  modified to allow abbreviated options; fixed char/uchar mismatch

    26     - 1.10:  added support for non-default visuals; fixed X pixel-conversion

    27     - 1.11:  added -usleep option for demos; fixed command-line parsing bug

    28     - 1.12:  added -pause option for demos and testing

    29     - 1.20:  added runtime MMX-enabling/disabling and new -mmx* options

    30     - 1.21:  fixed some small X memory leaks (thanks to François Petitjean)

    31     - 1.22:  fixed XFreeGC() crash bug (thanks to Patrick Welche)

    32     - 1.23:  added -bgpat 0 mode (std white/gray checkerboard, 8x8 squares)

    33     - 1.30:  added -loop option for -bgpat (ifdef FEATURE_LOOP); fixed bpp =

    34               24; added support for X resources (thanks to Gerhard Niklasch)

    35     - 1.31:  added code to skip unused chunks (thanks to Glenn Randers-Pehrson)

    36     - 1.32:  added AMD64/EM64T support (__x86_64__); added basic expose/redraw

    37               handling

    38     - 2.00:  dual-licensed (added GNU GPL)

    39     - 2.01:  fixed 64-bit typo in readpng2.c; fixed -pause usage description

    40     - 2.02:  fixed improper display of usage screen on PNG error(s); fixed

    41               unexpected-EOF and file-read-error cases; fixed Trace() cut-and-

    42               paste bugs

    43 

    44   ---------------------------------------------------------------------------

    45 

    46       Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.

    47 

    48       This software is provided "as is," without warranty of any kind,

    49       express or implied.  In no event shall the author or contributors

    50       be held liable for any damages arising in any way from the use of

    51       this software.

    52 

    53       The contents of this file are DUAL-LICENSED.  You may modify and/or

    54       redistribute this software according to the terms of one of the

    55       following two licenses (at your option):

    56 

    57 

    58       LICENSE 1 ("BSD-like with advertising clause"):

    59 

    60       Permission is granted to anyone to use this software for any purpose,

    61       including commercial applications, and to alter it and redistribute

    62       it freely, subject to the following restrictions:

    63 

    64       1. Redistributions of source code must retain the above copyright

    65          notice, disclaimer, and this list of conditions.

    66       2. Redistributions in binary form must reproduce the above copyright

    67          notice, disclaimer, and this list of conditions in the documenta-

    68          tion and/or other materials provided with the distribution.

    69       3. All advertising materials mentioning features or use of this

    70          software must display the following acknowledgment:

    71 

    72             This product includes software developed by Greg Roelofs

    73             and contributors for the book, "PNG: The Definitive Guide,"

    74             published by O'Reilly and Associates.

    75 

    76 

    77       LICENSE 2 (GNU GPL v2 or later):

    78 

    79       This program is free software; you can redistribute it and/or modify

    80       it under the terms of the GNU General Public License as published by

    81       the Free Software Foundation; either version 2 of the License, or

    82       (at your option) any later version.

    83 

    84       This program is distributed in the hope that it will be useful,

    85       but WITHOUT ANY WARRANTY; without even the implied warranty of

    86       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    87       GNU General Public License for more details.

    88 

    89       You should have received a copy of the GNU General Public License

    90       along with this program; if not, write to the Free Software Foundation,

    91       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    92 

    93   ---------------------------------------------------------------------------*/

    94 

    95 #define PROGNAME  "rpng2-x"

    96 #define LONGNAME  "Progressive PNG Viewer for X"

    97 #define VERSION   "2.02 of 16 March 2008"

    98 #define RESNAME   "rpng2"	/* our X resource application name */

    99 #define RESCLASS  "Rpng"	/* our X resource class name */

   100 

   101 #include <stdio.h>

   102 #include <stdlib.h>

   103 #include <ctype.h>

   104 #include <string.h>

   105 #include <setjmp.h>       /* for jmpbuf declaration in readpng2.h */

   106 #include <time.h>

   107 #include <math.h>         /* only for PvdM background code */

   108 #include <X11/Xlib.h>

   109 #include <X11/Xutil.h>

   110 #include <X11/Xos.h>

   111 #include <X11/keysym.h>   /* defines XK_* macros */

   112 

   113 #ifdef VMS

   114 #  include <unistd.h>

   115 #endif

   116 

   117 /* all for PvdM background code: */

   118 #ifndef PI

   119 #  define PI             3.141592653589793238

   120 #endif

   121 #define PI_2             (PI*0.5)

   122 #define INV_PI_360       (360.0 / PI)

   123 #define MAX(a,b)         (a>b?a:b)

   124 #define MIN(a,b)         (a<b?a:b)

   125 #define CLIP(a,min,max)  MAX(min,MIN((a),max))

   126 #define ABS(a)           ((a)<0?-(a):(a))

   127 #define CLIP8P(c)        MAX(0,(MIN((c),255)))   /* 8-bit pos. integer (uch) */

   128 #define ROUNDF(f)        ((int)(f + 0.5))

   129 

   130 #define QUIT(e,k) ((e.type == ButtonPress && e.xbutton.button == Button1) ||  \

   131                   (e.type == KeyPress &&   /*  v--- or 1 for shifted keys */  \

   132                   ((k = XLookupKeysym(&e.xkey, 0)) == XK_q || k == XK_Escape)))

   133 

   134 #define NO_24BIT_MASKS	/* undef case not fully written--only for redisplay() */

   135 

   136 #define rgb1_max   bg_freq

   137 #define rgb1_min   bg_gray

   138 #define rgb2_max   bg_bsat

   139 #define rgb2_min   bg_brot

   140 

   141 /* #define DEBUG */     /* this enables the Trace() macros */

   142 

   143 #include "readpng2.h"   /* typedefs, common macros, readpng2 prototypes */

   144 

   145 

   146 /* could just include png.h, but this macro is the only thing we need

   147  * (name and typedefs changed to local versions); note that side effects

   148  * only happen with alpha (which could easily be avoided with

   149  * "ush acopy = (alpha);") */

   150 

   151 #define alpha_composite(composite, fg, alpha, bg) {               \

   152     ush temp = ((ush)(fg)*(ush)(alpha) +                          \

   153                 (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \

   154     (composite) = (uch)((temp + (temp >> 8)) >> 8);               \

   155 }

   156 

   157 

   158 #define INBUFSIZE 4096   /* with pseudo-timing on (1 sec delay/block), this

   159                           *  block size corresponds roughly to a download

   160                           *  speed 10% faster than theoretical 33.6K maximum

   161                           *  (assuming 8 data bits, 1 stop bit and no other

   162                           *  overhead) */

   163 

   164 /* local prototypes */

   165 static void rpng2_x_init (void);

   166 static int  rpng2_x_create_window (void);

   167 static int  rpng2_x_load_bg_image (void);

   168 static void rpng2_x_display_row (ulg row);

   169 static void rpng2_x_finish_display (void);

   170 static void rpng2_x_redisplay_image (ulg startcol, ulg startrow,

   171                                      ulg width, ulg height);

   172 #ifdef FEATURE_LOOP

   173 static void rpng2_x_reload_bg_image (void);

   174 static int  is_number (char *p);

   175 #endif

   176 static void rpng2_x_cleanup (void);

   177 static int  rpng2_x_msb (ulg u32val);

   178 

   179 

   180 static char titlebar[1024], *window_name = titlebar;

   181 static char *appname = LONGNAME;

   182 static char *icon_name = PROGNAME;

   183 static char *res_name = RESNAME;

   184 static char *res_class = RESCLASS;

   185 static char *filename;

   186 static FILE *infile;

   187 

   188 static mainprog_info rpng2_info;

   189 

   190 static uch inbuf[INBUFSIZE];

   191 static int incount;

   192 

   193 static int pat = 6;        /* must be less than num_bgpat */

   194 static int bg_image = 0;

   195 static int bgscale, bgscale_default = 16;

   196 static ulg bg_rowbytes;

   197 static uch *bg_data;

   198 

   199 int pause_after_pass = FALSE;

   200 int demo_timing = FALSE;

   201 ulg usleep_duration = 0L;

   202 

   203 static struct rgb_color {

   204     uch r, g, b;

   205 } rgb[] = {

   206     {  0,   0,   0},    /*  0:  black */

   207     {255, 255, 255},    /*  1:  white */

   208     {173, 132,  57},    /*  2:  tan */

   209     { 64, 132,   0},    /*  3:  medium green */

   210     {189, 117,   1},    /*  4:  gold */

   211     {253, 249,   1},    /*  5:  yellow */

   212     {  0,   0, 255},    /*  6:  blue */

   213     {  0,   0, 120},    /*  7:  medium blue */

   214     {255,   0, 255},    /*  8:  magenta */

   215     { 64,   0,  64},    /*  9:  dark magenta */

   216     {255,   0,   0},    /* 10:  red */

   217     { 64,   0,   0},    /* 11:  dark red */

   218     {255, 127,   0},    /* 12:  orange */

   219     {192,  96,   0},    /* 13:  darker orange */

   220     { 24,  60,   0},    /* 14:  dark green-yellow */

   221     { 85, 125, 200},    /* 15:  ice blue */

   222     {192, 192, 192}     /* 16:  Netscape/Mosaic gray */

   223 };

   224 /* not used for now, but should be for error-checking:

   225 static int num_rgb = sizeof(rgb) / sizeof(struct rgb_color);

   226  */

   227 

   228 /*

   229     This whole struct is a fairly cheesy way to keep the number of

   230     command-line options to a minimum.  The radial-waves background

   231     type is a particularly poor fit to the integer elements of the

   232     struct...but a few macros and a little fixed-point math will do

   233     wonders for ya.

   234 

   235     type bits:

   236        F E D C B A 9 8 7 6 5 4 3 2 1 0

   237                              | | | | |

   238                              | | +-+-+-- 0 = sharp-edged checkerboard

   239                              | |         1 = soft diamonds

   240                              | |         2 = radial waves

   241                              | |       3-7 = undefined

   242                              | +-- gradient #2 inverted?

   243                              +-- alternating columns inverted?

   244  */

   245 static struct background_pattern {

   246     ush type;

   247     int rgb1_max, rgb1_min;     /* or bg_freq, bg_gray */

   248     int rgb2_max, rgb2_min;     /* or bg_bsat, bg_brot (both scaled by 10)*/

   249 } bg[] = {

   250     {0,     1,1, 16,16},        /* checkered:  white vs. light gray (basic) */

   251     {0+8,   2,0,  1,15},        /* checkered:  tan/black vs. white/ice blue */

   252     {0+24,  2,0,  1,0},         /* checkered:  tan/black vs. white/black */

   253     {0+8,   4,5,  0,2},         /* checkered:  gold/yellow vs. black/tan */

   254     {0+8,   4,5,  0,6},         /* checkered:  gold/yellow vs. black/blue */

   255     {0,     7,0,  8,9},         /* checkered:  deep blue/black vs. magenta */

   256     {0+8,  13,0,  5,14},        /* checkered:  orange/black vs. yellow */

   257     {0+8,  12,0, 10,11},        /* checkered:  orange/black vs. red */

   258     {1,     7,0,  8,0},         /* diamonds:  deep blue/black vs. magenta */

   259     {1,    12,0, 11,0},         /* diamonds:  orange vs. dark red */

   260     {1,    10,0,  7,0},         /* diamonds:  red vs. medium blue */

   261     {1,     4,0,  5,0},         /* diamonds:  gold vs. yellow */

   262     {1,     3,0,  0,0},         /* diamonds:  medium green vs. black */

   263     {2,    16, 100,  20,   0},  /* radial:  ~hard radial color-beams */

   264     {2,    18, 100,  10,   2},  /* radial:  soft, curved radial color-beams */

   265     {2,    16, 256, 100, 250},  /* radial:  very tight spiral */

   266     {2, 10000, 256,  11,   0}   /* radial:  dipole-moire' (almost fractal) */

   267 };

   268 static int num_bgpat = sizeof(bg) / sizeof(struct background_pattern);

   269 

   270 

   271 /* X-specific variables */

   272 static char *displayname;

   273 static XImage *ximage;

   274 static Display *display;

   275 static int depth;

   276 static Visual *visual;

   277 static XVisualInfo *visual_list;

   278 static int RShift, GShift, BShift;

   279 static ulg RMask, GMask, BMask;

   280 static Window window;

   281 static GC gc;

   282 static Colormap colormap;

   283 

   284 static int have_nondefault_visual = FALSE;

   285 static int have_colormap = FALSE;

   286 static int have_window = FALSE;

   287 static int have_gc = FALSE;

   288 

   289 

   290 

   291 

   292 int main(int argc, char **argv)

   293 {

   294 #ifdef sgi

   295     char tmpline[80];

   296 #endif

   297     char *p, *bgstr = NULL;

   298     int rc, alen, flen;

   299     int error = 0;

   300     int timing = FALSE;

   301     int have_bg = FALSE;

   302 #ifdef FEATURE_LOOP

   303     int loop = FALSE;

   304     long loop_interval = -1;		/* seconds (100,000 max) */

   305 #endif

   306     double LUT_exponent;                /* just the lookup table */

   307     double CRT_exponent = 2.2;          /* just the monitor */

   308     double default_display_exponent;    /* whole display system */

   309     XEvent e;

   310     KeySym k;

   311 

   312 

   313     /* First initialize a few things, just to be sure--memset takes care of

   314      * default background color (black), booleans (FALSE), pointers (NULL),

   315      * etc. */

   316 

   317     displayname = (char *)NULL;

   318     filename = (char *)NULL;

   319     memset(&rpng2_info, 0, sizeof(mainprog_info));

   320 

   321 

   322     /* Set the default value for our display-system exponent, i.e., the

   323      * product of the CRT exponent and the exponent corresponding to

   324      * the frame-buffer's lookup table (LUT), if any.  This is not an

   325      * exhaustive list of LUT values (e.g., OpenStep has a lot of weird

   326      * ones), but it should cover 99% of the current possibilities. */

   327 

   328 #if defined(NeXT)

   329     /* third-party utilities can modify the default LUT exponent */

   330     LUT_exponent = 1.0 / 2.2;

   331     /*

   332     if (some_next_function_that_returns_gamma(&next_gamma))

   333         LUT_exponent = 1.0 / next_gamma;

   334      */

   335 #elif defined(sgi)

   336     LUT_exponent = 1.0 / 1.7;

   337     /* there doesn't seem to be any documented function to

   338      * get the "gamma" value, so we do it the hard way */

   339     infile = fopen("/etc/config/system.glGammaVal", "r");

   340     if (infile) {

   341         double sgi_gamma;

   342 

   343         fgets(tmpline, 80, infile);

   344         fclose(infile);

   345         sgi_gamma = atof(tmpline);

   346         if (sgi_gamma > 0.0)

   347             LUT_exponent = 1.0 / sgi_gamma;

   348     }

   349 #elif defined(Macintosh)

   350     LUT_exponent = 1.8 / 2.61;

   351     /*

   352     if (some_mac_function_that_returns_gamma(&mac_gamma))

   353         LUT_exponent = mac_gamma / 2.61;

   354      */

   355 #else

   356     LUT_exponent = 1.0;   /* assume no LUT:  most PCs */

   357 #endif

   358 

   359     /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */

   360     default_display_exponent = LUT_exponent * CRT_exponent;

   361 

   362 

   363     /* If the user has set the SCREEN_GAMMA environment variable as suggested

   364      * (somewhat imprecisely) in the libpng documentation, use that; otherwise

   365      * use the default value we just calculated.  Either way, the user may

   366      * override this via a command-line option. */

   367 

   368     if ((p = getenv("SCREEN_GAMMA")) != NULL)

   369         rpng2_info.display_exponent = atof(p);

   370     else

   371         rpng2_info.display_exponent = default_display_exponent;

   372 

   373 

   374     /* Now parse the command line for options and the PNG filename. */

   375 

   376     while (*++argv && !error) {

   377         if (!strncmp(*argv, "-display", 2)) {

   378             if (!*++argv)

   379                 ++error;

   380             else

   381                 displayname = *argv;

   382         } else if (!strncmp(*argv, "-gamma", 2)) {

   383             if (!*++argv)

   384                 ++error;

   385             else {

   386                 rpng2_info.display_exponent = atof(*argv);

   387                 if (rpng2_info.display_exponent <= 0.0)

   388                     ++error;

   389             }

   390         } else if (!strncmp(*argv, "-bgcolor", 4)) {

   391             if (!*++argv)

   392                 ++error;

   393             else {

   394                 bgstr = *argv;

   395                 if (strlen(bgstr) != 7 || bgstr[0] != '#')

   396                     ++error;

   397                 else {

   398                     have_bg = TRUE;

   399                     bg_image = FALSE;

   400                 }

   401             }

   402         } else if (!strncmp(*argv, "-bgpat", 4)) {

   403             if (!*++argv)

   404                 ++error;

   405             else {

   406                 pat = atoi(*argv);

   407                 if (pat >= 0 && pat < num_bgpat) {

   408                     bg_image = TRUE;

   409                     have_bg = FALSE;

   410                 } else

   411                     ++error;

   412             }

   413         } else if (!strncmp(*argv, "-usleep", 2)) {

   414             if (!*++argv)

   415                 ++error;

   416             else {

   417                 usleep_duration = (ulg)atol(*argv);

   418                 demo_timing = TRUE;

   419             }

   420         } else if (!strncmp(*argv, "-pause", 2)) {

   421             pause_after_pass = TRUE;

   422         } else if (!strncmp(*argv, "-timing", 2)) {

   423             timing = TRUE;

   424 #ifdef FEATURE_LOOP

   425         } else if (!strncmp(*argv, "-loop", 2)) {

   426             loop = TRUE;

   427             if (!argv[1] || !is_number(argv[1]))

   428                 loop_interval = 2;

   429             else {

   430                 ++argv;

   431                 loop_interval = atol(*argv);

   432                 if (loop_interval < 0)

   433                     loop_interval = 2;

   434                 else if (loop_interval > 100000)   /* bit more than one day */

   435                     loop_interval = 100000;

   436             }

   437 #endif

   438 #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))

   439         } else if (!strncmp(*argv, "-nommxfilters", 7)) {

   440             rpng2_info.nommxfilters = TRUE;

   441         } else if (!strncmp(*argv, "-nommxcombine", 7)) {

   442             rpng2_info.nommxcombine = TRUE;

   443         } else if (!strncmp(*argv, "-nommxinterlace", 7)) {

   444             rpng2_info.nommxinterlace = TRUE;

   445         } else if (!strcmp(*argv, "-nommx")) {

   446             rpng2_info.nommxfilters = TRUE;

   447             rpng2_info.nommxcombine = TRUE;

   448             rpng2_info.nommxinterlace = TRUE;

   449 #endif

   450         } else {

   451             if (**argv != '-') {

   452                 filename = *argv;

   453                 if (argv[1])   /* shouldn't be any more args after filename */

   454                     ++error;

   455             } else

   456                 ++error;   /* not expecting any other options */

   457         }

   458     }

   459 

   460     if (!filename)

   461         ++error;

   462 

   463 

   464     /* print usage screen if any errors up to this point */

   465 

   466     if (error) {

   467         fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);

   468         readpng2_version_info();

   469         fprintf(stderr, "\n"

   470           "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"

   471 #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))

   472           "        %*s [[-nommxfilters] [-nommxcombine] [-nommxinterlace] | -nommx]\n"

   473 #endif

   474 #ifdef FEATURE_LOOP

   475           "        %*s [-usleep dur | -timing] [-pause] [-loop [sec]] file.png\n\n"

   476 #else

   477           "        %*s [-usleep dur | -timing] [-pause] file.png\n\n"

   478 #endif

   479           "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"

   480           "    exp \ttransfer-function exponent (``gamma'') of the display\n"

   481           "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"

   482           "\t\t  to the product of the lookup-table exponent (varies)\n"

   483           "\t\t  and the CRT exponent (usually 2.2); must be positive\n"

   484           "    bg  \tdesired background color in 7-character hex RGB format\n"

   485           "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"

   486           "\t\t  used with transparent images; overrides -bgpat\n"

   487           "    pat \tdesired background pattern number (0-%d); used with\n"

   488           "\t\t  transparent images; overrides -bgcolor\n"

   489 #ifdef FEATURE_LOOP

   490           "    -loop\tloops through background images after initial display\n"

   491           "\t\t  is complete (depends on -bgpat)\n"

   492           "    sec \tseconds to display each background image (default = 2)\n"

   493 #endif

   494 #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))

   495           "    -nommx*\tdisable optimized MMX routines for decoding row filters,\n"

   496           "\t\t  combining rows, and expanding interlacing, respectively\n"

   497 #endif

   498           "    dur \tduration in microseconds to wait after displaying each\n"

   499           "\t\t  row (for demo purposes)\n"

   500           "    -timing\tenables delay for every block read, to simulate modem\n"

   501           "\t\t  download of image (~36 Kbps)\n"

   502           "    -pause\tpauses after displaying each pass until mouse clicked\n"

   503           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"

   504           "is displayed) to quit.\n"

   505           "\n", PROGNAME,

   506 #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))

   507           (int)strlen(PROGNAME), " ",

   508 #endif

   509           (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat-1);

   510         exit(1);

   511     }

   512 

   513 

   514     if (!(infile = fopen(filename, "rb"))) {

   515         fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);

   516         ++error;

   517     } else {

   518         incount = fread(inbuf, 1, INBUFSIZE, infile);

   519         if (incount < 8 || !readpng2_check_sig(inbuf, 8)) {

   520             fprintf(stderr, PROGNAME

   521               ":  [%s] is not a PNG file: incorrect signature\n",

   522               filename);

   523             ++error;

   524         } else if ((rc = readpng2_init(&rpng2_info)) != 0) {

   525             switch (rc) {

   526                 case 2:

   527                     fprintf(stderr, PROGNAME

   528                       ":  [%s] has bad IHDR (libpng longjmp)\n", filename);

   529                     break;

   530                 case 4:

   531                     fprintf(stderr, PROGNAME ":  insufficient memory\n");

   532                     break;

   533                 default:

   534                     fprintf(stderr, PROGNAME

   535                       ":  unknown readpng2_init() error\n");

   536                     break;

   537             }

   538             ++error;

   539         } else {

   540             Trace((stderr, "about to call XOpenDisplay()\n"))

   541             display = XOpenDisplay(displayname);

   542             if (!display) {

   543                 readpng2_cleanup(&rpng2_info);

   544                 fprintf(stderr, PROGNAME ":  can't open X display [%s]\n",

   545                   displayname? displayname : "default");

   546                 ++error;

   547             }

   548         }

   549         if (error)

   550             fclose(infile);

   551     }

   552 

   553 

   554     if (error) {

   555         fprintf(stderr, PROGNAME ":  aborting.\n");

   556         exit(2);

   557     }

   558 

   559 

   560     /* set the title-bar string, but make sure buffer doesn't overflow */

   561 

   562     alen = strlen(appname);

   563     flen = strlen(filename);

   564     if (alen + flen + 3 > 1023)

   565         sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));

   566     else

   567         sprintf(titlebar, "%s:  %s", appname, filename);

   568 

   569 

   570     /* set some final rpng2_info variables before entering main data loop */

   571 

   572     if (have_bg) {

   573         unsigned r, g, b;   /* this approach quiets compiler warnings */

   574 

   575         sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);

   576         rpng2_info.bg_red   = (uch)r;

   577         rpng2_info.bg_green = (uch)g;

   578         rpng2_info.bg_blue  = (uch)b;

   579     } else

   580         rpng2_info.need_bgcolor = TRUE;

   581 

   582     rpng2_info.state = kPreInit;

   583     rpng2_info.mainprog_init = rpng2_x_init;

   584     rpng2_info.mainprog_display_row = rpng2_x_display_row;

   585     rpng2_info.mainprog_finish_display = rpng2_x_finish_display;

   586 

   587 

   588     /* OK, this is the fun part:  call readpng2_decode_data() at the start of

   589      * the loop to deal with our first buffer of data (read in above to verify

   590      * that the file is a PNG image), then loop through the file and continue

   591      * calling the same routine to handle each chunk of data.  It in turn

   592      * passes the data to libpng, which will invoke one or more of our call-

   593      * backs as decoded data become available.  We optionally call sleep() for

   594      * one second per iteration to simulate downloading the image via an analog

   595      * modem. */

   596 

   597     for (;;) {

   598         Trace((stderr, "about to call readpng2_decode_data()\n"))

   599         if (readpng2_decode_data(&rpng2_info, inbuf, incount))

   600             ++error;

   601         Trace((stderr, "done with readpng2_decode_data()\n"))

   602 

   603         if (error || incount != INBUFSIZE || rpng2_info.state == kDone) {

   604             if (rpng2_info.state == kDone) {

   605                 Trace((stderr, "done decoding PNG image\n"))

   606             } else if (ferror(infile)) {

   607                 fprintf(stderr, PROGNAME

   608                   ":  error while reading PNG image file\n");

   609                 exit(3);

   610             } else if (feof(infile)) {

   611                 fprintf(stderr, PROGNAME ":  end of file reached "

   612                   "(unexpectedly) while reading PNG image file\n");

   613                 exit(3);

   614             } else /* if (error) */ {

   615                 // will print error message below

   616             }

   617             break;

   618         }

   619 

   620         if (timing)

   621             sleep(1);

   622 

   623         incount = fread(inbuf, 1, INBUFSIZE, infile);

   624     }

   625 

   626 

   627     /* clean up PNG stuff and report any decoding errors */

   628 

   629     fclose(infile);

   630     Trace((stderr, "about to call readpng2_cleanup()\n"))

   631     readpng2_cleanup(&rpng2_info);

   632 

   633     if (error) {

   634         fprintf(stderr, PROGNAME ":  libpng error while decoding PNG image\n");

   635         exit(3);

   636     }

   637 

   638 

   639 #ifdef FEATURE_LOOP

   640 

   641     if (loop && bg_image) {

   642         Trace((stderr, "entering -loop loop (FEATURE_LOOP)\n"))

   643         for (;;) {

   644             int i, use_sleep;

   645             struct timeval now, then;

   646 

   647             /* get current time and add loop_interval to get target time */

   648             if (gettimeofday(&then, NULL) == 0) {

   649                 then.tv_sec += loop_interval;

   650                 use_sleep = FALSE;

   651             } else

   652                 use_sleep = TRUE;

   653 

   654             /* do quick check for a quit event but don't wait for it */

   655             /* GRR BUG:  should also check for Expose events and redraw... */

   656             if (XCheckMaskEvent(display, KeyPressMask | ButtonPressMask, &e))

   657                 if (QUIT(e,k))

   658                     break;

   659 

   660             /* generate next background image */

   661             if (++pat >= num_bgpat)

   662                 pat = 0;

   663             rpng2_x_reload_bg_image();

   664 

   665             /* wait for timeout, using whatever means are available */

   666             if (use_sleep || gettimeofday(&now, NULL) != 0) {

   667                 for (i = loop_interval;  i > 0;  --i) {

   668                     sleep(1);

   669                     /* GRR BUG:  also need to check for Expose (and redraw!) */

   670                     if (XCheckMaskEvent(display, KeyPressMask | ButtonPressMask,

   671                         &e) && QUIT(e,k))

   672                         break;

   673                 }

   674             } else {

   675                 /* Y2038 BUG! */

   676                 if (now.tv_sec < then.tv_sec ||

   677                     (now.tv_sec == then.tv_sec && now.tv_usec < then.tv_usec))

   678                 {

   679                     int quit = FALSE;

   680                     long seconds_to_go = then.tv_sec - now.tv_sec;

   681                     long usleep_usec;

   682 

   683                     /* basically chew up most of remaining loop-interval with

   684                      *  calls to sleep(1) interleaved with checks for quit

   685                      *  events, but also recalc time-to-go periodically; when

   686                      *  done, clean up any remaining time with usleep() call

   687                      *  (could also use SIGALRM, but signals are a pain...) */

   688                     while (seconds_to_go-- > 1) {

   689                         int seconds_done = 0;

   690 

   691                         for (i = seconds_to_go;  i > 0 && !quit;  --i) {

   692                             sleep(1);

   693                             /* GRR BUG:  need to check for Expose and redraw */

   694                             if (XCheckMaskEvent(display, KeyPressMask |

   695                                 ButtonPressMask, &e) && QUIT(e,k))

   696                                 quit = TRUE;

   697                             if (++seconds_done > 1000)

   698                                 break;   /* time to redo seconds_to_go meas. */

   699                         }

   700                         if (quit)

   701                             break;

   702 

   703                         /* OK, more than 1000 seconds since last check:

   704                          *  correct the time-to-go measurement for drift */

   705                         if (gettimeofday(&now, NULL) == 0) {

   706                             if (now.tv_sec >= then.tv_sec)

   707                                 break;

   708                             seconds_to_go = then.tv_sec - now.tv_sec;

   709                         } else

   710                             ++seconds_to_go;  /* restore what we subtracted */

   711                     }

   712                     if (quit)

   713                         break;   /* breaks outer do-loop, skips redisplay */

   714 

   715                     /* since difference between "now" and "then" is already

   716                      *  eaten up to within a couple of seconds, don't need to

   717                      *  worry about overflow--but might have overshot (neg.) */

   718                     if (gettimeofday(&now, NULL) == 0) {

   719                         usleep_usec = 1000000L*(then.tv_sec - now.tv_sec) +

   720                           then.tv_usec - now.tv_usec;

   721                         if (usleep_usec > 0)

   722                             usleep((ulg)usleep_usec);

   723                     }

   724                 }

   725             }

   726 

   727             /* composite image against new background and display (note that

   728              *  we do not take into account the time spent doing this...) */

   729             rpng2_x_redisplay_image (0, 0, rpng2_info.width, rpng2_info.height);

   730         }

   731 

   732     } else /* FALL THROUGH and do the normal thing */

   733 

   734 #endif /* FEATURE_LOOP */

   735 

   736     /* wait for the user to tell us when to quit */

   737 

   738     if (rpng2_info.state >= kWindowInit) {

   739         Trace((stderr, "entering final wait-for-quit-event loop\n"))

   740         do {

   741             XNextEvent(display, &e);

   742             if (e.type == Expose) {

   743                 XExposeEvent *ex = (XExposeEvent *)&e;

   744                 rpng2_x_redisplay_image (ex->x, ex->y, ex->width, ex->height);

   745             }

   746         } while (!QUIT(e,k));

   747     } else {

   748         fprintf(stderr, PROGNAME ":  init callback never called:  probable "

   749           "libpng error while decoding PNG metadata\n");

   750         exit(4);

   751     }

   752 

   753 

   754     /* we're done:  clean up all image and X resources and go away */

   755 

   756     Trace((stderr, "about to call rpng2_x_cleanup()\n"))

   757     rpng2_x_cleanup();

   758 

   759     return 0;

   760 }

   761 

   762 

   763 

   764 

   765 

   766 /* this function is called by readpng2_info_callback() in readpng2.c, which

   767  * in turn is called by libpng after all of the pre-IDAT chunks have been

   768  * read and processed--i.e., we now have enough info to finish initializing */

   769 

   770 static void rpng2_x_init(void)

   771 {

   772     ulg i;

   773     ulg rowbytes = rpng2_info.rowbytes;

   774 

   775     Trace((stderr, "beginning rpng2_x_init()\n"))

   776     Trace((stderr, "  rowbytes = %d\n", rpng2_info.rowbytes))

   777     Trace((stderr, "  width  = %ld\n", rpng2_info.width))

   778     Trace((stderr, "  height = %ld\n", rpng2_info.height))

   779 

   780     rpng2_info.image_data = (uch *)malloc(rowbytes * rpng2_info.height);

   781     if (!rpng2_info.image_data) {

   782         readpng2_cleanup(&rpng2_info);

   783         return;

   784     }

   785 

   786     rpng2_info.row_pointers = (uch **)malloc(rpng2_info.height * sizeof(uch *));

   787     if (!rpng2_info.row_pointers) {

   788         free(rpng2_info.image_data);

   789         rpng2_info.image_data = NULL;

   790         readpng2_cleanup(&rpng2_info);

   791         return;

   792     }

   793 

   794     for (i = 0;  i < rpng2_info.height;  ++i)

   795         rpng2_info.row_pointers[i] = rpng2_info.image_data + i*rowbytes;

   796 

   797 

   798     /* do the basic X initialization stuff, make the window, and fill it with

   799      * the user-specified, file-specified or default background color or

   800      * pattern */

   801 

   802     if (rpng2_x_create_window()) {

   803 

   804         /* GRR TEMPORARY HACK:  this is fundamentally no different from cases

   805          * above; libpng should longjmp() back to us when png_ptr goes away.

   806          * If we/it segfault instead, seems like a libpng bug... */

   807 

   808         /* we're here via libpng callback, so if window fails, clean and bail */

   809         readpng2_cleanup(&rpng2_info);

   810         rpng2_x_cleanup();

   811         exit(2);

   812     }

   813 

   814     rpng2_info.state = kWindowInit;

   815 }

   816 

   817 

   818 

   819 

   820 

   821 static int rpng2_x_create_window(void)

   822 {

   823     ulg bg_red   = rpng2_info.bg_red;

   824     ulg bg_green = rpng2_info.bg_green;

   825     ulg bg_blue  = rpng2_info.bg_blue;

   826     ulg bg_pixel = 0L;

   827     ulg attrmask;

   828     int need_colormap = FALSE;

   829     int screen, pad;

   830     uch *xdata;

   831     Window root;

   832     XEvent e;

   833     XGCValues gcvalues;

   834     XSetWindowAttributes attr;

   835     XTextProperty windowName, *pWindowName = &windowName;

   836     XTextProperty iconName, *pIconName = &iconName;

   837     XVisualInfo visual_info;

   838     XSizeHints *size_hints;

   839     XWMHints *wm_hints;

   840     XClassHint *class_hints;

   841 

   842 

   843     Trace((stderr, "beginning rpng2_x_create_window()\n"))

   844 

   845     screen = DefaultScreen(display);

   846     depth = DisplayPlanes(display, screen);

   847     root = RootWindow(display, screen);

   848 

   849 #ifdef DEBUG

   850     XSynchronize(display, True);

   851 #endif

   852 

   853     if (depth != 16 && depth != 24 && depth != 32) {

   854         int visuals_matched = 0;

   855 

   856         Trace((stderr, "default depth is %d:  checking other visuals\n",

   857           depth))

   858 

   859         /* 24-bit first */

   860         visual_info.screen = screen;

   861         visual_info.depth = 24;

   862         visual_list = XGetVisualInfo(display,

   863           VisualScreenMask | VisualDepthMask, &visual_info, &visuals_matched);

   864         if (visuals_matched == 0) {

   865 /* GRR:  add 15-, 16- and 32-bit TrueColor visuals (also DirectColor?) */

   866             fprintf(stderr, "default screen depth %d not supported, and no"

   867               " 24-bit visuals found\n", depth);

   868             return 2;

   869         }

   870         Trace((stderr, "XGetVisualInfo() returned %d 24-bit visuals\n",

   871           visuals_matched))

   872         visual = visual_list[0].visual;

   873         depth = visual_list[0].depth;

   874 /*

   875         colormap_size = visual_list[0].colormap_size;

   876         visual_class = visual->class;

   877         visualID = XVisualIDFromVisual(visual);

   878  */

   879         have_nondefault_visual = TRUE;

   880         need_colormap = TRUE;

   881     } else {

   882         XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info);

   883         visual = visual_info.visual;

   884     }

   885 

   886     RMask = visual->red_mask;

   887     GMask = visual->green_mask;

   888     BMask = visual->blue_mask;

   889 

   890 /* GRR:  add/check 8-bit support */

   891     if (depth == 8 || need_colormap) {

   892         colormap = XCreateColormap(display, root, visual, AllocNone);

   893         if (!colormap) {

   894             fprintf(stderr, "XCreateColormap() failed\n");

   895             return 2;

   896         }

   897         have_colormap = TRUE;

   898         if (depth == 8)

   899             bg_image = FALSE;   /* gradient just wastes palette entries */

   900     }

   901     if (depth == 15 || depth == 16) {

   902         RShift = 15 - rpng2_x_msb(RMask);    /* these are right-shifts */

   903         GShift = 15 - rpng2_x_msb(GMask);

   904         BShift = 15 - rpng2_x_msb(BMask);

   905     } else if (depth > 16) {

   906         RShift = rpng2_x_msb(RMask) - 7;     /* these are left-shifts */

   907         GShift = rpng2_x_msb(GMask) - 7;

   908         BShift = rpng2_x_msb(BMask) - 7;

   909     }

   910     if (depth >= 15 && (RShift < 0 || GShift < 0 || BShift < 0)) {

   911         fprintf(stderr, "rpng2 internal logic error:  negative X shift(s)!\n");

   912         return 2;

   913     }

   914 

   915 /*---------------------------------------------------------------------------

   916     Finally, create the window.

   917   ---------------------------------------------------------------------------*/

   918 

   919     attr.backing_store = Always;

   920     attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;

   921     attrmask = CWBackingStore | CWEventMask;

   922     if (have_nondefault_visual) {

   923         attr.colormap = colormap;

   924         attr.background_pixel = 0;

   925         attr.border_pixel = 1;

   926         attrmask |= CWColormap | CWBackPixel | CWBorderPixel;

   927     }

   928 

   929     window = XCreateWindow(display, root, 0, 0, rpng2_info.width,

   930       rpng2_info.height, 0, depth, InputOutput, visual, attrmask, &attr);

   931 

   932     if (window == None) {

   933         fprintf(stderr, "XCreateWindow() failed\n");

   934         return 2;

   935     } else

   936         have_window = TRUE;

   937 

   938     if (depth == 8)

   939         XSetWindowColormap(display, window, colormap);

   940 

   941     if (!XStringListToTextProperty(&window_name, 1, pWindowName))

   942         pWindowName = NULL;

   943     if (!XStringListToTextProperty(&icon_name, 1, pIconName))

   944         pIconName = NULL;

   945 

   946     /* OK if either hints allocation fails; XSetWMProperties() allows NULLs */

   947 

   948     if ((size_hints = XAllocSizeHints()) != NULL) {

   949         /* window will not be resizable */

   950         size_hints->flags = PMinSize | PMaxSize;

   951         size_hints->min_width = size_hints->max_width = (int)rpng2_info.width;

   952         size_hints->min_height = size_hints->max_height =

   953           (int)rpng2_info.height;

   954     }

   955 

   956     if ((wm_hints = XAllocWMHints()) != NULL) {

   957         wm_hints->initial_state = NormalState;

   958         wm_hints->input = True;

   959      /* wm_hints->icon_pixmap = icon_pixmap; */

   960         wm_hints->flags = StateHint | InputHint  /* | IconPixmapHint */ ;

   961     }

   962 

   963     if ((class_hints = XAllocClassHint()) != NULL) {

   964         class_hints->res_name = res_name;

   965         class_hints->res_class = res_class;

   966     }

   967 

   968     XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0,

   969       size_hints, wm_hints, class_hints);

   970 

   971     /* various properties and hints no longer needed; free memory */

   972     if (pWindowName)

   973        XFree(pWindowName->value);

   974     if (pIconName)

   975        XFree(pIconName->value);

   976     if (size_hints)

   977         XFree(size_hints);

   978     if (wm_hints)

   979        XFree(wm_hints);

   980     if (class_hints)

   981        XFree(class_hints);

   982 

   983     XMapWindow(display, window);

   984 

   985     gc = XCreateGC(display, window, 0, &gcvalues);

   986     have_gc = TRUE;

   987 

   988 /*---------------------------------------------------------------------------

   989     Allocate memory for the X- and display-specific version of the image.

   990   ---------------------------------------------------------------------------*/

   991 

   992     if (depth == 24 || depth == 32) {

   993         xdata = (uch *)malloc(4*rpng2_info.width*rpng2_info.height);

   994         pad = 32;

   995     } else if (depth == 16) {

   996         xdata = (uch *)malloc(2*rpng2_info.width*rpng2_info.height);

   997         pad = 16;

   998     } else /* depth == 8 */ {

   999         xdata = (uch *)malloc(rpng2_info.width*rpng2_info.height);

  1000         pad = 8;

  1001     }

  1002 

  1003     if (!xdata) {

  1004         fprintf(stderr, PROGNAME ":  unable to allocate image memory\n");

  1005         return 4;

  1006     }

  1007 

  1008     ximage = XCreateImage(display, visual, depth, ZPixmap, 0,

  1009       (char *)xdata, rpng2_info.width, rpng2_info.height, pad, 0);

  1010 

  1011     if (!ximage) {

  1012         fprintf(stderr, PROGNAME ":  XCreateImage() failed\n");

  1013         free(xdata);

  1014         return 3;

  1015     }

  1016 

  1017     /* to avoid testing the byte order every pixel (or doubling the size of

  1018      * the drawing routine with a giant if-test), we arbitrarily set the byte

  1019      * order to MSBFirst and let Xlib worry about inverting things on little-

  1020      * endian machines (e.g., Linux/x86, old VAXen, etc.)--this is not the

  1021      * most efficient approach (the giant if-test would be better), but in

  1022      * the interest of clarity, we'll take the easy way out... */

  1023 

  1024     ximage->byte_order = MSBFirst;

  1025 

  1026 /*---------------------------------------------------------------------------

  1027     Fill window with the specified background color (default is black) or

  1028     faked "background image" (but latter is disabled if 8-bit; gradients

  1029     just waste palette entries).

  1030   ---------------------------------------------------------------------------*/

  1031 

  1032     if (bg_image)

  1033         rpng2_x_load_bg_image();    /* resets bg_image if fails */

  1034 

  1035     if (!bg_image) {

  1036         if (depth == 24 || depth == 32) {

  1037             bg_pixel = (bg_red   << RShift) |

  1038                        (bg_green << GShift) |

  1039                        (bg_blue  << BShift);

  1040         } else if (depth == 16) {

  1041             bg_pixel = (((bg_red   << 8) >> RShift) & RMask) |

  1042                        (((bg_green << 8) >> GShift) & GMask) |

  1043                        (((bg_blue  << 8) >> BShift) & BMask);

  1044         } else /* depth == 8 */ {

  1045 

  1046             /* GRR:  add 8-bit support */

  1047 

  1048         }

  1049         XSetForeground(display, gc, bg_pixel);

  1050         XFillRectangle(display, window, gc, 0, 0, rpng2_info.width,

  1051           rpng2_info.height);

  1052     }

  1053 

  1054 /*---------------------------------------------------------------------------

  1055     Wait for first Expose event to do any drawing, then flush and return.

  1056   ---------------------------------------------------------------------------*/

  1057 

  1058     do

  1059         XNextEvent(display, &e);

  1060     while (e.type != Expose || e.xexpose.count);

  1061 

  1062     XFlush(display);

  1063 

  1064     return 0;

  1065 

  1066 } /* end function rpng2_x_create_window() */

  1067 

  1068 

  1069 

  1070 

  1071 

  1072 static int rpng2_x_load_bg_image(void)

  1073 {

  1074     uch *src;

  1075     char *dest;

  1076     uch r1, r2, g1, g2, b1, b2;

  1077     uch r1_inv, r2_inv, g1_inv, g2_inv, b1_inv, b2_inv;

  1078     int k, hmax, max;

  1079     int xidx, yidx, yidx_max;

  1080     int even_odd_vert, even_odd_horiz, even_odd;

  1081     int invert_gradient2 = (bg[pat].type & 0x08);

  1082     int invert_column;

  1083     int ximage_rowbytes = ximage->bytes_per_line;

  1084     ulg i, row;

  1085     ulg pixel;

  1086 

  1087 /*---------------------------------------------------------------------------

  1088     Allocate buffer for fake background image to be used with transparent

  1089     images; if this fails, revert to plain background color.

  1090   ---------------------------------------------------------------------------*/

  1091 

  1092     bg_rowbytes = 3 * rpng2_info.width;

  1093     bg_data = (uch *)malloc(bg_rowbytes * rpng2_info.height);

  1094     if (!bg_data) {

  1095         fprintf(stderr, PROGNAME

  1096           ":  unable to allocate memory for background image\n");

  1097         bg_image = 0;

  1098         return 1;

  1099     }

  1100 

  1101     bgscale = (pat == 0)? 8 : bgscale_default;

  1102     yidx_max = bgscale - 1;

  1103 

  1104 /*---------------------------------------------------------------------------

  1105     Vertical gradients (ramps) in NxN squares, alternating direction and

  1106     colors (N == bgscale).

  1107   ---------------------------------------------------------------------------*/

  1108 

  1109     if ((bg[pat].type & 0x07) == 0) {

  1110         uch r1_min  = rgb[bg[pat].rgb1_min].r;

  1111         uch g1_min  = rgb[bg[pat].rgb1_min].g;

  1112         uch b1_min  = rgb[bg[pat].rgb1_min].b;

  1113         uch r2_min  = rgb[bg[pat].rgb2_min].r;

  1114         uch g2_min  = rgb[bg[pat].rgb2_min].g;

  1115         uch b2_min  = rgb[bg[pat].rgb2_min].b;

  1116         int r1_diff = rgb[bg[pat].rgb1_max].r - r1_min;

  1117         int g1_diff = rgb[bg[pat].rgb1_max].g - g1_min;

  1118         int b1_diff = rgb[bg[pat].rgb1_max].b - b1_min;

  1119         int r2_diff = rgb[bg[pat].rgb2_max].r - r2_min;

  1120         int g2_diff = rgb[bg[pat].rgb2_max].g - g2_min;

  1121         int b2_diff = rgb[bg[pat].rgb2_max].b - b2_min;

  1122 

  1123         for (row = 0;  row < rpng2_info.height;  ++row) {

  1124             yidx = (int)(row % bgscale);

  1125             even_odd_vert = (int)((row / bgscale) & 1);

  1126 

  1127             r1 = r1_min + (r1_diff * yidx) / yidx_max;

  1128             g1 = g1_min + (g1_diff * yidx) / yidx_max;

  1129             b1 = b1_min + (b1_diff * yidx) / yidx_max;

  1130             r1_inv = r1_min + (r1_diff * (yidx_max-yidx)) / yidx_max;

  1131             g1_inv = g1_min + (g1_diff * (yidx_max-yidx)) / yidx_max;

  1132             b1_inv = b1_min + (b1_diff * (yidx_max-yidx)) / yidx_max;

  1133 

  1134             r2 = r2_min + (r2_diff * yidx) / yidx_max;

  1135             g2 = g2_min + (g2_diff * yidx) / yidx_max;