开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
rpng2-win.c
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：45k
源码类别：

界面编程

开发平台：

Visual C++

rpng2-win.c：源码内容
  1. /*---------------------------------------------------------------------------
  3.    rpng2 - progressive-model PNG display program                rpng2-win.c
  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 32-bit Windows; it may compile under 16-bit Windows with a little
  10.    tweaking (or maybe not).  Thanks to Adam Costello and Pieter S. van der
  11.    Meulen for the "diamond" and "radial waves" patterns, respectively.
  13.    to do (someday, maybe):
  14.     - handle quoted command-line args (especially filenames with spaces)
  15.     - finish resizable checkerboard-gradient (sizes 4-128?)
  16.     - use %.1023s to simplify truncation of title-bar string?
  17.     - have minimum window width:  oh well
  19.   ---------------------------------------------------------------------------
  21.    Changelog:
  22.     - 1.01:  initial public release
  23.     - 1.02:  fixed cut-and-paste error in usage screen (oops...)
  24.     - 1.03:  modified to allow abbreviated options
  25.     - 1.04:  removed bogus extra argument from usage fprintf() [Glenn R-P?];
  26.               fixed command-line parsing bug
  27.     - 1.10:  enabled "message window"/console (thanks to David Geldreich)
  28.     - 1.20:  added runtime MMX-enabling/disabling and new -mmx* options
  29.     - 1.21:  made minor tweak to usage screen to fit within 25-line console
  30.     - 1.22:  added AMD64/EM64T support (__x86_64__)
  31.     - 2.00:  dual-licensed (added GNU GPL)
  32.     - 2.01:  fixed 64-bit typo in readpng2.c
  33.     - 2.02:  fixed improper display of usage screen on PNG error(s); fixed
  34.               unexpected-EOF and file-read-error cases
  36.   ---------------------------------------------------------------------------
  38.       Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
  40.       This software is provided "as is," without warranty of any kind,
  41.       express or implied.  In no event shall the author or contributors
  42.       be held liable for any damages arising in any way from the use of
  43.       this software.
  45.       The contents of this file are DUAL-LICENSED.  You may modify and/or
  46.       redistribute this software according to the terms of one of the
  47.       following two licenses (at your option):
  50.       LICENSE 1 ("BSD-like with advertising clause"):
  52.       Permission is granted to anyone to use this software for any purpose,
  53.       including commercial applications, and to alter it and redistribute
  54.       it freely, subject to the following restrictions:
  56.       1. Redistributions of source code must retain the above copyright
  57.          notice, disclaimer, and this list of conditions.
  58.       2. Redistributions in binary form must reproduce the above copyright
  59.          notice, disclaimer, and this list of conditions in the documenta-
  60.          tion and/or other materials provided with the distribution.
  61.       3. All advertising materials mentioning features or use of this
  62.          software must display the following acknowledgment:
  64.             This product includes software developed by Greg Roelofs
  65.             and contributors for the book, "PNG: The Definitive Guide,"
  66.             published by O'Reilly and Associates.
  69.       LICENSE 2 (GNU GPL v2 or later):
  71.       This program is free software; you can redistribute it and/or modify
  72.       it under the terms of the GNU General Public License as published by
  73.       the Free Software Foundation; either version 2 of the License, or
  74.       (at your option) any later version.
  76.       This program is distributed in the hope that it will be useful,
  77.       but WITHOUT ANY WARRANTY; without even the implied warranty of
  78.       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  79.       GNU General Public License for more details.
  81.       You should have received a copy of the GNU General Public License
  82.       along with this program; if not, write to the Free Software Foundation,
  83.       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  85.   ---------------------------------------------------------------------------*/
  87. #define PROGNAME  "rpng2-win"
  88. #define LONGNAME  "Progressive PNG Viewer for Windows"
  89. #define VERSION   "2.02 of 16 March 2008"
  91. #include <stdio.h>
  92. #include <stdlib.h>
  93. #include <string.h>
  94. #include <setjmp.h>    /* for jmpbuf declaration in readpng2.h */
  95. #include <time.h>
  96. #include <math.h>      /* only for PvdM background code */
  97. #include <windows.h>
  98. #include <conio.h>     /* only for _getch() */
  100. /* all for PvdM background code: */
  101. #ifndef PI
  102. #  define PI             3.141592653589793238
  103. #endif
  104. #define PI_2             (PI*0.5)
  105. #define INV_PI_360       (360.0 / PI)
  106. #define MAX(a,b)         (a>b?a:b)
  107. #define MIN(a,b)         (a<b?a:b)
  108. #define CLIP(a,min,max)  MAX(min,MIN((a),max))
  109. #define ABS(a)           ((a)<0?-(a):(a))
  110. #define CLIP8P(c)        MAX(0,(MIN((c),255)))   /* 8-bit pos. integer (uch) */
  111. #define ROUNDF(f)        ((int)(f + 0.5))
  113. #define rgb1_max   bg_freq
  114. #define rgb1_min   bg_gray
  115. #define rgb2_max   bg_bsat
  116. #define rgb2_min   bg_brot
  118. /* #define DEBUG */     /* this enables the Trace() macros */
  120. #include "readpng2.h"   /* typedefs, common macros, readpng2 prototypes */
  123. /* could just include png.h, but this macro is the only thing we need
  124.  * (name and typedefs changed to local versions); note that side effects
  125.  * only happen with alpha (which could easily be avoided with
  126.  * "ush acopy = (alpha);") */
  128. #define alpha_composite(composite, fg, alpha, bg) {               
  129.     ush temp = ((ush)(fg)*(ush)(alpha) +                          
  130.                 (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  
  131.     (composite) = (uch)((temp + (temp >> 8)) >> 8);               
  132. }
  135. #define INBUFSIZE 4096   /* with pseudo-timing on (1 sec delay/block), this
  136.                           *  block size corresponds roughly to a download
  137.                           *  speed 10% faster than theoretical 33.6K maximum
  138.                           *  (assuming 8 data bits, 1 stop bit and no other
  139.                           *  overhead) */
  141. /* local prototypes */
  142. static void       rpng2_win_init(void);
  143. static int        rpng2_win_create_window(void);
  144. static int        rpng2_win_load_bg_image(void);
  145. static void       rpng2_win_display_row(ulg row);
  146. static void       rpng2_win_finish_display(void);
  147. static void       rpng2_win_cleanup(void);
  148. LRESULT CALLBACK  rpng2_win_wndproc(HWND, UINT, WPARAM, LPARAM);
  151. static char titlebar[1024];
  152. static char *progname = PROGNAME;
  153. static char *appname = LONGNAME;
  154. static char *filename;
  155. static FILE *infile;
  157. static mainprog_info rpng2_info;
  159. static uch inbuf[INBUFSIZE];
  160. static int incount;
  162. static int pat = 6;         /* must be less than num_bgpat */
  163. static int bg_image = 0;
  164. static int bgscale = 16;
  165. static ulg bg_rowbytes;
  166. static uch *bg_data;
  168. static struct rgb_color {
  169.     uch r, g, b;
  170. } rgb[] = {
  171.     {  0,   0,   0},    /*  0:  black */
  172.     {255, 255, 255},    /*  1:  white */
  173.     {173, 132,  57},    /*  2:  tan */
  174.     { 64, 132,   0},    /*  3:  medium green */
  175.     {189, 117,   1},    /*  4:  gold */
  176.     {253, 249,   1},    /*  5:  yellow */
  177.     {  0,   0, 255},    /*  6:  blue */
  178.     {  0,   0, 120},    /*  7:  medium blue */
  179.     {255,   0, 255},    /*  8:  magenta */
  180.     { 64,   0,  64},    /*  9:  dark magenta */
  181.     {255,   0,   0},    /* 10:  red */
  182.     { 64,   0,   0},    /* 11:  dark red */
  183.     {255, 127,   0},    /* 12:  orange */
  184.     {192,  96,   0},    /* 13:  darker orange */
  185.     { 24,  60,   0},    /* 14:  dark green-yellow */
  186.     { 85, 125, 200}     /* 15:  ice blue */
  187. };
  188. /* not used for now, but should be for error-checking:
  189. static int num_rgb = sizeof(rgb) / sizeof(struct rgb_color);
  190.  */
  192. /*
  193.     This whole struct is a fairly cheesy way to keep the number of
  194.     command-line options to a minimum.  The radial-waves background
  195.     type is a particularly poor fit to the integer elements of the
  196.     struct...but a few macros and a little fixed-point math will do
  197.     wonders for ya.
  199.     type bits:
  200.        F E D C B A 9 8 7 6 5 4 3 2 1 0
  201.                              | | | | |
  202.                              | | +-+-+-- 0 = sharp-edged checkerboard
  203.                              | |         1 = soft diamonds
  204.                              | |         2 = radial waves
  205.                              | |       3-7 = undefined
  206.                              | +-- gradient #2 inverted?
  207.                              +-- alternating columns inverted?
  208.  */
  209. static struct background_pattern {
  210.     ush type;
  211.     int rgb1_max, rgb1_min;     /* or bg_freq, bg_gray */
  212.     int rgb2_max, rgb2_min;     /* or bg_bsat, bg_brot (both scaled by 10)*/
  213. } bg[] = {
  214.     {0+8,   2,0,  1,15},        /* checkered:  tan/black vs. white/ice blue */
  215.     {0+24,  2,0,  1,0},         /* checkered:  tan/black vs. white/black */
  216.     {0+8,   4,5,  0,2},         /* checkered:  gold/yellow vs. black/tan */
  217.     {0+8,   4,5,  0,6},         /* checkered:  gold/yellow vs. black/blue */
  218.     {0,     7,0,  8,9},         /* checkered:  deep blue/black vs. magenta */
  219.     {0+8,  13,0,  5,14},        /* checkered:  orange/black vs. yellow */
  220.     {0+8,  12,0, 10,11},        /* checkered:  orange/black vs. red */
  221.     {1,     7,0,  8,0},         /* diamonds:  deep blue/black vs. magenta */
  222.     {1,    12,0, 11,0},         /* diamonds:  orange vs. dark red */
  223.     {1,    10,0,  7,0},         /* diamonds:  red vs. medium blue */
  224.     {1,     4,0,  5,0},         /* diamonds:  gold vs. yellow */
  225.     {1,     3,0,  0,0},         /* diamonds:  medium green vs. black */
  226.     {2,    16, 100,  20,   0},  /* radial:  ~hard radial color-beams */
  227.     {2,    18, 100,  10,   2},  /* radial:  soft, curved radial color-beams */
  228.     {2,    16, 256, 100, 250},  /* radial:  very tight spiral */
  229.     {2, 10000, 256,  11,   0}   /* radial:  dipole-moire' (almost fractal) */
  230. };
  231. static int num_bgpat = sizeof(bg) / sizeof(struct background_pattern);
  234. /* Windows-specific global variables (could go in struct, but messy...) */
  235. static ulg wimage_rowbytes;
  236. static uch *dib;
  237. static uch *wimage_data;
  238. static BITMAPINFOHEADER *bmih;
  240. static HWND global_hwnd;
  241. static HINSTANCE global_hInst;
  242. static int global_showmode;
  247. int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
  248. {
  249.     char *args[1024];                 /* arbitrary limit, but should suffice */
  250.     char **argv = args;
  251.     char *p, *q, *bgstr = NULL;
  252.     int argc = 0;
  253.     int rc, alen, flen;
  254.     int error = 0;
  255.     int timing = FALSE;
  256.     int have_bg = FALSE;
  257.     double LUT_exponent;              /* just the lookup table */
  258.     double CRT_exponent = 2.2;        /* just the monitor */
  259.     double default_display_exponent;  /* whole display system */
  260.     MSG msg;
  263.     /* First initialize a few things, just to be sure--memset takes care of
  264.      * default background color (black), booleans (FALSE), pointers (NULL),
  265.      * etc. */
  267.     global_hInst = hInst;
  268.     global_showmode = showmode;
  269.     filename = (char *)NULL;
  270.     memset(&rpng2_info, 0, sizeof(mainprog_info));
  273.     /* Next reenable console output, which normally goes to the bit bucket
  274.      * for windowed apps.  Closing the console window will terminate the
  275.      * app.  Thanks to David.Geldreich@realviz.com for supplying the magical
  276.      * incantation. */
  278.     AllocConsole();
  279.     freopen("CONOUT$", "a", stderr);
  280.     freopen("CONOUT$", "a", stdout);
  283.     /* Set the default value for our display-system exponent, i.e., the
  284.      * product of the CRT exponent and the exponent corresponding to
  285.      * the frame-buffer's lookup table (LUT), if any.  This is not an
  286.      * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
  287.      * ones), but it should cover 99% of the current possibilities.  And
  288.      * yes, these ifdefs are completely wasted in a Windows program... */
  290. #if defined(NeXT)
  291.     /* third-party utilities can modify the default LUT exponent */
  292.     LUT_exponent = 1.0 / 2.2;
  293.     /*
  294.     if (some_next_function_that_returns_gamma(&next_gamma))
  295.         LUT_exponent = 1.0 / next_gamma;
  296.      */
  297. #elif defined(sgi)
  298.     LUT_exponent = 1.0 / 1.7;
  299.     /* there doesn't seem to be any documented function to
  300.      * get the "gamma" value, so we do it the hard way */
  301.     infile = fopen("/etc/config/system.glGammaVal", "r");
  302.     if (infile) {
  303.         double sgi_gamma;
  305.         fgets(tmpline, 80, infile);
  306.         fclose(infile);
  307.         sgi_gamma = atof(tmpline);
  308.         if (sgi_gamma > 0.0)
  309.             LUT_exponent = 1.0 / sgi_gamma;
  310.     }
  311. #elif defined(Macintosh)
  312.     LUT_exponent = 1.8 / 2.61;
  313.     /*
  314.     if (some_mac_function_that_returns_gamma(&mac_gamma))
  315.         LUT_exponent = mac_gamma / 2.61;
  316.      */
  317. #else
  318.     LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
  319. #endif
  321.     /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
  322.     default_display_exponent = LUT_exponent * CRT_exponent;
  325.     /* If the user has set the SCREEN_GAMMA environment variable as suggested
  326.      * (somewhat imprecisely) in the libpng documentation, use that; otherwise
  327.      * use the default value we just calculated.  Either way, the user may
  328.      * override this via a command-line option. */
  330.     if ((p = getenv("SCREEN_GAMMA")) != NULL)
  331.         rpng2_info.display_exponent = atof(p);
  332.     else
  333.         rpng2_info.display_exponent = default_display_exponent;
  336.     /* Windows really hates command lines, so we have to set up our own argv.
  337.      * Note that we do NOT bother with quoted arguments here, so don't use
  338.      * filenames with spaces in 'em! */
  340.     argv[argc++] = PROGNAME;
  341.     p = cmd;
  342.     for (;;) {
  343.         if (*p == ' ')
  344.             while (*++p == ' ')
  345.                 ;
  346.         /* now p points at the first non-space after some spaces */
  347.         if (*p == '')
  348.             break;    /* nothing after the spaces:  done */
  349.         argv[argc++] = q = p;
  350.         while (*q && *q != ' ')
  351.             ++q;
  352.         /* now q points at a space or the end of the string */
  353.         if (*q == '')
  354.             break;    /* last argv already terminated; quit */
  355.         *q = '';    /* change space to terminator */
  356.         p = q + 1;
  357.     }
  358.     argv[argc] = NULL;   /* terminate the argv array itself */
  361.     /* Now parse the command line for options and the PNG filename. */
  363.     while (*++argv && !error) {
  364.         if (!strncmp(*argv, "-gamma", 2)) {
  365.             if (!*++argv)
  366.                 ++error;
  367.             else {
  368.                 rpng2_info.display_exponent = atof(*argv);
  369.                 if (rpng2_info.display_exponent <= 0.0)
  370.                     ++error;
  371.             }
  372.         } else if (!strncmp(*argv, "-bgcolor", 4)) {
  373.             if (!*++argv)
  374.                 ++error;
  375.             else {
  376.                 bgstr = *argv;
  377.                 if (strlen(bgstr) != 7 || bgstr[0] != '#')
  378.                     ++error;
  379.                 else {
  380.                     have_bg = TRUE;
  381.                     bg_image = FALSE;
  382.                 }
  383.             }
  384.         } else if (!strncmp(*argv, "-bgpat", 4)) {
  385.             if (!*++argv)
  386.                 ++error;
  387.             else {
  388.                 pat = atoi(*argv) - 1;
  389.                 if (pat < 0 || pat >= num_bgpat)
  390.                     ++error;
  391.                 else {
  392.                     bg_image = TRUE;
  393.                     have_bg = FALSE;
  394.                 }
  395.             }
  396.         } else if (!strncmp(*argv, "-timing", 2)) {
  397.             timing = TRUE;
  398. #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
  399.         } else if (!strncmp(*argv, "-nommxfilters", 7)) {
  400.             rpng2_info.nommxfilters = TRUE;
  401.         } else if (!strncmp(*argv, "-nommxcombine", 7)) {
  402.             rpng2_info.nommxcombine = TRUE;
  403.         } else if (!strncmp(*argv, "-nommxinterlace", 7)) {
  404.             rpng2_info.nommxinterlace = TRUE;
  405.         } else if (!strcmp(*argv, "-nommx")) {
  406.             rpng2_info.nommxfilters = TRUE;
  407.             rpng2_info.nommxcombine = TRUE;
  408.             rpng2_info.nommxinterlace = TRUE;
  409. #endif
  410.         } else {
  411.             if (**argv != '-') {
  412.                 filename = *argv;
  413.                 if (argv[1])   /* shouldn't be any more args after filename */
  414.                     ++error;
  415.             } else
  416.                 ++error;   /* not expecting any other options */
  417.         }
  418.     }
  420.     if (!filename)
  421.         ++error;
  424.     /* print usage screen if any errors up to this point */
  426.     if (error) {
  427.         int ch;
  429.         fprintf(stderr, "n%s %s:  %snn", PROGNAME, VERSION, appname);
  430.         readpng2_version_info();
  431.         fprintf(stderr, "n"
  432.           "Usage:  %s [-gamma exp] [-bgcolor bg | -bgpat pat] [-timing]n"
  433. #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
  434.           "        %*s [[-nommxfilters] [-nommxcombine] [-nommxinterlace] | -nommx]n"
  435. #endif
  436.           "        %*s file.pngnn"
  437.           "    exp ttransfer-function exponent (``gamma'') of the displayn"
  438.           "tt  system in floating-point format (e.g., ``%.1f''); equaln"
  439.           "tt  to the product of the lookup-table exponent (varies)n"
  440.           "tt  and the CRT exponent (usually 2.2); must be positiven"
  441.           "    bg  tdesired background color in 7-character hex RGB formatn"
  442.           "tt  (e.g., ``#ff7700'' for orange:  same as HTML colors);n"
  443.           "tt  used with transparent images; overrides -bgpat optionn"
  444.           "    pat tdesired background pattern number (1-%d); used withn"
  445.           "tt  transparent images; overrides -bgcolor optionn"
  446.           "    -timingtenables delay for every block read, to simulate modemn"
  447.           "tt  download of image (~36 Kbps)n"
  448. #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
  449.           "    -nommx*tdisable optimized MMX routines for decoding row filters,n"
  450.           "tt  combining rows, and expanding interlacing, respectivelyn"
  451. #endif
  452.           "nPress Q, Esc or mouse button 1 after image is displayed to quit.n"
  453.           "Press Q or Esc to quit this usage screen. ",
  454.           PROGNAME,
  455. #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
  456.           (int)strlen(PROGNAME), " ",
  457. #endif
  458.           (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat);
  459.         fflush(stderr);
  460.         do
  461.             ch = _getch();
  462.         while (ch != 'q' && ch != 'Q' && ch != 0x1B);
  463.         exit(1);
  464.     }
  467.     if (!(infile = fopen(filename, "rb"))) {
  468.         fprintf(stderr, PROGNAME ":  can't open PNG file [%s]n", filename);
  469.         ++error;
  470.     } else {
  471.         incount = fread(inbuf, 1, INBUFSIZE, infile);
  472.         if (incount < 8 || !readpng2_check_sig(inbuf, 8)) {
  473.             fprintf(stderr, PROGNAME
  474.               ":  [%s] is not a PNG file: incorrect signaturen",
  475.               filename);
  476.             ++error;
  477.         } else if ((rc = readpng2_init(&rpng2_info)) != 0) {
  478.             switch (rc) {
  479.                 case 2:
  480.                     fprintf(stderr, PROGNAME
  481.                       ":  [%s] has bad IHDR (libpng longjmp)n", filename);
  482.                     break;
  483.                 case 4:
  484.                     fprintf(stderr, PROGNAME ":  insufficient memoryn");
  485.                     break;
  486.                 default:
  487.                     fprintf(stderr, PROGNAME
  488.                       ":  unknown readpng2_init() errorn");
  489.                     break;
  490.             }
  491.             ++error;
  492.         }
  493.         if (error)
  494.             fclose(infile);
  495.     }
  498.     if (error) {
  499.         int ch;
  501.         fprintf(stderr, PROGNAME ":  aborting.n");
  502.         do
  503.             ch = _getch();
  504.         while (ch != 'q' && ch != 'Q' && ch != 0x1B);
  505.         exit(2);
  506.     } else {
  507.         fprintf(stderr, "n%s %s:  %sn", PROGNAME, VERSION, appname);
  508.         fprintf(stderr,
  509.           "n   [console window:  closing this window will terminate %s]nn",
  510.           PROGNAME);
  511.         fflush(stderr);
  512.     }
  515.     /* set the title-bar string, but make sure buffer doesn't overflow */
  517.     alen = strlen(appname);
  518.     flen = strlen(filename);
  519.     if (alen + flen + 3 > 1023)
  520.         sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
  521.     else
  522.         sprintf(titlebar, "%s:  %s", appname, filename);
  525.     /* set some final rpng2_info variables before entering main data loop */
  527.     if (have_bg) {
  528.         unsigned r, g, b;   /* this approach quiets compiler warnings */
  530.         sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
  531.         rpng2_info.bg_red   = (uch)r;
  532.         rpng2_info.bg_green = (uch)g;
  533.         rpng2_info.bg_blue  = (uch)b;
  534.     } else
  535.         rpng2_info.need_bgcolor = TRUE;
  537.     rpng2_info.state = kPreInit;
  538.     rpng2_info.mainprog_init = rpng2_win_init;
  539.     rpng2_info.mainprog_display_row = rpng2_win_display_row;
  540.     rpng2_info.mainprog_finish_display = rpng2_win_finish_display;
  543.     /* OK, this is the fun part:  call readpng2_decode_data() at the start of
  544.      * the loop to deal with our first buffer of data (read in above to verify
  545.      * that the file is a PNG image), then loop through the file and continue
  546.      * calling the same routine to handle each chunk of data.  It in turn
  547.      * passes the data to libpng, which will invoke one or more of our call-
  548.      * backs as decoded data become available.  We optionally call Sleep() for
  549.      * one second per iteration to simulate downloading the image via an analog
  550.      * modem. */
  552.     for (;;) {
  553.         Trace((stderr, "about to call readpng2_decode_data()n"))
  554.         if (readpng2_decode_data(&rpng2_info, inbuf, incount))
  555.             ++error;
  556.         Trace((stderr, "done with readpng2_decode_data()n"))
  558.         if (error || incount != INBUFSIZE || rpng2_info.state == kDone) {
  559.             if (rpng2_info.state == kDone) {
  560.                 Trace((stderr, "done decoding PNG imagen"))
  561.             } else if (ferror(infile)) {
  562.                 fprintf(stderr, PROGNAME
  563.                   ":  error while reading PNG image filen");
  564.                 exit(3);
  565.             } else if (feof(infile)) {
  566.                 fprintf(stderr, PROGNAME ":  end of file reached "
  567.                   "(unexpectedly) while reading PNG image filen");
  568.                 exit(3);
  569.             } else /* if (error) */ {
  570.                 // will print error message below
  571.             }
  572.             break;
  573.         }
  575.         if (timing)
  576.             Sleep(1000L);
  578.         incount = fread(inbuf, 1, INBUFSIZE, infile);
  579.     }
  582.     /* clean up PNG stuff and report any decoding errors */
  584.     fclose(infile);
  585.     Trace((stderr, "about to call readpng2_cleanup()n"))
  586.     readpng2_cleanup(&rpng2_info);
  588.     if (error) {
  589.         fprintf(stderr, PROGNAME ":  libpng error while decoding PNG imagen");
  590.         exit(3);
  591.     }
  594.     /* wait for the user to tell us when to quit */
  596.     while (GetMessage(&msg, NULL, 0, 0)) {
  597.         TranslateMessage(&msg);
  598.         DispatchMessage(&msg);
  599.     }
  602.     /* we're done:  clean up all image and Windows resources and go away */
  604.     Trace((stderr, "about to call rpng2_win_cleanup()n"))
  605.     rpng2_win_cleanup();
  607.     return msg.wParam;
  608. }
  614. /* this function is called by readpng2_info_callback() in readpng2.c, which
  615.  * in turn is called by libpng after all of the pre-IDAT chunks have been
  616.  * read and processed--i.e., we now have enough info to finish initializing */
  618. static void rpng2_win_init()
  619. {
  620.     ulg i;
  621.     ulg rowbytes = rpng2_info.rowbytes;
  623.     Trace((stderr, "beginning rpng2_win_init()n"))
  624.     Trace((stderr, "  rowbytes = %dn", rpng2_info.rowbytes))
  625.     Trace((stderr, "  width  = %ldn", rpng2_info.width))
  626.     Trace((stderr, "  height = %ldn", rpng2_info.height))
  628.     rpng2_info.image_data = (uch *)malloc(rowbytes * rpng2_info.height);
  629.     if (!rpng2_info.image_data) {
  630.         readpng2_cleanup(&rpng2_info);
  631.         return;
  632.     }
  634.     rpng2_info.row_pointers = (uch **)malloc(rpng2_info.height * sizeof(uch *));
  635.     if (!rpng2_info.row_pointers) {
  636.         free(rpng2_info.image_data);
  637.         rpng2_info.image_data = NULL;
  638.         readpng2_cleanup(&rpng2_info);
  639.         return;
  640.     }
  642.     for (i = 0;  i < rpng2_info.height;  ++i)
  643.         rpng2_info.row_pointers[i] = rpng2_info.image_data + i*rowbytes;
  645. /*---------------------------------------------------------------------------
  646.     Do the basic Windows initialization stuff, make the window, and fill it
  647.     with the user-specified, file-specified or default background color.
  648.   ---------------------------------------------------------------------------*/
  650.     if (rpng2_win_create_window()) {
  651.         readpng2_cleanup(&rpng2_info);
  652.         return;
  653.     }
  655.     rpng2_info.state = kWindowInit;
  656. }
  662. static int rpng2_win_create_window()
  663. {
  664.     uch bg_red   = rpng2_info.bg_red;
  665.     uch bg_green = rpng2_info.bg_green;
  666.     uch bg_blue  = rpng2_info.bg_blue;
  667.     uch *dest;
  668.     int extra_width, extra_height;
  669.     ulg i, j;
  670.     WNDCLASSEX wndclass;
  671.     RECT rect;
  674. /*---------------------------------------------------------------------------
  675.     Allocate memory for the display-specific version of the image (round up
  676.     to multiple of 4 for Windows DIB).
  677.   ---------------------------------------------------------------------------*/
  679.     wimage_rowbytes = ((3*rpng2_info.width + 3L) >> 2) << 2;
  681.     if (!(dib = (uch *)malloc(sizeof(BITMAPINFOHEADER) +
  682.                               wimage_rowbytes*rpng2_info.height)))
  683.     {
  684.         return 4;   /* fail */
  685.     }
  687. /*---------------------------------------------------------------------------
  688.     Initialize the DIB.  Negative height means to use top-down BMP ordering
  689.     (must be uncompressed, but that's what we want).  Bit count of 1, 4 or 8
  690.     implies a colormap of RGBX quads, but 24-bit BMPs just use B,G,R values
  691.     directly => wimage_data begins immediately after BMP header.
  692.   ---------------------------------------------------------------------------*/
  694.     memset(dib, 0, sizeof(BITMAPINFOHEADER));
  695.     bmih = (BITMAPINFOHEADER *)dib;
  696.     bmih->biSize = sizeof(BITMAPINFOHEADER);
  697.     bmih->biWidth = rpng2_info.width;
  698.     bmih->biHeight = -((long)rpng2_info.height);
  699.     bmih->biPlanes = 1;
  700.     bmih->biBitCount = 24;
  701.     bmih->biCompression = 0;
  702.     wimage_data = dib + sizeof(BITMAPINFOHEADER);
  704. /*---------------------------------------------------------------------------
  705.     Fill window with the specified background color (default is black), but
  706.     defer loading faked "background image" until window is displayed (may be
  707.     slow to compute).  Data are in BGR order.
  708.   ---------------------------------------------------------------------------*/
  710.     if (bg_image) {   /* just fill with black for now */
  711.         memset(wimage_data, 0, wimage_rowbytes*rpng2_info.height);
  712.     } else {
  713.         for (j = 0;  j < rpng2_info.height;  ++j) {
  714.             dest = wimage_data + j*wimage_rowbytes;
  715.             for (i = rpng2_info.width;  i > 0;  --i) {
  716.                 *dest++ = bg_blue;
  717.                 *dest++ = bg_green;
  718.                 *dest++ = bg_red;
  719.             }
  720.         }
  721.     }
  723. /*---------------------------------------------------------------------------
  724.     Set the window parameters.
  725.   ---------------------------------------------------------------------------*/
  727.     memset(&wndclass, 0, sizeof(wndclass));
  729.     wndclass.cbSize = sizeof(wndclass);
  730.     wndclass.style = CS_HREDRAW | CS_VREDRAW;
  731.     wndclass.lpfnWndProc = rpng2_win_wndproc;
  732.     wndclass.hInstance = global_hInst;
  733.     wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  734.     wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  735.     wndclass.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
  736.     wndclass.lpszMenuName = NULL;
  737.     wndclass.lpszClassName = progname;
  738.     wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
  740.     RegisterClassEx(&wndclass);
  742. /*---------------------------------------------------------------------------
  743.     Finally, create the window.
  744.   ---------------------------------------------------------------------------*/
  746.     extra_width  = 2*(GetSystemMetrics(SM_CXBORDER) +
  747.                       GetSystemMetrics(SM_CXDLGFRAME));
  748.     extra_height = 2*(GetSystemMetrics(SM_CYBORDER) +
  749.                       GetSystemMetrics(SM_CYDLGFRAME)) +
  750.                       GetSystemMetrics(SM_CYCAPTION);
  752.     global_hwnd = CreateWindow(progname, titlebar, WS_OVERLAPPEDWINDOW,
  753.       CW_USEDEFAULT, CW_USEDEFAULT, rpng2_info.width+extra_width,
  754.       rpng2_info.height+extra_height, NULL, NULL, global_hInst, NULL);
  756.     ShowWindow(global_hwnd, global_showmode);
  757.     UpdateWindow(global_hwnd);
  759. /*---------------------------------------------------------------------------
  760.     Now compute the background image and display it.  If it fails (memory
  761.     allocation), revert to a plain background color.
  762.   ---------------------------------------------------------------------------*/
  764.     if (bg_image) {
  765.         static const char *msg = "Computing background image...";
  766.         int x, y, len = strlen(msg);
  767.         HDC hdc = GetDC(global_hwnd);
  768.         TEXTMETRIC tm;
  770.         GetTextMetrics(hdc, &tm);
  771.         x = (rpng2_info.width - len*tm.tmAveCharWidth)/2;
  772.         y = (rpng2_info.height - tm.tmHeight)/2;
  773.         SetBkMode(hdc, TRANSPARENT);
  774.         SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
  775.         /* this can still begin out of bounds even if x is positive (???): */
  776.         TextOut(hdc, ((x < 0)? 0 : x), ((y < 0)? 0 : y), msg, len);
  777.         ReleaseDC(global_hwnd, hdc);
  779.         rpng2_win_load_bg_image();   /* resets bg_image if fails */
  780.     }
  782.     if (!bg_image) {
  783.         for (j = 0;  j < rpng2_info.height;  ++j) {
  784.             dest = wimage_data + j*wimage_rowbytes;
  785.             for (i = rpng2_info.width;  i > 0;  --i) {
  786.                 *dest++ = bg_blue;
  787.                 *dest++ = bg_green;
  788.                 *dest++ = bg_red;
  789.             }
  790.         }
  791.     }
  793.     rect.left = 0L;
  794.     rect.top = 0L;
  795.     rect.right = (LONG)rpng2_info.width;       /* possibly off by one? */
  796.     rect.bottom = (LONG)rpng2_info.height;     /* possibly off by one? */
  797.     InvalidateRect(global_hwnd, &rect, FALSE);
  798.     UpdateWindow(global_hwnd);                 /* similar to XFlush() */
  800.     return 0;
  802. } /* end function rpng2_win_create_window() */
  808. static int rpng2_win_load_bg_image()
  809. {
  810.     uch *src, *dest;
  811.     uch r1, r2, g1, g2, b1, b2;
  812.     uch r1_inv, r2_inv, g1_inv, g2_inv, b1_inv, b2_inv;
  813.     int k, hmax, max;
  814.     int xidx, yidx, yidx_max = (bgscale-1);
  815.     int even_odd_vert, even_odd_horiz, even_odd;
  816.     int invert_gradient2 = (bg[pat].type & 0x08);
  817.     int invert_column;
  818.     ulg i, row;
  820. /*---------------------------------------------------------------------------
  821.     Allocate buffer for fake background image to be used with transparent
  822.     images; if this fails, revert to plain background color.
  823.   ---------------------------------------------------------------------------*/
  825.     bg_rowbytes = 3 * rpng2_info.width;
  826.     bg_data = (uch *)malloc(bg_rowbytes * rpng2_info.height);
  827.     if (!bg_data) {
  828.         fprintf(stderr, PROGNAME
  829.           ":  unable to allocate memory for background imagen");
  830.         bg_image = 0;
  831.         return 1;
  832.     }
  834. /*---------------------------------------------------------------------------
  835.     Vertical gradients (ramps) in NxN squares, alternating direction and
  836.     colors (N == bgscale).
  837.   ---------------------------------------------------------------------------*/
  839.     if ((bg[pat].type & 0x07) == 0) {
  840.         uch r1_min  = rgb[bg[pat].rgb1_min].r;
  841.         uch g1_min  = rgb[bg[pat].rgb1_min].g;
  842.         uch b1_min  = rgb[bg[pat].rgb1_min].b;
  843.         uch r2_min  = rgb[bg[pat].rgb2_min].r;
  844.         uch g2_min  = rgb[bg[pat].rgb2_min].g;
  845.         uch b2_min  = rgb[bg[pat].rgb2_min].b;
  846.         int r1_diff = rgb[bg[pat].rgb1_max].r - r1_min;
  847.         int g1_diff = rgb[bg[pat].rgb1_max].g - g1_min;
  848.         int b1_diff = rgb[bg[pat].rgb1_max].b - b1_min;
  849.         int r2_diff = rgb[bg[pat].rgb2_max].r - r2_min;
  850.         int g2_diff = rgb[bg[pat].rgb2_max].g - g2_min;
  851.         int b2_diff = rgb[bg[pat].rgb2_max].b - b2_min;
  853.         for (row = 0;  row < rpng2_info.height;  ++row) {
  854.             yidx = row % bgscale;
  855.             even_odd_vert = (row / bgscale) & 1;
  857.             r1 = r1_min + (r1_diff * yidx) / yidx_max;
  858.             g1 = g1_min + (g1_diff * yidx) / yidx_max;
  859.             b1 = b1_min + (b1_diff * yidx) / yidx_max;
  860.             r1_inv = r1_min + (r1_diff * (yidx_max-yidx)) / yidx_max;
  861.             g1_inv = g1_min + (g1_diff * (yidx_max-yidx)) / yidx_max;
  862.             b1_inv = b1_min + (b1_diff * (yidx_max-yidx)) / yidx_max;
  864.             r2 = r2_min + (r2_diff * yidx) / yidx_max;
  865.             g2 = g2_min + (g2_diff * yidx) / yidx_max;
  866.             b2 = b2_min + (b2_diff * yidx) / yidx_max;
  867.             r2_inv = r2_min + (r2_diff * (yidx_max-yidx)) / yidx_max;
  868.             g2_inv = g2_min + (g2_diff * (yidx_max-yidx)) / yidx_max;
  869.             b2_inv = b2_min + (b2_diff * (yidx_max-yidx)) / yidx_max;
  871.             dest = bg_data + row*bg_rowbytes;
  872.             for (i = 0;  i < rpng2_info.width;  ++i) {
  873.                 even_odd_horiz = (i / bgscale) & 1;
  874.                 even_odd = even_odd_vert ^ even_odd_horiz;
  875.                 invert_column =
  876.                   (even_odd_horiz && (bg[pat].type & 0x10));
  877.                 if (even_odd == 0) {         /* gradient #1 */
  878.                     if (invert_column) {
  879.                         *dest++ = r1_inv;
  880.                         *dest++ = g1_inv;
  881.                         *dest++ = b1_inv;
  882.                     } else {
  883.                         *dest++ = r1;
  884.                         *dest++ = g1;
  885.                         *dest++ = b1;
  886.                     }
  887.                 } else {                     /* gradient #2 */
  888.                     if ((invert_column && invert_gradient2) ||
  889.                         (!invert_column && !invert_gradient2))
  890.                     {
  891.                         *dest++ = r2;        /* not inverted or */
  892.                         *dest++ = g2;        /*  doubly inverted */
  893.                         *dest++ = b2;
  894.                     } else {
  895.                         *dest++ = r2_inv;
  896.                         *dest++ = g2_inv;    /* singly inverted */
  897.                         *dest++ = b2_inv;
  898.                     }
  899.                 }
  900.             }
  901.         }
  903. /*---------------------------------------------------------------------------
  904.     Soft gradient-diamonds with scale = bgscale.  Code contributed by Adam
  905.     M. Costello.
  906.   ---------------------------------------------------------------------------*/
  908.     } else if ((bg[pat].type & 0x07) == 1) {
  910.         hmax = (bgscale-1)/2;   /* half the max weight of a color */
  911.         max = 2*hmax;           /* the max weight of a color */
  913.         r1 = rgb[bg[pat].rgb1_max].r;
  914.         g1 = rgb[bg[pat].rgb1_max].g;
  915.         b1 = rgb[bg[pat].rgb1_max].b;
  916.         r2 = rgb[bg[pat].rgb2_max].r;
  917.         g2 = rgb[bg[pat].rgb2_max].g;
  918.         b2 = rgb[bg[pat].rgb2_max].b;
  920.         for (row = 0;  row < rpng2_info.height;  ++row) {
  921.             yidx = row % bgscale;
  922.             if (yidx > hmax)
  923.                 yidx = bgscale-1 - yidx;
  924.             dest = bg_data + row*bg_rowbytes;
  925.             for (i = 0;  i < rpng2_info.width;  ++i) {
  926.                 xidx = i % bgscale;
  927.                 if (xidx > hmax)
  928.                     xidx = bgscale-1 - xidx;
  929.                 k = xidx + yidx;
  930.                 *dest++ = (k*r1 + (max-k)*r2) / max;
  931.                 *dest++ = (k*g1 + (max-k)*g2) / max;
  932.                 *dest++ = (k*b1 + (max-k)*b2) / max;
  933.             }
  934.         }
  936. /*---------------------------------------------------------------------------
  937.     Radial "starburst" with azimuthal sinusoids; [eventually number of sinu-
  938.     soids will equal bgscale?].  This one is slow but very cool.  Code con-
  939.     tributed by Pieter S. van der Meulen (originally in Smalltalk).
  940.   ---------------------------------------------------------------------------*/
  942.     } else if ((bg[pat].type & 0x07) == 2) {
  943.         uch ch;
  944.         int ii, x, y, hw, hh, grayspot;
  945.         double freq, rotate, saturate, gray, intensity;
  946.         double angle=0.0, aoffset=0.0, maxDist, dist;
  947.         double red=0.0, green=0.0, blue=0.0, hue, s, v, f, p, q, t;
  949.         fprintf(stderr, "%s:  computing radial background...",
  950.           PROGNAME);
  951.         fflush(stderr);
  953.         hh = rpng2_info.height / 2;
  954.         hw = rpng2_info.width / 2;
  956.         /* variables for radial waves:
  957.          *   aoffset:  number of degrees to rotate hue [CURRENTLY NOT USED]
  958.          *   freq:  number of color beams originating from the center
  959.          *   grayspot:  size of the graying center area (anti-alias)
  960.          *   rotate:  rotation of the beams as a function of radius
  961.          *   saturate:  saturation of beams' shape azimuthally
  962.          */
  963.         angle = CLIP(angle, 0.0, 360.0);
  964.         grayspot = CLIP(bg[pat].bg_gray, 1, (hh + hw));
  965.         freq = MAX((double)bg[pat].bg_freq, 0.0);
  966.         saturate = (double)bg[pat].bg_bsat * 0.1;
  967.         rotate = (double)bg[pat].bg_brot * 0.1;
  968.         gray = 0.0;
  969.         intensity = 0.0;
  970.         maxDist = (double)((hw*hw) + (hh*hh));
  972.         for (row = 0;  row < rpng2_info.height;  ++row) {
  973.             y = row - hh;
  974.             dest = bg_data + row*bg_rowbytes;
  975.             for (i = 0;  i < rpng2_info.width;  ++i) {
  976.                 x = i - hw;
  977.                 angle = (x == 0)? PI_2 : atan((double)y / (double)x);
  978.                 gray = (double)MAX(ABS(y), ABS(x)) / grayspot;
  979.                 gray = MIN(1.0, gray);
  980.                 dist = (double)((x*x) + (y*y)) / maxDist;
  981.                 intensity = cos((angle+(rotate*dist*PI)) * freq) *
  982.                   gray * saturate;
  983.                 intensity = (MAX(MIN(intensity,1.0),-1.0) + 1.0) * 0.5;
  984.                 hue = (angle + PI) * INV_PI_360 + aoffset;
  985.                 s = gray * ((double)(ABS(x)+ABS(y)) / (double)(hw + hh));
  986.                 s = MIN(MAX(s,0.0), 1.0);
  987.                 v = MIN(MAX(intensity,0.0), 1.0);
  989.                 if (s == 0.0) {
  990.                     ch = (uch)(v * 255.0);
  991.                     *dest++ = ch;
  992.                     *dest++ = ch;
  993.                     *dest++ = ch;
  994.                 } else {
  995.                     if ((hue < 0.0) || (hue >= 360.0))
  996.                         hue -= (((int)(hue / 360.0)) * 360.0);
  997.                     hue /= 60.0;
  998.                     ii = (int)hue;
  999.                     f = hue - (double)ii;
  1000.                     p = (1.0 - s) * v;
  1001.                     q = (1.0 - (s * f)) * v;
  1002.                     t = (1.0 - (s * (1.0 - f))) * v;
  1003.                     if      (ii == 0) { red = v; green = t; blue = p; }
  1004.                     else if (ii == 1) { red = q; green = v; blue = p; }
  1005.                     else if (ii == 2) { red = p; green = v; blue = t; }
  1006.                     else if (ii == 3) { red = p; green = q; blue = v; }
  1007.                     else if (ii == 4) { red = t; green = p; blue = v; }
  1008.                     else if (ii == 5) { red = v; green = p; blue = q; }
  1009.                     *dest++ = (uch)(red * 255.0);
  1010.                     *dest++ = (uch)(green * 255.0);
  1011.                     *dest++ = (uch)(blue * 255.0);
  1012.                 }
  1013.             }
  1014.         }
  1015.         fprintf(stderr, "done.n");
  1016.         fflush(stderr);
  1017.     }
  1019. /*---------------------------------------------------------------------------
  1020.     Blast background image to display buffer before beginning PNG decode;
  1021.     calling function will handle invalidation and UpdateWindow() call.
  1022.   ---------------------------------------------------------------------------*/
  1024.     for (row = 0;  row < rpng2_info.height;  ++row) {
  1025.         src = bg_data + row*bg_rowbytes;
  1026.         dest = wimage_data + row*wimage_rowbytes;
  1027.         for (i = rpng2_info.width;  i > 0;  --i) {
  1028.             r1 = *src++;
  1029.             g1 = *src++;
  1030.             b1 = *src++;
  1031.             *dest++ = b1;
  1032.             *dest++ = g1;   /* note reverse order */
  1033.             *dest++ = r1;
  1034.         }
  1035.     }
  1037.     return 0;
  1039. } /* end function rpng2_win_load_bg_image() */
  1045. static void rpng2_win_display_row(ulg row)
  1046. {
  1047.     uch bg_red   = rpng2_info.bg_red;
  1048.     uch bg_green = rpng2_info.bg_green;
  1049.     uch bg_blue  = rpng2_info.bg_blue;
  1050.     uch *src, *src2=NULL, *dest;
  1051.     uch r, g, b, a;
  1052.     ulg i;
  1053.     static int rows=0;
  1054.     static ulg firstrow;
  1056. /*---------------------------------------------------------------------------
  1057.     rows and firstrow simply track how many rows (and which ones) have not
  1058.     yet been displayed; alternatively, we could call InvalidateRect() for
  1059.     every row and not bother with the records-keeping.
  1060.   ---------------------------------------------------------------------------*/
  1062.     Trace((stderr, "beginning rpng2_win_display_row()n"))
  1064.     if (rows == 0)
  1065.         firstrow = row;   /* first row not yet displayed */
  1067.     ++rows;   /* count of rows received but not yet displayed */
  1069. /*---------------------------------------------------------------------------
  1070.     Aside from the use of the rpng2_info struct and the lack of an outer
  1071.     loop (over rows), this routine is identical to rpng_win_display_image()
  1072.     in the non-progressive version of the program.
  1073.   ---------------------------------------------------------------------------*/
  1075.     src = rpng2_info.image_data + row*rpng2_info.rowbytes;
  1076.     if (bg_image)
  1077.         src2 = bg_data + row*bg_rowbytes;
  1078.     dest = wimage_data + row*wimage_rowbytes;
  1080.     if (rpng2_info.channels == 3) {
  1081.         for (i = rpng2_info.width;  i > 0;  --i) {
  1082.             r = *src++;
  1083.             g = *src++;
  1084.             b = *src++;
  1085.             *dest++ = b;
  1086.             *dest++ = g;   /* note reverse order */
  1087.             *dest++ = r;
  1088.         }
  1089.     } else /* if (rpng2_info.channels == 4) */ {
  1090.         for (i = rpng2_info.width;  i > 0;  --i) {
  1091.             r = *src++;
  1092.             g = *src++;
  1093.             b = *src++;
  1094.             a = *src++;
  1095.             if (bg_image) {
  1096.                 bg_red   = *src2++;
  1097.                 bg_green = *src2++;
  1098.                 bg_blue  = *src2++;
  1099.             }
  1100.             if (a == 255) {
  1101.                 *dest++ = b;
  1102.                 *dest++ = g;
  1103.                 *dest++ = r;
  1104.             } else if (a == 0) {
  1105.                 *dest++ = bg_blue;
  1106.                 *dest++ = bg_green;
  1107.                 *dest++ = bg_red;
  1108.             } else {
  1109.                 /* this macro (copied from png.h) composites the
  1110.                  * foreground and background values and puts the
  1111.                  * result into the first argument; there are no
  1112.                  * side effects with the first argument */
  1113.                 alpha_composite(*dest++, b, a, bg_blue);
  1114.                 alpha_composite(*dest++, g, a, bg_green);
  1115.                 alpha_composite(*dest++, r, a, bg_red);
  1116.             }
  1117.         }
  1118.     }
  1120. /*---------------------------------------------------------------------------
  1121.     Display after every 16 rows or when on last row.  (Region may include
  1122.     previously displayed lines due to interlacing--i.e., not contiguous.)
  1123.   ---------------------------------------------------------------------------*/
  1125.     if ((rows & 0xf) == 0 || row == rpng2_info.height-1) {
  1126.         RECT rect;
  1128.         rect.left = 0L;
  1129.         rect.top = (LONG)firstrow;
  1130.         rect.right = (LONG)rpng2_info.width;       /* possibly off by one? */
  1131.         rect.bottom = (LONG)row + 1L;              /* possibly off by one? */
  1132.         InvalidateRect(global_hwnd, &rect, FALSE);
  1133.         UpdateWindow(global_hwnd);                 /* similar to XFlush() */
  1134.         rows = 0;
  1135.     }
  1137. } /* end function rpng2_win_display_row() */
  1143. static void rpng2_win_finish_display()
  1144. {
  1145.     Trace((stderr, "beginning rpng2_win_finish_display()n"))
  1147.     /* last row has already been displayed by rpng2_win_display_row(), so
  1148.      * we have nothing to do here except set a flag and let the user know
  1149.      * that the image is done */
  1151.     rpng2_info.state = kDone;
  1152.     printf(
  1153.       "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.n");
  1154.     fflush(stdout);
  1155. }
  1161. static void rpng2_win_cleanup()
  1162. {
  1163.     if (bg_image && bg_data) {
  1164.         free(bg_data);
  1165.         bg_data = NULL;
  1166.     }
  1168.     if (rpng2_info.image_data) {
  1169.         free(rpng2_info.image_data);
  1170.         rpng2_info.image_data = NULL;
  1171.     }
  1173.     if (rpng2_info.row_pointers) {
  1174.         free(rpng2_info.row_pointers);
  1175.         rpng2_info.row_pointers = NULL;
  1176.     }
  1178.     if (dib) {
  1179.         free(dib);
  1180.         dib = NULL;
  1181.     }
  1182. }
  1188. LRESULT CALLBACK rpng2_win_wndproc(HWND hwnd, UINT iMsg, WPARAM wP, LPARAM lP)
  1189. {
  1190.     HDC         hdc;
  1191.     PAINTSTRUCT ps;
  1192.     int rc;
  1194.     switch (iMsg) {
  1195.         case WM_CREATE:
  1196.             /* one-time processing here, if any */
  1197.             return 0;
  1199.         case WM_PAINT:
  1200.             hdc = BeginPaint(hwnd, &ps);
  1201.             rc = StretchDIBits(hdc, 0, 0, rpng2_info.width, rpng2_info.height,
  1202.                                     0, 0, rpng2_info.width, rpng2_info.height,
  1203.                                     wimage_data, (BITMAPINFO *)bmih,
  1204.                                     0, SRCCOPY);
  1205.             EndPaint(hwnd, &ps);
  1206.             return 0;
  1208.         /* wait for the user to tell us when to quit */
  1209.         case WM_CHAR:
  1210.             switch (wP) {       /* only need one, so ignore repeat count */
  1211.                 case 'q':
  1212.                 case 'Q':
  1213.                 case 0x1B:      /* Esc key */
  1214.                     PostQuitMessage(0);
  1215.             }
  1216.             return 0;
  1218.         case WM_LBUTTONDOWN:    /* another way of quitting */
  1219.         case WM_DESTROY:
  1220.             PostQuitMessage(0);
  1221.             return 0;
  1222.     }
  1224.     return DefWindowProc(hwnd, iMsg, wP, lP);
  1225. }