readpng2.c@ 59500

最後變更在這個檔案從59500是 58796,由 vboxsync 提交於 9 年前
libpng 1.2.54 unmodified
屬性 svn:eol-style 設為 `native`
檔案大小: 24.2 KB

行
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
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
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
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
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
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
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
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
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
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	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/libpng-1.2.54/contrib/gregbook/readpng2.c@ 59500

以其他格式下載: