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