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 2015-11-12 - 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 } 521
