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 return; 452 } 453 454 455 456 457 458 void readpng2_cleanup(mainprog_info *mainprog_ptr) 459 { 460 png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr; 461 png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr; 462 463 if (png_ptr && info_ptr) 464 png_destroy_read_struct(&png_ptr, &info_ptr, NULL); 465 466 mainprog_ptr->png_ptr = NULL; 467 mainprog_ptr->info_ptr = NULL; 468 } 469 470 471 static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg) 472 { 473 fprintf(stderr, "readpng2 libpng warning: %s\n", msg); 474 fflush(stderr); 475 } 476 477 478 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg) 479 { 480 mainprog_info *mainprog_ptr; 481 482 /* This function, aside from the extra step of retrieving the "error 483 * pointer" (below) and the fact that it exists within the application 484 * rather than within libpng, is essentially identical to libpng's 485 * default error handler. The second point is critical: since both 486 * setjmp() and longjmp() are called from the same code, they are 487 * guaranteed to have compatible notions of how big a jmp_buf is, 488 * regardless of whether _BSD_SOURCE or anything else has (or has not) 489 * been defined. */ 490 491 fprintf(stderr, "readpng2 libpng error: %s\n", msg); 492 fflush(stderr); 493 494 mainprog_ptr = png_get_error_ptr(png_ptr); 495 if (mainprog_ptr == NULL) { /* we are completely hosed now */ 496 fprintf(stderr, 497 "readpng2 severe error: jmpbuf not recoverable; terminating.\n"); 498 fflush(stderr); 499 exit(99); 500 } 501 502 /* Now we have our data structure we can use the information in it 503 * to return control to our own higher level code (all the points 504 * where 'setjmp' is called in this file.) This will work with other 505 * error handling mechanisms as well - libpng always calls png_error 506 * when it can proceed no further, thus, so long as the error handler 507 * is intercepted, application code can do its own error recovery. 508 */ 509 longjmp(mainprog_ptr->jmpbuf, 1); 510 } 511
