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