contrib/gregbook/readpng2.c

   1 /*---------------------------------------------------------------------------
   2
   3    rpng2 - progressive-model PNG display program                 readpng2.c
   4
   5   ---------------------------------------------------------------------------
   6
   7       Copyright (c) 1998-2015 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    Changelog:
  57      %RDATE% - Check return value of png_get_bKGD() (Glenn R-P)
  58
  59   ---------------------------------------------------------------------------*/
  60
  61
  62 #include <stdlib.h>     /* for exit() prototype */
  63 #include <setjmp.h>
  64
  65 #include <zlib.h>
  66 #include "png.h"        /* libpng header from the local directory */
  67 #include "readpng2.h"   /* typedefs, common macros, public prototypes */
  68
  69
  70 /* local prototypes */
  71
  72 static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr);
  73 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
  74                                  png_uint_32 row_num, int pass);
  75 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
  76 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
  77 static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg);
  78
  79
  80
  81
  82 void readpng2_version_info(void)
  83 {
  84     fprintf(stderr, "   Compiled with libpng %s; using libpng %s\n",
  85       PNG_LIBPNG_VER_STRING, png_libpng_ver);
  86
  87     fprintf(stderr, "   and with zlib %s; using zlib %s.\n",
  88       ZLIB_VERSION, zlib_version);
  89 }
  90
  91
  92
  93
  94 int readpng2_check_sig(uch *sig, int num)
  95 {
  96     return !png_sig_cmp(sig, 0, num);
  97 }
  98
  99
 100
 101
 102 /* returns 0 for success, 2 for libpng problem, 4 for out of memory */
 103
 104 int readpng2_init(mainprog_info *mainprog_ptr)
 105 {
 106     png_structp  png_ptr;       /* note:  temporary variables! */
 107     png_infop  info_ptr;
 108
 109
 110     /* could also replace libpng warning-handler (final NULL), but no need: */
 111
 112     png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), mainprog_ptr,
 113       readpng2_error_handler, readpng2_warning_handler);
 114     if (!png_ptr)
 115         return 4;   /* out of memory */
 116
 117     info_ptr = png_create_info_struct(png_ptr);
 118     if (!info_ptr) {
 119         png_destroy_read_struct(&png_ptr, NULL, NULL);
 120         return 4;   /* out of memory */
 121     }
 122
 123
 124     /* we could create a second info struct here (end_info), but it's only
 125      * useful if we want to keep pre- and post-IDAT chunk info separated
 126      * (mainly for PNG-aware image editors and converters) */
 127
 128
 129     /* setjmp() must be called in every function that calls a PNG-reading
 130      * libpng function, unless an alternate error handler was installed--
 131      * but compatible error handlers must either use longjmp() themselves
 132      * (as in this program) or exit immediately, so here we are: */
 133
 134     if (setjmp(mainprog_ptr->jmpbuf)) {
 135         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 136         return 2;
 137     }
 138
 139
 140 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 141     /* prepare the reader to ignore all recognized chunks whose data won't be
 142      * used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
 143      * IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
 144     {
 145         /* These byte strings were copied from png.h.  If a future version
 146          * of readpng2.c recognizes more chunks, add them to this list.
 147          */
 148         static PNG_CONST png_byte chunks_to_process[] = {
 149             98,  75,  71,  68, '\0',  /* bKGD */
 150            103,  65,  77,  65, '\0',  /* gAMA */
 151            115,  82,  71,  66, '\0',  /* sRGB */
 152            };
 153
 154        /* Ignore all chunks except for IHDR, PLTE, tRNS, IDAT, and IEND */
 155        png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
 156           NULL, -1);
 157
 158        /* But do not ignore chunks in the "chunks_to_process" list */
 159        png_set_keep_unknown_chunks(png_ptr,
 160           0 /* PNG_HANDLE_CHUNK_AS_DEFAULT */, chunks_to_process,
 161           sizeof(chunks_to_process)/5);
 162     }
 163 #endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
 164
 165
 166     /* instead of doing png_init_io() here, now we set up our callback
 167      * functions for progressive decoding */
 168
 169     png_set_progressive_read_fn(png_ptr, mainprog_ptr,
 170       readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
 171
 172
 173     /* make sure we save our pointers for use in readpng2_decode_data() */
 174
 175     mainprog_ptr->png_ptr = png_ptr;
 176     mainprog_ptr->info_ptr = info_ptr;
 177
 178
 179     /* and that's all there is to initialization */
 180
 181     return 0;
 182 }
 183
 184
 185
 186
 187 /* returns 0 for success, 2 for libpng (longjmp) problem */
 188
 189 int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length)
 190 {
 191     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
 192     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
 193
 194
 195     /* setjmp() must be called in every function that calls a PNG-reading
 196      * libpng function */
 197
 198     if (setjmp(mainprog_ptr->jmpbuf)) {
 199         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 200         mainprog_ptr->png_ptr = NULL;
 201         mainprog_ptr->info_ptr = NULL;
 202         return 2;
 203     }
 204
 205
 206     /* hand off the next chunk of input data to libpng for decoding */
 207
 208     png_process_data(png_ptr, info_ptr, rawbuf, length);
 209
 210     return 0;
 211 }
 212
 213
 214
 215
 216 static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
 217 {
 218     mainprog_info  *mainprog_ptr;
 219     int  color_type, bit_depth;
 220     png_uint_32 width, height;
 221 #ifdef PNG_FLOATING_POINT_SUPPORTED
 222     double  gamma;
 223 #else
 224     png_fixed_point gamma;
 225 #endif
 226
 227
 228     /* setjmp() doesn't make sense here, because we'd either have to exit(),
 229      * longjmp() ourselves, or return control to libpng, which doesn't want
 230      * to see us again.  By not doing anything here, libpng will instead jump
 231      * to readpng2_decode_data(), which can return an error value to the main
 232      * program. */
 233
 234
 235     /* retrieve the pointer to our special-purpose struct, using the png_ptr
 236      * that libpng passed back to us (i.e., not a global this time--there's
 237      * no real difference for a single image, but for a multithreaded browser
 238      * decoding several PNG images at the same time, one needs to avoid mixing
 239      * up different images' structs) */
 240
 241     mainprog_ptr = png_get_progressive_ptr(png_ptr);
 242
 243     if (mainprog_ptr == NULL) {         /* we be hosed */
 244         fprintf(stderr,
 245           "readpng2 error:  main struct not recoverable in info_callback.\n");
 246         fflush(stderr);
 247         return;
 248         /*
 249          * Alternatively, we could call our error-handler just like libpng
 250          * does, which would effectively terminate the program.  Since this
 251          * can only happen if png_ptr gets redirected somewhere odd or the
 252          * main PNG struct gets wiped, we're probably toast anyway.  (If
 253          * png_ptr itself is NULL, we would not have been called.)
 254          */
 255     }
 256
 257
 258     /* this is just like in the non-progressive case */
 259
 260     png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
 261        NULL, NULL, NULL);
 262     mainprog_ptr->width = (ulg)width;
 263     mainprog_ptr->height = (ulg)height;
 264
 265
 266     /* since we know we've read all of the PNG file's "header" (i.e., up
 267      * to IDAT), we can check for a background color here */
 268
 269     if (mainprog_ptr->need_bgcolor)
 270     {
 271         png_color_16p pBackground;
 272
 273         /* it is not obvious from the libpng documentation, but this function
 274          * takes a pointer to a pointer, and it always returns valid red,
 275          * green and blue values, regardless of color_type: */
 276         if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
 277         {
 278
 279            /* however, it always returns the raw bKGD data, regardless of any
 280             * bit-depth transformations, so check depth and adjust if necessary
 281             */
 282            if (bit_depth == 16) {
 283                mainprog_ptr->bg_red   = pBackground->red   >> 8;
 284                mainprog_ptr->bg_green = pBackground->green >> 8;
 285                mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
 286            } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
 287                if (bit_depth == 1)
 288                    mainprog_ptr->bg_red = mainprog_ptr->bg_green =
 289                      mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
 290                else if (bit_depth == 2)
 291                    mainprog_ptr->bg_red = mainprog_ptr->bg_green =
 292                      mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
 293                else /* bit_depth == 4 */
 294                    mainprog_ptr->bg_red = mainprog_ptr->bg_green =
 295                      mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
 296            } else {
 297                mainprog_ptr->bg_red   = (uch)pBackground->red;
 298                mainprog_ptr->bg_green = (uch)pBackground->green;
 299                mainprog_ptr->bg_blue  = (uch)pBackground->blue;
 300            }
 301         }
 302     }
 303
 304
 305     /* as before, let libpng expand palette images to RGB, low-bit-depth
 306      * grayscale images to 8 bits, transparency chunks to full alpha channel;
 307      * strip 16-bit-per-sample images to 8 bits per sample; and convert
 308      * grayscale to RGB[A] */
 309
 310     if (color_type == PNG_COLOR_TYPE_PALETTE)
 311         png_set_expand(png_ptr);
 312     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 313         png_set_expand(png_ptr);
 314     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 315         png_set_expand(png_ptr);
 316 #ifdef PNG_READ_16_TO_8_SUPPORTED
 317     if (bit_depth == 16)
 318 #  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
 319         png_set_scale_16(png_ptr);
 320 #  else
 321         png_set_strip_16(png_ptr);
 322 #  endif
 323 #endif
 324     if (color_type == PNG_COLOR_TYPE_GRAY ||
 325         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 326         png_set_gray_to_rgb(png_ptr);
 327
 328
 329     /* Unlike the basic viewer, which was designed to operate on local files,
 330      * this program is intended to simulate a web browser--even though we
 331      * actually read from a local file, too.  But because we are pretending
 332      * that most of the images originate on the Internet, we follow the recom-
 333      * mendation of the sRGB proposal and treat unlabelled images (no gAMA
 334      * chunk) as existing in the sRGB color space.  That is, we assume that
 335      * such images have a file gamma of 0.45455, which corresponds to a PC-like
 336      * display system.  This change in assumptions will have no effect on a
 337      * PC-like system, but on a Mac, SGI, NeXT or other system with a non-
 338      * identity lookup table, it will darken unlabelled images, which effec-
 339      * tively favors images from PC-like systems over those originating on
 340      * the local platform.  Note that mainprog_ptr->display_exponent is the
 341      * "gamma" value for the entire display system, i.e., the product of
 342      * LUT_exponent and CRT_exponent. */
 343
 344 #ifdef PNG_FLOATING_POINT_SUPPORTED
 345     if (png_get_gAMA(png_ptr, info_ptr, &gamma))
 346         png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
 347     else
 348         png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
 349 #else
 350     if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
 351         png_set_gamma_fixed(png_ptr,
 352             (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), gamma);
 353     else
 354         png_set_gamma_fixed(png_ptr,
 355             (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), 45455);
 356 #endif
 357
 358     /* we'll let libpng expand interlaced images, too */
 359
 360     mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
 361
 362
 363     /* all transformations have been registered; now update info_ptr data and
 364      * then get rowbytes and channels */
 365
 366     png_read_update_info(png_ptr, info_ptr);
 367
 368     mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
 369     mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
 370
 371
 372     /* Call the main program to allocate memory for the image buffer and
 373      * initialize windows and whatnot.  (The old-style function-pointer
 374      * invocation is used for compatibility with a few supposedly ANSI
 375      * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */
 376
 377     (*mainprog_ptr->mainprog_init)();
 378
 379
 380     /* and that takes care of initialization */
 381
 382     return;
 383 }
 384
 385
 386
 387
 388
 389 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
 390                                   png_uint_32 row_num, int pass)
 391 {
 392     mainprog_info  *mainprog_ptr;
 393
 394
 395     /* first check whether the row differs from the previous pass; if not,
 396      * nothing to combine or display */
 397
 398     if (!new_row)
 399         return;
 400
 401
 402     /* retrieve the pointer to our special-purpose struct so we can access
 403      * the old rows and image-display callback function */
 404
 405     mainprog_ptr = png_get_progressive_ptr(png_ptr);
 406
 407
 408     /* save the pass number for optional use by the front end */
 409
 410     mainprog_ptr->pass = pass;
 411
 412
 413     /* have libpng either combine the new row data with the existing row data
 414      * from previous passes (if interlaced) or else just copy the new row
 415      * into the main program's image buffer */
 416
 417     png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
 418       new_row);
 419
 420
 421     /* finally, call the display routine in the main program with the number
 422      * of the row we just updated */
 423
 424     (*mainprog_ptr->mainprog_display_row)(row_num);
 425
 426
 427     /* and we're ready for more */
 428
 429     return;
 430 }
 431
 432
 433
 434
 435
 436 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
 437 {
 438     mainprog_info  *mainprog_ptr;
 439
 440
 441     /* retrieve the pointer to our special-purpose struct */
 442
 443     mainprog_ptr = png_get_progressive_ptr(png_ptr);
 444
 445
 446     /* let the main program know that it should flush any buffered image
 447      * data to the display now and set a "done" flag or whatever, but note
 448      * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do
 449      * NOT call readpng2_cleanup() either here or in the finish_display()
 450      * routine; wait until control returns to the main program via
 451      * readpng2_decode_data() */
 452
 453     (*mainprog_ptr->mainprog_finish_display)();
 454
 455
 456     /* all done */
 457
 458     (void)info_ptr; /* Unused */
 459
 460     return;
 461 }
 462
 463
 464
 465
 466
 467 void readpng2_cleanup(mainprog_info *mainprog_ptr)
 468 {
 469     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
 470     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
 471
 472     if (png_ptr && info_ptr)
 473         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 474
 475     mainprog_ptr->png_ptr = NULL;
 476     mainprog_ptr->info_ptr = NULL;
 477 }
 478
 479
 480 static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg)
 481 {
 482     fprintf(stderr, "readpng2 libpng warning: %s\n", msg);
 483     fflush(stderr);
 484     (void)png_ptr; /* Unused */
 485 }
 486
 487
 488 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
 489 {
 490     mainprog_info  *mainprog_ptr;
 491
 492     /* This function, aside from the extra step of retrieving the "error
 493      * pointer" (below) and the fact that it exists within the application
 494      * rather than within libpng, is essentially identical to libpng's
 495      * default error handler.  The second point is critical:  since both
 496      * setjmp() and longjmp() are called from the same code, they are
 497      * guaranteed to have compatible notions of how big a jmp_buf is,
 498      * regardless of whether _BSD_SOURCE or anything else has (or has not)
 499      * been defined. */
 500
 501     fprintf(stderr, "readpng2 libpng error: %s\n", msg);
 502     fflush(stderr);
 503
 504     mainprog_ptr = png_get_error_ptr(png_ptr);
 505     if (mainprog_ptr == NULL) {         /* we are completely hosed now */
 506         fprintf(stderr,
 507           "readpng2 severe error:  jmpbuf not recoverable; terminating.\n");
 508         fflush(stderr);
 509         exit(99);
 510     }
 511
 512     /* Now we have our data structure we can use the information in it
 513      * to return control to our own higher level code (all the points
 514      * where 'setjmp' is called in this file.)  This will work with other
 515      * error handling mechanisms as well - libpng always calls png_error
 516      * when it can proceed no further, thus, so long as the error handler
 517      * is intercepted, application code can do its own error recovery.
 518      */
 519     longjmp(mainprog_ptr->jmpbuf, 1);
 520 }