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