/*---------------------------------------------------------------------------

   rpng2 - progressive-model PNG display program                rpng2-win.c

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

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

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

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

   for 32-bit Windows; it may compile under 16-bit Windows with a little

   tweaking (or maybe not).  Thanks to Adam Costello and Pieter S. van der

   Meulen for the "diamond" and "radial waves" patterns, respectively.

   to do (someday, maybe):

    - handle quoted command-line args (especially filenames with spaces)

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

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

    - have minimum window width:  oh well

  ---------------------------------------------------------------------------

   Changelog:

    - 1.01:  initial public release

    - 1.02:  fixed cut-and-paste error in usage screen (oops...)

    - 1.03:  modified to allow abbreviated options

    - 1.04:  removed bogus extra argument from usage fprintf() [Glenn R-P?];

              fixed command-line parsing bug

    - 1.10:  enabled "message window"/console (thanks to David Geldreich)

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

    - 1.21:  made minor tweak to usage screen to fit within 25-line console

    - 1.22:  added AMD64/EM64T support (__x86_64__)

    - 2.00:  dual-licensed (added GNU GPL)

    - 2.01:  fixed 64-bit typo in readpng2.c

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

              unexpected-EOF and file-read-error cases

  ---------------------------------------------------------------------------

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

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

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

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

      this software.

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

      redistribute this software according to the terms of one of the

      following two licenses (at your option):

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

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

      including commercial applications, and to alter it and redistribute

      it freely, subject to the following restrictions:

      1. Redistributions of source code must retain the above copyright

         notice, disclaimer, and this list of conditions.

      2. Redistributions in binary form must reproduce the above copyright

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

         tion and/or other materials provided with the distribution.

      3. All advertising materials mentioning features or use of this

         software must display the following acknowledgment:

            This product includes software developed by Greg Roelofs

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

            published by O'Reilly and Associates.

      LICENSE 2 (GNU GPL v2 or later):

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

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

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

      (at your option) any later version.

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

      but WITHOUT ANY WARRANTY; without even the implied warranty of

      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

      GNU General Public License for more details.

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

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

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

  ---------------------------------------------------------------------------*/

#define PROGNAME  "rpng2-win"

#define LONGNAME  "Progressive PNG Viewer for Windows"

#define VERSION   "2.02 of 16 March 2008"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

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

#include <time.h>

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

#include <windows.h>

#include <conio.h>     /* only for _getch() */

/* all for PvdM background code: */

#ifndef PI

#  define PI             3.141592653589793238

#endif

#define PI_2             (PI*0.5)

#define INV_PI_360       (360.0 / PI)

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

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

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

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

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

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

#define rgb1_max   bg_freq

#define rgb1_min   bg_gray

#define rgb2_max   bg_bsat

#define rgb2_min   bg_brot

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

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

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

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

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

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

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

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

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

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

}

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

                          *  block size corresponds roughly to a download

                          *  speed 10% faster than theoretical 33.6K maximum

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

                          *  overhead) */

/* local prototypes */

static void       rpng2_win_init(void);

static int        rpng2_win_create_window(void);

static int        rpng2_win_load_bg_image(void);

static void       rpng2_win_display_row(ulg row);

static void       rpng2_win_finish_display(void);

static void       rpng2_win_cleanup(void);

LRESULT CALLBACK  rpng2_win_wndproc(HWND, UINT, WPARAM, LPARAM);

static char titlebar[1024];

static char *progname = PROGNAME;

static char *appname = LONGNAME;

static char *filename;

static FILE *infile;

static mainprog_info rpng2_info;

static uch inbuf[INBUFSIZE];

static int incount;

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

static int bg_image = 0;

static int bgscale = 16;

static ulg bg_rowbytes;

static uch *bg_data;

static struct rgb_color {

    uch r, g, b;

} rgb[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

};

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

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

 */

/*

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

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

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

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

    wonders for ya.

    type bits:

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

                             | | | | |

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

                             | |         1 = soft diamonds

                             | |         2 = radial waves

                             | |       3-7 = undefined

                             | +-- gradient #2 inverted?

                             +-- alternating columns inverted?

 */

static struct background_pattern {

    ush type;

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

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

} bg[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

};

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

/* Windows-specific global variables (could go in struct, but messy...) */

static ulg wimage_rowbytes;

static uch *dib;

static uch *wimage_data;

static BITMAPINFOHEADER *bmih;

static HWND global_hwnd;

static HINSTANCE global_hInst;

static int global_showmode;

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)

{

    char *args[1024];                 /* arbitrary limit, but should suffice */

    char **argv = args;

    char *p, *q, *bgstr = NULL;

    int argc = 0;

    int rc, alen, flen;

    int error = 0;

    int timing = FALSE;

    int have_bg = FALSE;

    double LUT_exponent;              /* just the lookup table */

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

    double default_display_exponent;  /* whole display system */

    MSG msg;

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

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

     * etc. */

    global_hInst = hInst;

    global_showmode = showmode;

    filename = (char *)NULL;

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

    /* Next reenable console output, which normally goes to the bit bucket

     * for windowed apps.  Closing the console window will terminate the

     * app.  Thanks to David.Geldreich@realviz.com for supplying the magical

     * incantation. */

    AllocConsole();

    freopen("CONOUT$", "a", stderr);

    freopen("CONOUT$", "a", stdout);

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

     * product of the CRT exponent and the exponent corresponding to

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

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

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

     * yes, these ifdefs are completely wasted in a Windows program... */

#if defined(NeXT)

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

    LUT_exponent = 1.0 / 2.2;

    /*

    if (some_next_function_that_returns_gamma(&next_gamma))

        LUT_exponent = 1.0 / next_gamma;

     */

#elif defined(sgi)

    LUT_exponent = 1.0 / 1.7;

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

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

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

    if (infile) {

        double sgi_gamma;

        fgets(tmpline, 80, infile);

        fclose(infile);

        sgi_gamma = atof(tmpline);

        if (sgi_gamma > 0.0)

            LUT_exponent = 1.0 / sgi_gamma;

    }

#elif defined(Macintosh)

    LUT_exponent = 1.8 / 2.61;

    /*

    if (some_mac_function_that_returns_gamma(&mac_gamma))

        LUT_exponent = mac_gamma / 2.61;

     */

#else

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

#endif

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

    default_display_exponent = LUT_exponent * CRT_exponent;

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

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

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

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

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

        rpng2_info.display_exponent = atof(p);

    else

        rpng2_info.display_exponent = default_display_exponent;

    /* Windows really hates command lines, so we have to set up our own argv.

     * Note that we do NOT bother with quoted arguments here, so don't use

     * filenames with spaces in 'em! */

    argv[argc++] = PROGNAME;

    p = cmd;

    for (;;) {

        if (*p == ' ')

            while (*++p == ' ')

                ;

        /* now p points at the first non-space after some spaces */

        if (*p == '\0')

            break;    /* nothing after the spaces:  done */

        argv[argc++] = q = p;

        while (*q && *q != ' ')

            ++q;

        /* now q points at a space or the end of the string */

        if (*q == '\0')

            break;    /* last argv already terminated; quit */

        *q = '\0';    /* change space to terminator */

        p = q + 1;

    }

    argv[argc] = NULL;   /* terminate the argv array itself */

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

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

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

            if (!*++argv)

                ++error;

            else {

                rpng2_info.display_exponent = atof(*argv);

                if (rpng2_info.display_exponent <= 0.0)

                    ++error;

            }

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

            if (!*++argv)

                ++error;

            else {

                bgstr = *argv;

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

                    ++error;

                else {

                    have_bg = TRUE;

                    bg_image = FALSE;

                }

            }

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

            if (!*++argv)

                ++error;

            else {

                pat = atoi(*argv) - 1;

                if (pat < 0 || pat >= num_bgpat)

                    ++error;

                else {

                    bg_image = TRUE;

                    have_bg = FALSE;

                }

            }

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

            timing = TRUE;

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

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

            rpng2_info.nommxfilters = TRUE;

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

            rpng2_info.nommxcombine = TRUE;

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

            rpng2_info.nommxinterlace = TRUE;

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

            rpng2_info.nommxfilters = TRUE;

            rpng2_info.nommxcombine = TRUE;

            rpng2_info.nommxinterlace = TRUE;

#endif

        } else {

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

                filename = *argv;

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

                    ++error;

            } else

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

        }

    }

    if (!filename)

        ++error;

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

    if (error) {

        int ch;

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

        readpng2_version_info();

        fprintf(stderr, "\n"

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

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

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

#endif

          "        %*s file.png\n\n"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif

          "\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"

          "Press Q or Esc to quit this usage screen. ",

          PROGNAME,

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

          (int)strlen(PROGNAME), " ",

#endif

          (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat);

        fflush(stderr);

        do

            ch = _getch();

        while (ch != 'q' && ch != 'Q' && ch != 0x1B);

        exit(1);

    }

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

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

        ++error;

    } else {

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

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

            fprintf(stderr, PROGNAME

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

              filename);

            ++error;

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

            switch (rc) {

                case 2:

                    fprintf(stderr, PROGNAME

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

                    break;

                case 4:

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

                    break;

                default:

                    fprintf(stderr, PROGNAME

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

                    break;

            }

            ++error;

        }

        if (error)

            fclose(infile);

    }

    if (error) {

        int ch;

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

        do

            ch = _getch();

        while (ch != 'q' && ch != 'Q' && ch != 0x1B);

        exit(2);

    } else {

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

        fprintf(stderr,

          "\n   [console window:  closing this window will terminate %s]\n\n",

          PROGNAME);

        fflush(stderr);

    }

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

    alen = strlen(appname);

    flen = strlen(filename);

    if (alen + flen + 3 > 1023)

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

    else

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

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

    if (have_bg) {

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