1 /*---------------------------------------------------------------------------
2
3 rpng2 - progressive-model PNG display program readpng2.c
4
5 ---------------------------------------------------------------------------
6
7 Changelog:
8 - 1.01: initial public release
9 - 1.02: added code to skip unused chunks (GR-P)
10
11 ---------------------------------------------------------------------------
12
13 Copyright (c) 1998-2002 Greg Roelofs. All rights reserved.
14
15 This software is provided "as is," without warranty of any kind,
16 express or implied. In no event shall the author or contributors
17 be held liable for any damages arising in any way from the use of
18 this software.
19
20 Permission is granted to anyone to use this software for any purpose,
21 including commercial applications, and to alter it and redistribute
22 it freely, subject to the following restrictions:
23
24 1. Redistributions of source code must retain the above copyright
25 notice, disclaimer, and this list of conditions.
26 2. Redistributions in binary form must reproduce the above copyright
27 notice, disclaimer, and this list of conditions in the documenta-
28 tion and/or other materials provided with the distribution.
29 3. All advertising materials mentioning features or use of this
30 software must display the following acknowledgment:
31
32 This product includes software developed by Greg Roelofs
33 and contributors for the book, "PNG: The Definitive Guide,"
34 published by O'Reilly and Associates.
35
36 ---------------------------------------------------------------------------*/
37
38
39 #include <stdlib.h> /* for exit() prototype */
40
41 #include "png.h" /* libpng header; includes zlib.h and setjmp.h */
42 #include "readpng2.h" /* typedefs, common macros, public prototypes */
43
44
45 /* local prototypes */
46
47 static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr);
48 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
49 png_uint_32 row_num, int pass);
50 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
51 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
52
53
54
55
readpng2_version_info(void)56 void readpng2_version_info(void)
57 {
58 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
59 (defined(__i386__) || defined(_M_IX86)) && \
60 defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
61 /*
62 * WARNING: This preprocessor approach means that the following code
63 * cannot be used with a libpng DLL older than 1.2.0--the
64 * compiled-in symbols for the new functions will not exist.
65 * (Could use dlopen() and dlsym() on Unix and corresponding
66 * calls for Windows, but not portable...)
67 */
68 {
69 int mmxsupport = png_mmx_support();
70 if (mmxsupport < 0)
71 fprintf(stderr, " Compiled with libpng %s; using libpng %s "
72 "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
73 else {
74 int compilerID;
75 png_uint_32 mmx_mask = png_get_mmx_flagmask(
76 PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
77
78 fprintf(stderr, " Compiled with libpng %s; using libpng %s "
79 "with MMX support\n (%s version).", PNG_LIBPNG_VER_STRING,
80 png_libpng_ver, compilerID == 1? "MSVC++" :
81 (compilerID == 2? "GNU C" : "unknown"));
82 fprintf(stderr, " Processor %s MMX instructions.\n",
83 mmxsupport? "supports" : "does not support");
84 if (mmxsupport > 0) {
85 int num_optims = 0;
86
87 fprintf(stderr,
88 " Potential MMX optimizations supported by libpng:\n");
89 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)
90 ++num_optims;
91 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_UP)
92 ++num_optims;
93 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)
94 ++num_optims;
95 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)
96 ++num_optims;
97 if (num_optims)
98 fprintf(stderr,
99 " decoding %s row filters (reading)\n",
100 (num_optims == 4)? "all non-trivial" : "some");
101 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) {
102 fprintf(stderr, " combining rows (reading)\n");
103 ++num_optims;
104 }
105 if (mmx_mask & PNG_ASM_FLAG_MMX_READ_INTERLACE) {
106 fprintf(stderr,
107 " expanding interlacing (reading)\n");
108 ++num_optims;
109 }
110 mmx_mask &= ~( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \
111 | PNG_ASM_FLAG_MMX_READ_INTERLACE \
112 | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \
113 | PNG_ASM_FLAG_MMX_READ_FILTER_UP \
114 | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \
115 | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );
116 if (mmx_mask) {
117 fprintf(stderr, " other (unknown)\n");
118 ++num_optims;
119 }
120 if (num_optims == 0)
121 fprintf(stderr, " (none)\n");
122 }
123 }
124 }
125 #else
126 fprintf(stderr, " Compiled with libpng %s; using libpng %s "
127 "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
128 #endif
129
130 fprintf(stderr, " Compiled with zlib %s; using zlib %s.\n",
131 ZLIB_VERSION, zlib_version);
132 }
133
134
135
136
readpng2_check_sig(uch * sig,int num)137 int readpng2_check_sig(uch *sig, int num)
138 {
139 return png_check_sig(sig, num);
140 }
141
142
143
144
145 /* returns 0 for success, 2 for libpng problem, 4 for out of memory */
146
readpng2_init(mainprog_info * mainprog_ptr)147 int readpng2_init(mainprog_info *mainprog_ptr)
148 {
149 png_structp png_ptr; /* note: temporary variables! */
150 png_infop info_ptr;
151
152
153 /* could also replace libpng warning-handler (final NULL), but no need: */
154
155 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
156 readpng2_error_handler, NULL);
157 if (!png_ptr)
158 return 4; /* out of memory */
159
160 info_ptr = png_create_info_struct(png_ptr);
161 if (!info_ptr) {
162 png_destroy_read_struct(&png_ptr, NULL, NULL);
163 return 4; /* out of memory */
164 }
165
166
167 /* we could create a second info struct here (end_info), but it's only
168 * useful if we want to keep pre- and post-IDAT chunk info separated
169 * (mainly for PNG-aware image editors and converters) */
170
171
172 /* setjmp() must be called in every function that calls a PNG-reading
173 * libpng function, unless an alternate error handler was installed--
174 * but compatible error handlers must either use longjmp() themselves
175 * (as in this program) or exit immediately, so here we are: */
176
177 if (setjmp(mainprog_ptr->jmpbuf)) {
178 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
179 return 2;
180 }
181
182 /* prepare the reader to ignore all recognized chunks whose data isn't
183 * going to be used, i.e., all chunks recognized by libpng except for
184 * IHDR, PLTE, IDAT, IEND, tRNS, bKGD, gAMA, and sRGB : */
185
186 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
187 {
188 #ifndef HANDLE_CHUNK_NEVER
189 /* prior to libpng-1.2.5, this macro was internal, so we define it here. */
190 # define HANDLE_CHUNK_NEVER 1
191 #endif
192 /* these byte strings were copied from png.h.
193 * If a future libpng version recognizes more chunks, add them
194 * to this list. If a future version of readpng2.c recognizes
195 * more chunks, delete them from this list. */
196 png_byte png_chunk_types_to_ignore[]=
197 { 99, 72, 82, 77, '\0', /* cHRM */
198 104, 73, 83, 84, '\0', /* hIST */
199 105, 67, 67, 80, '\0', /* iCCP */
200 105, 84, 88, 116, '\0', /* iTXt */
201 111, 70, 70, 115, '\0', /* oFFs */
202 112, 67, 65, 76, '\0', /* pCAL */
203 115, 67, 65, 76, '\0', /* sCAL */
204 112, 72, 89, 115, '\0', /* pHYs */
205 115, 66, 73, 84, '\0', /* sBIT */
206 115, 80, 76, 84, '\0', /* sPLT */
207 116, 69, 88, 116, '\0', /* tEXt */
208 116, 73, 77, 69, '\0', /* tIME */
209 122, 84, 88, 116, '\0'}; /* zTXt */
210 #define NUM_PNG_CHUNK_TYPES_TO_IGNORE 13
211
212 png_set_keep_unknown_chunks(png_ptr, HANDLE_CHUNK_NEVER,
213 png_chunk_types_to_ignore, NUM_PNG_CHUNK_TYPES_TO_IGNORE);
214 }
215 #endif
216
217 /* instead of doing png_init_io() here, now we set up our callback
218 * functions for progressive decoding */
219
220 png_set_progressive_read_fn(png_ptr, mainprog_ptr,
221 readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
222
223
224 /*
225 * may as well enable or disable MMX routines here, if supported;
226 *
227 * to enable all: mask = png_get_mmx_flagmask (
228 * PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
229 * flags = png_get_asm_flags (png_ptr);
230 * flags |= mask;
231 * png_set_asm_flags (png_ptr, flags);
232 *
233 * to disable all: mask = png_get_mmx_flagmask (
234 * PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
235 * flags = png_get_asm_flags (png_ptr);
236 * flags &= ~mask;
237 * png_set_asm_flags (png_ptr, flags);
238 */
239
240 #if (defined(__i386__) || defined(_M_IX86)) && \
241 defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
242 /*
243 * WARNING: This preprocessor approach means that the following code
244 * cannot be used with a libpng DLL older than 1.2.0--the
245 * compiled-in symbols for the new functions will not exist.
246 * (Could use dlopen() and dlsym() on Unix and corresponding
247 * calls for Windows, but not portable...)
248 */
249 {
250 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
251 png_uint_32 mmx_disable_mask = 0;
252 png_uint_32 asm_flags, mmx_mask;
253 int compilerID;
254
255 if (mainprog_ptr->nommxfilters)
256 mmx_disable_mask |= ( PNG_ASM_FLAG_MMX_READ_FILTER_SUB \
257 | PNG_ASM_FLAG_MMX_READ_FILTER_UP \
258 | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \
259 | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );
260 if (mainprog_ptr->nommxcombine)
261 mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_COMBINE_ROW;
262 if (mainprog_ptr->nommxinterlace)
263 mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_INTERLACE;
264 asm_flags = png_get_asm_flags(png_ptr);
265 png_set_asm_flags(png_ptr, asm_flags & ~mmx_disable_mask);
266
267
268 /* Now query libpng's asm settings, just for yuks. Note that this
269 * differs from the querying of its *potential* MMX capabilities
270 * in readpng2_version_info(); this is true runtime verification. */
271
272 asm_flags = png_get_asm_flags(png_ptr);
273 mmx_mask = png_get_mmx_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE,
274 &compilerID);
275 if (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED)
276 fprintf(stderr,
277 " MMX support (%s version) is compiled into libpng\n",
278 compilerID == 1? "MSVC++" :
279 (compilerID == 2? "GNU C" : "unknown"));
280 else
281 fprintf(stderr, " MMX support is not compiled into libpng\n");
282 fprintf(stderr, " MMX instructions are %ssupported by CPU\n",
283 (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)? "" : "not ");
284 fprintf(stderr, " MMX read support for combining rows is %sabled\n",
285 (asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)? "en" : "dis");
286 fprintf(stderr,
287 " MMX read support for expanding interlacing is %sabled\n",
288 (asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)? "en" : "dis");
289 fprintf(stderr, " MMX read support for \"sub\" filter is %sabled\n",
290 (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "en" : "dis");
291 fprintf(stderr, " MMX read support for \"up\" filter is %sabled\n",
292 (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "en" : "dis");
293 fprintf(stderr, " MMX read support for \"avg\" filter is %sabled\n",
294 (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "en" : "dis");
295 fprintf(stderr, " MMX read support for \"Paeth\" filter is %sabled\n",
296 (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "en" : "dis");
297 asm_flags &= (mmx_mask & ~( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \
298 | PNG_ASM_FLAG_MMX_READ_INTERLACE \
299 | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \
300 | PNG_ASM_FLAG_MMX_READ_FILTER_UP \
301 | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \
302 | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ));
303 if (asm_flags)
304 fprintf(stderr,
305 " additional MMX support is also enabled (0x%02lx)\n",
306 asm_flags);
307 #else /* !PNG_ASSEMBLER_CODE_SUPPORTED */
308 fprintf(stderr, " MMX querying is disabled in libpng.\n");
309 #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
310 }
311 #endif
312
313
314 /* make sure we save our pointers for use in readpng2_decode_data() */
315
316 mainprog_ptr->png_ptr = png_ptr;
317 mainprog_ptr->info_ptr = info_ptr;
318
319
320 /* and that's all there is to initialization */
321
322 return 0;
323 }
324
325
326
327
328 /* returns 0 for success, 2 for libpng (longjmp) problem */
329
readpng2_decode_data(mainprog_info * mainprog_ptr,uch * rawbuf,ulg length)330 int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length)
331 {
332 png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
333 png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
334
335
336 /* setjmp() must be called in every function that calls a PNG-reading
337 * libpng function */
338
339 if (setjmp(mainprog_ptr->jmpbuf)) {
340 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
341 mainprog_ptr->png_ptr = NULL;
342 mainprog_ptr->info_ptr = NULL;
343 return 2;
344 }
345
346
347 /* hand off the next chunk of input data to libpng for decoding */
348
349 png_process_data(png_ptr, info_ptr, rawbuf, length);
350
351 return 0;
352 }
353
354
355
356
readpng2_info_callback(png_structp png_ptr,png_infop info_ptr)357 static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
358 {
359 mainprog_info *mainprog_ptr;
360 int color_type, bit_depth;
361 double gamma;
362
363
364 /* setjmp() doesn't make sense here, because we'd either have to exit(),
365 * longjmp() ourselves, or return control to libpng, which doesn't want
366 * to see us again. By not doing anything here, libpng will instead jump
367 * to readpng2_decode_data(), which can return an error value to the main
368 * program. */
369
370
371 /* retrieve the pointer to our special-purpose struct, using the png_ptr
372 * that libpng passed back to us (i.e., not a global this time--there's
373 * no real difference for a single image, but for a multithreaded browser
374 * decoding several PNG images at the same time, one needs to avoid mixing
375 * up different images' structs) */
376
377 mainprog_ptr = png_get_progressive_ptr(png_ptr);
378
379 if (mainprog_ptr == NULL) { /* we be hosed */
380 fprintf(stderr,
381 "readpng2 error: main struct not recoverable in info_callback.\n");
382 fflush(stderr);
383 return;
384 /*
385 * Alternatively, we could call our error-handler just like libpng
386 * does, which would effectively terminate the program. Since this
387 * can only happen if png_ptr gets redirected somewhere odd or the
388 * main PNG struct gets wiped, we're probably toast anyway. (If
389 * png_ptr itself is NULL, we would not have been called.)
390 */
391 }
392
393
394 /* this is just like in the non-progressive case */
395
396 png_get_IHDR(png_ptr, info_ptr, &mainprog_ptr->width,
397 &mainprog_ptr->height, &bit_depth, &color_type, NULL, NULL, NULL);
398
399
400 /* since we know we've read all of the PNG file's "header" (i.e., up
401 * to IDAT), we can check for a background color here */
402
403 if (mainprog_ptr->need_bgcolor &&
404 png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
405 {
406 png_color_16p pBackground;
407
408 /* it is not obvious from the libpng documentation, but this function
409 * takes a pointer to a pointer, and it always returns valid red,
410 * green and blue values, regardless of color_type: */
411 png_get_bKGD(png_ptr, info_ptr, &pBackground);
412
413 /* however, it always returns the raw bKGD data, regardless of any
414 * bit-depth transformations, so check depth and adjust if necessary */
415 if (bit_depth == 16) {
416 mainprog_ptr->bg_red = pBackground->red >> 8;
417 mainprog_ptr->bg_green = pBackground->green >> 8;
418 mainprog_ptr->bg_blue = pBackground->blue >> 8;
419 } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
420 if (bit_depth == 1)
421 mainprog_ptr->bg_red = mainprog_ptr->bg_green =
422 mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
423 else if (bit_depth == 2)
424 mainprog_ptr->bg_red = mainprog_ptr->bg_green =
425 mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
426 else /* bit_depth == 4 */
427 mainprog_ptr->bg_red = mainprog_ptr->bg_green =
428 mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
429 } else {
430 mainprog_ptr->bg_red = (uch)pBackground->red;
431 mainprog_ptr->bg_green = (uch)pBackground->green;
432 mainprog_ptr->bg_blue = (uch)pBackground->blue;
433 }
434 }
435
436
437 /* as before, let libpng expand palette images to RGB, low-bit-depth
438 * grayscale images to 8 bits, transparency chunks to full alpha channel;
439 * strip 16-bit-per-sample images to 8 bits per sample; and convert
440 * grayscale to RGB[A] */
441
442 if (color_type == PNG_COLOR_TYPE_PALETTE)
443 png_set_expand(png_ptr);
444 if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
445 png_set_expand(png_ptr);
446 if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
447 png_set_expand(png_ptr);
448 if (bit_depth == 16)
449 png_set_strip_16(png_ptr);
450 if (color_type == PNG_COLOR_TYPE_GRAY ||
451 color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
452 png_set_gray_to_rgb(png_ptr);
453
454
455 /* Unlike the basic viewer, which was designed to operate on local files,
456 * this program is intended to simulate a web browser--even though we
457 * actually read from a local file, too. But because we are pretending
458 * that most of the images originate on the Internet, we follow the recom-
459 * mendation of the sRGB proposal and treat unlabelled images (no gAMA
460 * chunk) as existing in the sRGB color space. That is, we assume that
461 * such images have a file gamma of 0.45455, which corresponds to a PC-like
462 * display system. This change in assumptions will have no effect on a
463 * PC-like system, but on a Mac, SGI, NeXT or other system with a non-
464 * identity lookup table, it will darken unlabelled images, which effec-
465 * tively favors images from PC-like systems over those originating on
466 * the local platform. Note that mainprog_ptr->display_exponent is the
467 * "gamma" value for the entire display system, i.e., the product of
468 * LUT_exponent and CRT_exponent. */
469
470 if (png_get_gAMA(png_ptr, info_ptr, &gamma))
471 png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
472 else
473 png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
474
475
476 /* we'll let libpng expand interlaced images, too */
477
478 mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
479
480
481 /* all transformations have been registered; now update info_ptr data and
482 * then get rowbytes and channels */
483
484 png_read_update_info(png_ptr, info_ptr);
485
486 mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
487 mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
488
489
490 /* Call the main program to allocate memory for the image buffer and
491 * initialize windows and whatnot. (The old-style function-pointer
492 * invocation is used for compatibility with a few supposedly ANSI
493 * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */
494
495 (*mainprog_ptr->mainprog_init)();
496
497
498 /* and that takes care of initialization */
499
500 return;
501 }
502
503
504
505
506
readpng2_row_callback(png_structp png_ptr,png_bytep new_row,png_uint_32 row_num,int pass)507 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
508 png_uint_32 row_num, int pass)
509 {
510 mainprog_info *mainprog_ptr;
511
512
513 /* first check whether the row differs from the previous pass; if not,
514 * nothing to combine or display */
515
516 if (!new_row)
517 return;
518
519
520 /* retrieve the pointer to our special-purpose struct so we can access
521 * the old rows and image-display callback function */
522
523 mainprog_ptr = png_get_progressive_ptr(png_ptr);
524
525
526 /* save the pass number for optional use by the front end */
527
528 mainprog_ptr->pass = pass;
529
530
531 /* have libpng either combine the new row data with the existing row data
532 * from previous passes (if interlaced) or else just copy the new row
533 * into the main program's image buffer */
534
535 png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
536 new_row);
537
538
539 /* finally, call the display routine in the main program with the number
540 * of the row we just updated */
541
542 (*mainprog_ptr->mainprog_display_row)(row_num);
543
544
545 /* and we're ready for more */
546
547 return;
548 }
549
550
551
552
553
readpng2_end_callback(png_structp png_ptr,png_infop info_ptr)554 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
555 {
556 mainprog_info *mainprog_ptr;
557
558
559 /* retrieve the pointer to our special-purpose struct */
560
561 mainprog_ptr = png_get_progressive_ptr(png_ptr);
562
563
564 /* let the main program know that it should flush any buffered image
565 * data to the display now and set a "done" flag or whatever, but note
566 * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do
567 * NOT call readpng2_cleanup() either here or in the finish_display()
568 * routine; wait until control returns to the main program via
569 * readpng2_decode_data() */
570
571 (*mainprog_ptr->mainprog_finish_display)();
572
573
574 /* all done */
575
576 return;
577 }
578
579
580
581
582
readpng2_cleanup(mainprog_info * mainprog_ptr)583 void readpng2_cleanup(mainprog_info *mainprog_ptr)
584 {
585 png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
586 png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
587
588 if (png_ptr && info_ptr)
589 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
590
591 mainprog_ptr->png_ptr = NULL;
592 mainprog_ptr->info_ptr = NULL;
593 }
594
595
596
597
598
readpng2_error_handler(png_structp png_ptr,png_const_charp msg)599 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
600 {
601 mainprog_info *mainprog_ptr;
602
603 /* This function, aside from the extra step of retrieving the "error
604 * pointer" (below) and the fact that it exists within the application
605 * rather than within libpng, is essentially identical to libpng's
606 * default error handler. The second point is critical: since both
607 * setjmp() and longjmp() are called from the same code, they are
608 * guaranteed to have compatible notions of how big a jmp_buf is,
609 * regardless of whether _BSD_SOURCE or anything else has (or has not)
610 * been defined. */
611
612 fprintf(stderr, "readpng2 libpng error: %s\n", msg);
613 fflush(stderr);
614
615 mainprog_ptr = png_get_error_ptr(png_ptr);
616 if (mainprog_ptr == NULL) { /* we are completely hosed now */
617 fprintf(stderr,
618 "readpng2 severe error: jmpbuf not recoverable; terminating.\n");
619 fflush(stderr);
620 exit(99);
621 }
622
623 longjmp(mainprog_ptr->jmpbuf, 1);
624 }
625