|
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_check_sig(sig, 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 double gamma; |
|
383 |
|
384 |
|
385 /* setjmp() doesn't make sense here, because we'd either have to exit(), |
|
386 * longjmp() ourselves, or return control to libpng, which doesn't want |
|
387 * to see us again. By not doing anything here, libpng will instead jump |
|
388 * to readpng2_decode_data(), which can return an error value to the main |
|
389 * program. */ |
|
390 |
|
391 |
|
392 /* retrieve the pointer to our special-purpose struct, using the png_ptr |
|
393 * that libpng passed back to us (i.e., not a global this time--there's |
|
394 * no real difference for a single image, but for a multithreaded browser |
|
395 * decoding several PNG images at the same time, one needs to avoid mixing |
|
396 * up different images' structs) */ |
|
397 |
|
398 mainprog_ptr = png_get_progressive_ptr(png_ptr); |
|
399 |
|
400 if (mainprog_ptr == NULL) { /* we be hosed */ |
|
401 fprintf(stderr, |
|
402 "readpng2 error: main struct not recoverable in info_callback.\n"); |
|
403 fflush(stderr); |
|
404 return; |
|
405 /* |
|
406 * Alternatively, we could call our error-handler just like libpng |
|
407 * does, which would effectively terminate the program. Since this |
|
408 * can only happen if png_ptr gets redirected somewhere odd or the |
|
409 * main PNG struct gets wiped, we're probably toast anyway. (If |
|
410 * png_ptr itself is NULL, we would not have been called.) |
|
411 */ |
|
412 } |
|
413 |
|
414 |
|
415 /* this is just like in the non-progressive case */ |
|
416 |
|
417 png_get_IHDR(png_ptr, info_ptr, &mainprog_ptr->width, |
|
418 &mainprog_ptr->height, &bit_depth, &color_type, NULL, NULL, NULL); |
|
419 |
|
420 |
|
421 /* since we know we've read all of the PNG file's "header" (i.e., up |
|
422 * to IDAT), we can check for a background color here */ |
|
423 |
|
424 if (mainprog_ptr->need_bgcolor && |
|
425 png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD)) |
|
426 { |
|
427 png_color_16p pBackground; |
|
428 |
|
429 /* it is not obvious from the libpng documentation, but this function |
|
430 * takes a pointer to a pointer, and it always returns valid red, |
|
431 * green and blue values, regardless of color_type: */ |
|
432 png_get_bKGD(png_ptr, info_ptr, &pBackground); |
|
433 |
|
434 /* however, it always returns the raw bKGD data, regardless of any |
|
435 * bit-depth transformations, so check depth and adjust if necessary */ |
|
436 if (bit_depth == 16) { |
|
437 mainprog_ptr->bg_red = pBackground->red >> 8; |
|
438 mainprog_ptr->bg_green = pBackground->green >> 8; |
|
439 mainprog_ptr->bg_blue = pBackground->blue >> 8; |
|
440 } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) { |
|
441 if (bit_depth == 1) |
|
442 mainprog_ptr->bg_red = mainprog_ptr->bg_green = |
|
443 mainprog_ptr->bg_blue = pBackground->gray? 255 : 0; |
|
444 else if (bit_depth == 2) |
|
445 mainprog_ptr->bg_red = mainprog_ptr->bg_green = |
|
446 mainprog_ptr->bg_blue = (255/3) * pBackground->gray; |
|
447 else /* bit_depth == 4 */ |
|
448 mainprog_ptr->bg_red = mainprog_ptr->bg_green = |
|
449 mainprog_ptr->bg_blue = (255/15) * pBackground->gray; |
|
450 } else { |
|
451 mainprog_ptr->bg_red = (uch)pBackground->red; |
|
452 mainprog_ptr->bg_green = (uch)pBackground->green; |
|
453 mainprog_ptr->bg_blue = (uch)pBackground->blue; |
|
454 } |
|
455 } |
|
456 |
|
457 |
|
458 /* as before, let libpng expand palette images to RGB, low-bit-depth |
|
459 * grayscale images to 8 bits, transparency chunks to full alpha channel; |
|
460 * strip 16-bit-per-sample images to 8 bits per sample; and convert |
|
461 * grayscale to RGB[A] */ |
|
462 |
|
463 if (color_type == PNG_COLOR_TYPE_PALETTE) |
|
464 png_set_expand(png_ptr); |
|
465 if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) |
|
466 png_set_expand(png_ptr); |
|
467 if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) |
|
468 png_set_expand(png_ptr); |
|
469 if (bit_depth == 16) |
|
470 png_set_strip_16(png_ptr); |
|
471 if (color_type == PNG_COLOR_TYPE_GRAY || |
|
472 color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
|
473 png_set_gray_to_rgb(png_ptr); |
|
474 |
|
475 |
|
476 /* Unlike the basic viewer, which was designed to operate on local files, |
|
477 * this program is intended to simulate a web browser--even though we |
|
478 * actually read from a local file, too. But because we are pretending |
|
479 * that most of the images originate on the Internet, we follow the recom- |
|
480 * mendation of the sRGB proposal and treat unlabelled images (no gAMA |
|
481 * chunk) as existing in the sRGB color space. That is, we assume that |
|
482 * such images have a file gamma of 0.45455, which corresponds to a PC-like |
|
483 * display system. This change in assumptions will have no effect on a |
|
484 * PC-like system, but on a Mac, SGI, NeXT or other system with a non- |
|
485 * identity lookup table, it will darken unlabelled images, which effec- |
|
486 * tively favors images from PC-like systems over those originating on |
|
487 * the local platform. Note that mainprog_ptr->display_exponent is the |
|
488 * "gamma" value for the entire display system, i.e., the product of |
|
489 * LUT_exponent and CRT_exponent. */ |
|
490 |
|
491 if (png_get_gAMA(png_ptr, info_ptr, &gamma)) |
|
492 png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma); |
|
493 else |
|
494 png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455); |
|
495 |
|
496 |
|
497 /* we'll let libpng expand interlaced images, too */ |
|
498 |
|
499 mainprog_ptr->passes = png_set_interlace_handling(png_ptr); |
|
500 |
|
501 |
|
502 /* all transformations have been registered; now update info_ptr data and |
|
503 * then get rowbytes and channels */ |
|
504 |
|
505 png_read_update_info(png_ptr, info_ptr); |
|
506 |
|
507 mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr); |
|
508 mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr); |
|
509 |
|
510 |
|
511 /* Call the main program to allocate memory for the image buffer and |
|
512 * initialize windows and whatnot. (The old-style function-pointer |
|
513 * invocation is used for compatibility with a few supposedly ANSI |
|
514 * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */ |
|
515 |
|
516 (*mainprog_ptr->mainprog_init)(); |
|
517 |
|
518 |
|
519 /* and that takes care of initialization */ |
|
520 |
|
521 return; |
|
522 } |
|
523 |
|
524 |
|
525 |
|
526 |
|
527 |
|
528 static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row, |
|
529 png_uint_32 row_num, int pass) |
|
530 { |
|
531 mainprog_info *mainprog_ptr; |
|
532 |
|
533 |
|
534 /* first check whether the row differs from the previous pass; if not, |
|
535 * nothing to combine or display */ |
|
536 |
|
537 if (!new_row) |
|
538 return; |
|
539 |
|
540 |
|
541 /* retrieve the pointer to our special-purpose struct so we can access |
|
542 * the old rows and image-display callback function */ |
|
543 |
|
544 mainprog_ptr = png_get_progressive_ptr(png_ptr); |
|
545 |
|
546 |
|
547 /* save the pass number for optional use by the front end */ |
|
548 |
|
549 mainprog_ptr->pass = pass; |
|
550 |
|
551 |
|
552 /* have libpng either combine the new row data with the existing row data |
|
553 * from previous passes (if interlaced) or else just copy the new row |
|
554 * into the main program's image buffer */ |
|
555 |
|
556 png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num], |
|
557 new_row); |
|
558 |
|
559 |
|
560 /* finally, call the display routine in the main program with the number |
|
561 * of the row we just updated */ |
|
562 |
|
563 (*mainprog_ptr->mainprog_display_row)(row_num); |
|
564 |
|
565 |
|
566 /* and we're ready for more */ |
|
567 |
|
568 return; |
|
569 } |
|
570 |
|
571 |
|
572 |
|
573 |
|
574 |
|
575 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr) |
|
576 { |
|
577 mainprog_info *mainprog_ptr; |
|
578 |
|
579 |
|
580 /* retrieve the pointer to our special-purpose struct */ |
|
581 |
|
582 mainprog_ptr = png_get_progressive_ptr(png_ptr); |
|
583 |
|
584 |
|
585 /* let the main program know that it should flush any buffered image |
|
586 * data to the display now and set a "done" flag or whatever, but note |
|
587 * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do |
|
588 * NOT call readpng2_cleanup() either here or in the finish_display() |
|
589 * routine; wait until control returns to the main program via |
|
590 * readpng2_decode_data() */ |
|
591 |
|
592 (*mainprog_ptr->mainprog_finish_display)(); |
|
593 |
|
594 |
|
595 /* all done */ |
|
596 |
|
597 return; |
|
598 } |
|
599 |
|
600 |
|
601 |
|
602 |
|
603 |
|
604 void readpng2_cleanup(mainprog_info *mainprog_ptr) |
|
605 { |
|
606 png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr; |
|
607 png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr; |
|
608 |
|
609 if (png_ptr && info_ptr) |
|
610 png_destroy_read_struct(&png_ptr, &info_ptr, NULL); |
|
611 |
|
612 mainprog_ptr->png_ptr = NULL; |
|
613 mainprog_ptr->info_ptr = NULL; |
|
614 } |
|
615 |
|
616 |
|
617 |
|
618 |
|
619 |
|
620 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg) |
|
621 { |
|
622 mainprog_info *mainprog_ptr; |
|
623 |
|
624 /* This function, aside from the extra step of retrieving the "error |
|
625 * pointer" (below) and the fact that it exists within the application |
|
626 * rather than within libpng, is essentially identical to libpng's |
|
627 * default error handler. The second point is critical: since both |
|
628 * setjmp() and longjmp() are called from the same code, they are |
|
629 * guaranteed to have compatible notions of how big a jmp_buf is, |
|
630 * regardless of whether _BSD_SOURCE or anything else has (or has not) |
|
631 * been defined. */ |
|
632 |
|
633 fprintf(stderr, "readpng2 libpng error: %s\n", msg); |
|
634 fflush(stderr); |
|
635 |
|
636 mainprog_ptr = png_get_error_ptr(png_ptr); |
|
637 if (mainprog_ptr == NULL) { /* we are completely hosed now */ |
|
638 fprintf(stderr, |
|
639 "readpng2 severe error: jmpbuf not recoverable; terminating.\n"); |
|
640 fflush(stderr); |
|
641 exit(99); |
|
642 } |
|
643 |
|
644 longjmp(mainprog_ptr->jmpbuf, 1); |
|
645 } |