contrib/gregbook/readpng2.c

   1 /*---------------------------------------------------------------------------
   2
   3    rpng2 - progressive-model PNG display program                 readpng2.c
   4
   5   ---------------------------------------------------------------------------
   6
   7       Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
   8
   9       This software is provided "as is," without warranty of any kind,
  10       express or implied.  In no event shall the author or contributors
  11       be held liable for any damages arising in any way from the use of
  12       this software.
  13
  14       The contents of this file are DUAL-LICENSED.  You may modify and/or
  15       redistribute this software according to the terms of one of the
  16       following two licenses (at your option):
  17
  18
  19       LICENSE 1 ("BSD-like with advertising clause"):
  20
  21       Permission is granted to anyone to use this software for any purpose,
  22       including commercial applications, and to alter it and redistribute
  23       it freely, subject to the following restrictions:
  24
  25       1. Redistributions of source code must retain the above copyright
  26          notice, disclaimer, and this list of conditions.
  27       2. Redistributions in binary form must reproduce the above copyright
  28          notice, disclaimer, and this list of conditions in the documenta-
  29          tion and/or other materials provided with the distribution.
  30       3. All advertising materials mentioning features or use of this
  31          software must display the following acknowledgment:
  32
  33             This product includes software developed by Greg Roelofs
  34             and contributors for the book, "PNG: The Definitive Guide,"
  35             published by O'Reilly and Associates.
  36
  37
  38       LICENSE 2 (GNU GPL v2 or later):
  39
  40       This program is free software; you can redistribute it and/or modify
  41       it under the terms of the GNU General Public License as published by
  42       the Free Software Foundation; either version 2 of the License, or
  43       (at your option) any later version.
  44
  45       This program is distributed in the hope that it will be useful,
  46       but WITHOUT ANY WARRANTY; without even the implied warranty of
  47       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  48       GNU General Public License for more details.
  49
  50       You should have received a copy of the GNU General Public License
  51       along with this program; if not, write to the Free Software Foundation,
  52       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  53
  54   ---------------------------------------------------------------------------*/
  55
  56
  57 #include <stdlib.h>     /* for exit() prototype */
  58
  59 #include "png.h"        /* libpng header; includes zlib.h and setjmp.h */
  60 #include "readpng2.h"   /* typedefs, common macros, public prototypes */
  61
  62
  63 /* local prototypes */
  64
  65 static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr);
  66 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
  67                                  png_uint_32 row_num, int pass);
  68 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
  69 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
  70
  71
  72
  73
  74 void readpng2_version_info(void)
  75 {
  76 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
  77     (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__)) && \
  78     defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
  79     /*
  80      * WARNING:  This preprocessor approach means that the following code
  81      *           cannot be used with a libpng DLL older than 1.2.0--the
  82      *           compiled-in symbols for the new functions will not exist.
  83      *           (Could use dlopen() and dlsym() on Unix and corresponding
  84      *           calls for Windows, but not portable...)
  85      */
  86     {
  87         int mmxsupport = png_mmx_support();
  88         if (mmxsupport < 0)
  89             fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
  90               "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
  91         else {
  92             int compilerID;
  93             png_uint_32 mmx_mask = png_get_mmx_flagmask(
  94               PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
  95
  96             fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
  97               "with MMX support\n   (%s version).", PNG_LIBPNG_VER_STRING,
  98               png_libpng_ver, compilerID == 1? "MSVC++" :
  99               (compilerID == 2? "GNU C" : "unknown"));
 100             fprintf(stderr, "  Processor (x86%s) %s MMX instructions.\n",
 101 #if defined(__x86_64__)
 102               "_64",
 103 #else
 104               "",
 105 #endif
 106               mmxsupport? "supports" : "does not support");
 107             if (mmxsupport > 0) {
 108                 int num_optims = 0;
 109
 110                 fprintf(stderr,
 111                   "      Potential MMX optimizations supported by libpng:\n");
 112                 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)
 113                     ++num_optims;
 114                 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_UP)
 115                     ++num_optims;
 116                 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)
 117                     ++num_optims;
 118                 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)
 119                     ++num_optims;
 120                 if (num_optims)
 121                     fprintf(stderr,
 122                       "         decoding %s row filters (reading)\n",
 123                       (num_optims == 4)? "all non-trivial" : "some");
 124                 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) {
 125                     fprintf(stderr, "         combining rows (reading)\n");
 126                     ++num_optims;
 127                 }
 128                 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_INTERLACE) {
 129                     fprintf(stderr,
 130                       "         expanding interlacing (reading)\n");
 131                     ++num_optims;
 132                 }
 133                 mmx_mask &= ~( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \
 134                              | PNG_ASM_FLAG_MMX_READ_INTERLACE    \
 135                              | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \
 136                              | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \
 137                              | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \
 138                              | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );
 139                 if (mmx_mask) {
 140                     fprintf(stderr, "         other (unknown)\n");
 141                     ++num_optims;
 142                 }
 143                 if (num_optims == 0)
 144                     fprintf(stderr, "         (none)\n");
 145             }
 146         }
 147     }
 148 #else
 149     fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
 150       "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
 151 #endif
 152
 153     fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
 154       ZLIB_VERSION, zlib_version);
 155 }
 156
 157
 158
 159
 160 int readpng2_check_sig(uch *sig, int num)
 161 {
 162     return !png_sig_cmp(sig, 0, num);
 163 }
 164
 165
 166
 167
 168 /* returns 0 for success, 2 for libpng problem, 4 for out of memory */
 169
 170 int readpng2_init(mainprog_info *mainprog_ptr)
 171 {
 172     png_structp  png_ptr;       /* note:  temporary variables! */
 173     png_infop  info_ptr;
 174
 175
 176     /* could also replace libpng warning-handler (final NULL), but no need: */
 177
 178     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
 179       readpng2_error_handler, NULL);
 180     if (!png_ptr)
 181         return 4;   /* out of memory */
 182
 183     info_ptr = png_create_info_struct(png_ptr);
 184     if (!info_ptr) {
 185         png_destroy_read_struct(&png_ptr, NULL, NULL);
 186         return 4;   /* out of memory */
 187     }
 188
 189
 190     /* we could create a second info struct here (end_info), but it's only
 191      * useful if we want to keep pre- and post-IDAT chunk info separated
 192      * (mainly for PNG-aware image editors and converters) */
 193
 194
 195     /* setjmp() must be called in every function that calls a PNG-reading
 196      * libpng function, unless an alternate error handler was installed--
 197      * but compatible error handlers must either use longjmp() themselves
 198      * (as in this program) or exit immediately, so here we are: */
 199
 200     if (setjmp(mainprog_ptr->jmpbuf)) {
 201         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 202         return 2;
 203     }
 204
 205
 206 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
 207     /* prepare the reader to ignore all recognized chunks whose data won't be
 208      * used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
 209      * IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
 210     {
 211         /* These byte strings were copied from png.h.  If a future libpng
 212          * version recognizes more chunks, add them to this list.  If a
 213          * future version of readpng2.c recognizes more chunks, delete them
 214          * from this list. */
 215         static const png_byte chunks_to_ignore[] = {
 216              99,  72,  82,  77, '\0',  /* cHRM */
 217             104,  73,  83,  84, '\0',  /* hIST */
 218             105,  67,  67,  80, '\0',  /* iCCP */
 219             105,  84,  88, 116, '\0',  /* iTXt */
 220             111,  70,  70, 115, '\0',  /* oFFs */
 221             112,  67,  65,  76, '\0',  /* pCAL */
 222             112,  72,  89, 115, '\0',  /* pHYs */
 223             115,  66,  73,  84, '\0',  /* sBIT */
 224             115,  67,  65,  76, '\0',  /* sCAL */
 225             115,  80,  76,  84, '\0',  /* sPLT */
 226             115,  84,  69,  82, '\0',  /* sTER */
 227             116,  69,  88, 116, '\0',  /* tEXt */
 228             116,  73,  77,  69, '\0',  /* tIME */
 229             122,  84,  88, 116, '\0'   /* zTXt */
 230         };
 231
 232         png_set_keep_unknown_chunks(png_ptr, 1 /* PNG_HANDLE_CHUNK_NEVER */,
 233           chunks_to_ignore, sizeof(chunks_to_ignore)/5);
 234     }
 235 #endif /* PNG_UNKNOWN_CHUNKS_SUPPORTED */
 236
 237
 238     /* instead of doing png_init_io() here, now we set up our callback
 239      * functions for progressive decoding */
 240
 241     png_set_progressive_read_fn(png_ptr, mainprog_ptr,
 242       readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
 243
 244
 245     /*
 246      * may as well enable or disable MMX routines here, if supported;
 247      *
 248      * to enable all:  mask = png_get_mmx_flagmask (
 249      *                   PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
 250      *                 flags = png_get_asm_flags (png_ptr);
 251      *                 flags |= mask;
 252      *                 png_set_asm_flags (png_ptr, flags);
 253      *
 254      * to disable all:  mask = png_get_mmx_flagmask (
 255      *                   PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
 256      *                  flags = png_get_asm_flags (png_ptr);
 257      *                  flags &= ~mask;
 258      *                  png_set_asm_flags (png_ptr, flags);
 259      */
 260
 261 #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__)) && \
 262     defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
 263     /*
 264      * WARNING:  This preprocessor approach means that the following code
 265      *           cannot be used with a libpng DLL older than 1.2.0--the
 266      *           compiled-in symbols for the new functions will not exist.
 267      *           (Could use dlopen() and dlsym() on Unix and corresponding
 268      *           calls for Windows, but not portable...)
 269      */
 270     {
 271 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
 272         png_uint_32 mmx_disable_mask = 0;
 273         png_uint_32 asm_flags, mmx_mask;
 274         int compilerID;
 275
 276         if (mainprog_ptr->nommxfilters)
 277             mmx_disable_mask |= ( PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \
 278                                 | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \
 279                                 | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \
 280                                 | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );
 281         if (mainprog_ptr->nommxcombine)
 282             mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_COMBINE_ROW;
 283         if (mainprog_ptr->nommxinterlace)
 284             mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_INTERLACE;
 285         asm_flags = png_get_asm_flags(png_ptr);
 286         png_set_asm_flags(png_ptr, asm_flags & ~mmx_disable_mask);
 287
 288
 289         /* Now query libpng's asm settings, just for yuks.  Note that this
 290          * differs from the querying of its *potential* MMX capabilities
 291          * in readpng2_version_info(); this is true runtime verification. */
 292
 293         asm_flags = png_get_asm_flags(png_ptr);
 294         mmx_mask = png_get_mmx_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE,
 295           &compilerID);
 296         if (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED)
 297             fprintf(stderr,
 298               "  MMX support (%s version) is compiled into libpng\n",
 299               compilerID == 1? "MSVC++" :
 300               (compilerID == 2? "GNU C" : "unknown"));
 301         else
 302             fprintf(stderr, "  MMX support is not compiled into libpng\n");
 303         fprintf(stderr, "  MMX instructions are %ssupported by CPU\n",
 304           (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)? "" : "not ");
 305         fprintf(stderr, "  MMX read support for combining rows is %sabled\n",
 306           (asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)? "en" : "dis");
 307         fprintf(stderr,
 308           "  MMX read support for expanding interlacing is %sabled\n",
 309           (asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)? "en" : "dis");
 310         fprintf(stderr, "  MMX read support for \"sub\" filter is %sabled\n",
 311           (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "en" : "dis");
 312         fprintf(stderr, "  MMX read support for \"up\" filter is %sabled\n",
 313           (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "en" : "dis");
 314         fprintf(stderr, "  MMX read support for \"avg\" filter is %sabled\n",
 315           (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "en" : "dis");
 316         fprintf(stderr, "  MMX read support for \"Paeth\" filter is %sabled\n",
 317           (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "en" : "dis");
 318         asm_flags &= (mmx_mask & ~( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \
 319                                   | PNG_ASM_FLAG_MMX_READ_INTERLACE    \
 320                                   | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \
 321                                   | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \
 322                                   | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \
 323                                   | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ));
 324         if (asm_flags)
 325             fprintf(stderr,
 326               "  additional MMX support is also enabled (0x%02lx)\n",
 327               asm_flags);
 328 #else  /* !PNG_ASSEMBLER_CODE_SUPPORTED */
 329         fprintf(stderr, "  MMX querying is disabled in libpng.\n");
 330 #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
 331     }
 332 #endif
 333
 334
 335     /* make sure we save our pointers for use in readpng2_decode_data() */
 336
 337     mainprog_ptr->png_ptr = png_ptr;
 338     mainprog_ptr->info_ptr = info_ptr;
 339
 340
 341     /* and that's all there is to initialization */
 342
 343     return 0;
 344 }
 345
 346
 347
 348
 349 /* returns 0 for success, 2 for libpng (longjmp) problem */
 350
 351 int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length)
 352 {
 353     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
 354     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
 355
 356
 357     /* setjmp() must be called in every function that calls a PNG-reading
 358      * libpng function */
 359
 360     if (setjmp(mainprog_ptr->jmpbuf)) {
 361         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 362         mainprog_ptr->png_ptr = NULL;
 363         mainprog_ptr->info_ptr = NULL;
 364         return 2;
 365     }
 366
 367
 368     /* hand off the next chunk of input data to libpng for decoding */
 369
 370     png_process_data(png_ptr, info_ptr, rawbuf, length);
 371
 372     return 0;
 373 }
 374
 375
 376
 377
 378 static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
 379 {
 380     mainprog_info  *mainprog_ptr;
 381     int  color_type, bit_depth;
 382     png_uint_32 width, height;
 383     double  gamma;
 384
 385
 386     /* setjmp() doesn't make sense here, because we'd either have to exit(),
 387      * longjmp() ourselves, or return control to libpng, which doesn't want
 388      * to see us again.  By not doing anything here, libpng will instead jump
 389      * to readpng2_decode_data(), which can return an error value to the main
 390      * program. */
 391
 392
 393     /* retrieve the pointer to our special-purpose struct, using the png_ptr
 394      * that libpng passed back to us (i.e., not a global this time--there's
 395      * no real difference for a single image, but for a multithreaded browser
 396      * decoding several PNG images at the same time, one needs to avoid mixing
 397      * up different images' structs) */
 398
 399     mainprog_ptr = png_get_progressive_ptr(png_ptr);
 400
 401     if (mainprog_ptr == NULL) {         /* we be hosed */
 402         fprintf(stderr,
 403           "readpng2 error:  main struct not recoverable in info_callback.\n");
 404         fflush(stderr);
 405         return;
 406         /*
 407          * Alternatively, we could call our error-handler just like libpng
 408          * does, which would effectively terminate the program.  Since this
 409          * can only happen if png_ptr gets redirected somewhere odd or the
 410          * main PNG struct gets wiped, we're probably toast anyway.  (If
 411          * png_ptr itself is NULL, we would not have been called.)
 412          */
 413     }
 414
 415
 416     /* this is just like in the non-progressive case */
 417
 418     png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
 419        NULL, NULL, NULL);
 420     mainprog_ptr->width = (ulg)width;
 421     mainprog_ptr->height = (ulg)height;
 422
 423
 424     /* since we know we've read all of the PNG file's "header" (i.e., up
 425      * to IDAT), we can check for a background color here */
 426
 427     if (mainprog_ptr->need_bgcolor &&
 428         png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
 429     {
 430         png_color_16p pBackground;
 431
 432         /* it is not obvious from the libpng documentation, but this function
 433          * takes a pointer to a pointer, and it always returns valid red,
 434          * green and blue values, regardless of color_type: */
 435         png_get_bKGD(png_ptr, info_ptr, &pBackground);
 436
 437         /* however, it always returns the raw bKGD data, regardless of any
 438          * bit-depth transformations, so check depth and adjust if necessary */
 439         if (bit_depth == 16) {
 440             mainprog_ptr->bg_red   = pBackground->red   >> 8;
 441             mainprog_ptr->bg_green = pBackground->green >> 8;
 442             mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
 443         } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
 444             if (bit_depth == 1)
 445                 mainprog_ptr->bg_red = mainprog_ptr->bg_green =
 446                   mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
 447             else if (bit_depth == 2)
 448                 mainprog_ptr->bg_red = mainprog_ptr->bg_green =
 449                   mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
 450             else /* bit_depth == 4 */
 451                 mainprog_ptr->bg_red = mainprog_ptr->bg_green =
 452                   mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
 453         } else {
 454             mainprog_ptr->bg_red   = (uch)pBackground->red;
 455             mainprog_ptr->bg_green = (uch)pBackground->green;
 456             mainprog_ptr->bg_blue  = (uch)pBackground->blue;
 457         }
 458     }
 459
 460
 461     /* as before, let libpng expand palette images to RGB, low-bit-depth
 462      * grayscale images to 8 bits, transparency chunks to full alpha channel;
 463      * strip 16-bit-per-sample images to 8 bits per sample; and convert
 464      * grayscale to RGB[A] */
 465
 466     if (color_type == PNG_COLOR_TYPE_PALETTE)
 467         png_set_expand(png_ptr);
 468     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 469         png_set_expand(png_ptr);
 470     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 471         png_set_expand(png_ptr);
 472     if (bit_depth == 16)
 473         png_set_strip_16(png_ptr);
 474     if (color_type == PNG_COLOR_TYPE_GRAY ||
 475         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 476         png_set_gray_to_rgb(png_ptr);
 477
 478
 479     /* Unlike the basic viewer, which was designed to operate on local files,
 480      * this program is intended to simulate a web browser--even though we
 481      * actually read from a local file, too.  But because we are pretending
 482      * that most of the images originate on the Internet, we follow the recom-
 483      * mendation of the sRGB proposal and treat unlabelled images (no gAMA
 484      * chunk) as existing in the sRGB color space.  That is, we assume that
 485      * such images have a file gamma of 0.45455, which corresponds to a PC-like
 486      * display system.  This change in assumptions will have no effect on a
 487      * PC-like system, but on a Mac, SGI, NeXT or other system with a non-
 488      * identity lookup table, it will darken unlabelled images, which effec-
 489      * tively favors images from PC-like systems over those originating on
 490      * the local platform.  Note that mainprog_ptr->display_exponent is the
 491      * "gamma" value for the entire display system, i.e., the product of
 492      * LUT_exponent and CRT_exponent. */
 493
 494     if (png_get_gAMA(png_ptr, info_ptr, &gamma))
 495         png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
 496     else
 497         png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
 498
 499
 500     /* we'll let libpng expand interlaced images, too */
 501
 502     mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
 503
 504
 505     /* all transformations have been registered; now update info_ptr data and
 506      * then get rowbytes and channels */
 507
 508     png_read_update_info(png_ptr, info_ptr);
 509
 510     mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
 511     mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
 512
 513
 514     /* Call the main program to allocate memory for the image buffer and
 515      * initialize windows and whatnot.  (The old-style function-pointer
 516      * invocation is used for compatibility with a few supposedly ANSI
 517      * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */
 518
 519     (*mainprog_ptr->mainprog_init)();
 520
 521
 522     /* and that takes care of initialization */
 523
 524     return;
 525 }
 526
 527
 528
 529
 530
 531 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
 532                                   png_uint_32 row_num, int pass)
 533 {
 534     mainprog_info  *mainprog_ptr;
 535
 536
 537     /* first check whether the row differs from the previous pass; if not,
 538      * nothing to combine or display */
 539
 540     if (!new_row)
 541         return;
 542
 543
 544     /* retrieve the pointer to our special-purpose struct so we can access
 545      * the old rows and image-display callback function */
 546
 547     mainprog_ptr = png_get_progressive_ptr(png_ptr);
 548
 549
 550     /* save the pass number for optional use by the front end */
 551
 552     mainprog_ptr->pass = pass;
 553
 554
 555     /* have libpng either combine the new row data with the existing row data
 556      * from previous passes (if interlaced) or else just copy the new row
 557      * into the main program's image buffer */
 558
 559     png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
 560       new_row);
 561
 562
 563     /* finally, call the display routine in the main program with the number
 564      * of the row we just updated */
 565
 566     (*mainprog_ptr->mainprog_display_row)(row_num);
 567
 568
 569     /* and we're ready for more */
 570
 571     return;
 572 }
 573
 574
 575
 576
 577
 578 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
 579 {
 580     mainprog_info  *mainprog_ptr;
 581
 582
 583     /* retrieve the pointer to our special-purpose struct */
 584
 585     mainprog_ptr = png_get_progressive_ptr(png_ptr);
 586
 587
 588     /* let the main program know that it should flush any buffered image
 589      * data to the display now and set a "done" flag or whatever, but note
 590      * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do
 591      * NOT call readpng2_cleanup() either here or in the finish_display()
 592      * routine; wait until control returns to the main program via
 593      * readpng2_decode_data() */
 594
 595     (*mainprog_ptr->mainprog_finish_display)();
 596
 597
 598     /* all done */
 599
 600     return;
 601 }
 602
 603
 604
 605
 606
 607 void readpng2_cleanup(mainprog_info *mainprog_ptr)
 608 {
 609     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
 610     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
 611
 612     if (png_ptr && info_ptr)
 613         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 614
 615     mainprog_ptr->png_ptr = NULL;
 616     mainprog_ptr->info_ptr = NULL;
 617 }
 618
 619
 620
 621
 622
 623 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
 624 {
 625     mainprog_info  *mainprog_ptr;
 626
 627     /* This function, aside from the extra step of retrieving the "error
 628      * pointer" (below) and the fact that it exists within the application
 629      * rather than within libpng, is essentially identical to libpng's
 630      * default error handler.  The second point is critical:  since both
 631      * setjmp() and longjmp() are called from the same code, they are
 632      * guaranteed to have compatible notions of how big a jmp_buf is,
 633      * regardless of whether _BSD_SOURCE or anything else has (or has not)
 634      * been defined. */
 635
 636     fprintf(stderr, "readpng2 libpng error: %s\n", msg);
 637     fflush(stderr);
 638
 639     mainprog_ptr = png_get_error_ptr(png_ptr);
 640     if (mainprog_ptr == NULL) {         /* we are completely hosed now */
 641         fprintf(stderr,
 642           "readpng2 severe error:  jmpbuf not recoverable; terminating.\n");
 643         fflush(stderr);
 644         exit(99);
 645     }
 646
 647     longjmp(mainprog_ptr->jmpbuf, 1);
 648 }