runtime/libpng/contrib/gregbook/readpng2.c

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