Contents of /trunk/netpbm/patches/netpbm-10.35.81-libpng15.patch
Parent Directory | Revision Log
Revision 1409 -
(show annotations)
(download)
Tue Jul 12 20:29:57 2011 UTC (13 years, 2 months ago) by niro
File size: 54101 byte(s)
Tue Jul 12 20:29:57 2011 UTC (13 years, 2 months ago) by niro
File size: 54101 byte(s)
-added libpng-1.5 patch from netbsd
1 | consolidated patches ac,af,aj,ak,al from netbsd |
2 | |
3 | ## |
4 | |
5 | $NetBSD: patch-ac,v 1.22 2011/01/15 18:37:46 tron Exp $ |
6 | |
7 | Fix build with png-1.5. |
8 | |
9 | --- converter/other/pnmtopng.c.orig 2010-12-10 18:19:40.000000000 +0000 |
10 | +++ converter/other/pnmtopng.c 2011-01-15 11:15:25.000000000 +0000 |
11 | @@ -61,7 +61,8 @@ |
12 | #include <assert.h> |
13 | #include <string.h> /* strcat() */ |
14 | #include <limits.h> |
15 | -#include <png.h> /* includes zlib.h and setjmp.h */ |
16 | +#include <png.h> /* includes setjmp.h */ |
17 | +#include <zlib.h> |
18 | #include "pnm.h" |
19 | #include "pngtxt.h" |
20 | #include "shhopt.h" |
21 | @@ -69,13 +70,6 @@ |
22 | #include "nstring.h" |
23 | #include "version.h" |
24 | |
25 | -#if PNG_LIBPNG_VER >= 10400 |
26 | -#error Your PNG library (<png.h>) is incompatible with this Netpbm source code. |
27 | -#error You need either an older PNG library (older than 1.4) |
28 | -#error newer Netpbm source code (at least 10.47.04) |
29 | -#endif |
30 | - |
31 | - |
32 | struct zlibCompression { |
33 | /* These are parameters that describe a form of zlib compression. |
34 | Values have the same meaning as the similarly named arguments to |
35 | @@ -2079,6 +2073,7 @@ |
36 | gray * const alpha_mask, |
37 | colorhash_table const cht, |
38 | coloralphahash_table const caht, |
39 | + png_struct * const png_ptr, |
40 | png_info * const info_ptr, |
41 | xelval const png_maxval, |
42 | unsigned int const depth) { |
43 | @@ -2091,20 +2086,20 @@ |
44 | xel p_png; |
45 | xel const p = xelrow[col]; |
46 | PPM_DEPTH(p_png, p, maxval, png_maxval); |
47 | - if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY || |
48 | - info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { |
49 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY || |
50 | + png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY_ALPHA) { |
51 | if (depth == 16) |
52 | *pp++ = PNM_GET1(p_png) >> 8; |
53 | *pp++ = PNM_GET1(p_png) & 0xff; |
54 | - } else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { |
55 | + } else if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { |
56 | unsigned int paletteIndex; |
57 | if (alpha) |
58 | paletteIndex = lookupColorAlpha(caht, &p, &alpha_mask[col]); |
59 | else |
60 | paletteIndex = ppm_lookupcolor(cht, &p); |
61 | *pp++ = paletteIndex; |
62 | - } else if (info_ptr->color_type == PNG_COLOR_TYPE_RGB || |
63 | - info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) { |
64 | + } else if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB || |
65 | + png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB_ALPHA) { |
66 | if (depth == 16) |
67 | *pp++ = PPM_GETR(p_png) >> 8; |
68 | *pp++ = PPM_GETR(p_png) & 0xff; |
69 | @@ -2117,7 +2112,7 @@ |
70 | } else |
71 | pm_error("INTERNAL ERROR: undefined color_type"); |
72 | |
73 | - if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) { |
74 | + if (png_get_color_type(png_ptr, info_ptr) & PNG_COLOR_MASK_ALPHA) { |
75 | int const png_alphaval = (int) |
76 | alpha_mask[col] * (float) png_maxval / maxval + 0.5; |
77 | if (depth == 16) |
78 | @@ -2174,7 +2169,7 @@ |
79 | |
80 | makePngLine(line, xelrow, cols, maxval, |
81 | alpha, alpha ? alpha_mask[row] : NULL, |
82 | - cht, caht, info_ptr, png_maxval, depth); |
83 | + cht, caht, png_ptr, info_ptr, png_maxval, depth); |
84 | |
85 | png_write_row(png_ptr, line); |
86 | } |
87 | @@ -2186,12 +2181,12 @@ |
88 | |
89 | static void |
90 | doGamaChunk(struct cmdlineInfo const cmdline, |
91 | + png_struct * const png_ptr, |
92 | png_info * const info_ptr) { |
93 | |
94 | if (cmdline.gammaSpec) { |
95 | /* gAMA chunk */ |
96 | - info_ptr->valid |= PNG_INFO_gAMA; |
97 | - info_ptr->gamma = cmdline.gamma; |
98 | + png_set_gAMA(png_ptr, info_ptr, cmdline.gamma); |
99 | } |
100 | } |
101 | |
102 | @@ -2199,20 +2194,15 @@ |
103 | |
104 | static void |
105 | doChrmChunk(struct cmdlineInfo const cmdline, |
106 | + png_struct * const png_ptr, |
107 | png_info * const info_ptr) { |
108 | |
109 | if (cmdline.rgbSpec) { |
110 | /* cHRM chunk */ |
111 | - info_ptr->valid |= PNG_INFO_cHRM; |
112 | - |
113 | - info_ptr->x_white = cmdline.rgb.wx; |
114 | - info_ptr->y_white = cmdline.rgb.wy; |
115 | - info_ptr->x_red = cmdline.rgb.rx; |
116 | - info_ptr->y_red = cmdline.rgb.ry; |
117 | - info_ptr->x_green = cmdline.rgb.gx; |
118 | - info_ptr->y_green = cmdline.rgb.gy; |
119 | - info_ptr->x_blue = cmdline.rgb.bx; |
120 | - info_ptr->y_blue = cmdline.rgb.by; |
121 | + |
122 | + png_set_cHRM (png_ptr, info_ptr, cmdline.rgb.wx, cmdline.rgb.wy, |
123 | + cmdline.rgb.rx, cmdline.rgb.ry, cmdline.rgb.gx, |
124 | + cmdline.rgb.gy, cmdline.rgb.bx, cmdline.rgb.by); |
125 | } |
126 | } |
127 | |
128 | @@ -2220,15 +2210,12 @@ |
129 | |
130 | static void |
131 | doPhysChunk(struct cmdlineInfo const cmdline, |
132 | + png_struct * const png_ptr, |
133 | png_info * const info_ptr) { |
134 | |
135 | if (cmdline.sizeSpec) { |
136 | /* pHYS chunk */ |
137 | - info_ptr->valid |= PNG_INFO_pHYs; |
138 | - |
139 | - info_ptr->x_pixels_per_unit = cmdline.size.x; |
140 | - info_ptr->y_pixels_per_unit = cmdline.size.y; |
141 | - info_ptr->phys_unit_type = cmdline.size.unit; |
142 | + png_set_pHYs(png_ptr, info_ptr, cmdline.size.x, cmdline.size.y, cmdline.size.unit); |
143 | } |
144 | } |
145 | |
146 | @@ -2237,26 +2224,28 @@ |
147 | |
148 | static void |
149 | doTimeChunk(struct cmdlineInfo const cmdline, |
150 | + png_struct * const png_ptr, |
151 | png_info * const info_ptr) { |
152 | |
153 | if (cmdline.modtimeSpec) { |
154 | /* tIME chunk */ |
155 | - info_ptr->valid |= PNG_INFO_tIME; |
156 | - |
157 | - png_convert_from_time_t(&info_ptr->mod_time, cmdline.modtime); |
158 | + png_timep ptime; |
159 | + png_convert_from_time_t(ptime, cmdline.modtime); |
160 | + png_set_tIME(png_ptr, info_ptr, ptime); |
161 | } |
162 | } |
163 | |
164 | |
165 | |
166 | static void |
167 | -doSbitChunk(png_info * const pngInfoP, |
168 | +doSbitChunk(png_struct * const pngP, |
169 | + png_info * const pngInfoP, |
170 | xelval const pngMaxval, |
171 | xelval const maxval, |
172 | bool const alpha, |
173 | xelval const alphaMaxval) { |
174 | |
175 | - if (pngInfoP->color_type != PNG_COLOR_TYPE_PALETTE && |
176 | + if (png_get_color_type(pngP, pngInfoP) != PNG_COLOR_TYPE_PALETTE && |
177 | (pngMaxval > maxval || (alpha && pngMaxval > alphaMaxval))) { |
178 | |
179 | /* We're writing in a bit depth that doesn't match the maxval |
180 | @@ -2275,26 +2264,28 @@ |
181 | sBIT chunk. |
182 | */ |
183 | |
184 | - pngInfoP->valid |= PNG_INFO_sBIT; |
185 | - |
186 | { |
187 | int const sbitval = pm_maxvaltobits(MIN(maxval, pngMaxval)); |
188 | + png_color_8 sbit; |
189 | |
190 | - if (pngInfoP->color_type & PNG_COLOR_MASK_COLOR) { |
191 | - pngInfoP->sig_bit.red = sbitval; |
192 | - pngInfoP->sig_bit.green = sbitval; |
193 | - pngInfoP->sig_bit.blue = sbitval; |
194 | + (void)memset(&sbit, 0, sizeof(sbit)); |
195 | + if (png_get_color_type(pngP, pngInfoP) & PNG_COLOR_MASK_COLOR) { |
196 | + sbit.red = sbitval; |
197 | + sbit.green = sbitval; |
198 | + sbit.blue = sbitval; |
199 | } else |
200 | - pngInfoP->sig_bit.gray = sbitval; |
201 | + sbit.gray = sbitval; |
202 | |
203 | if (verbose) |
204 | pm_message("Writing sBIT chunk with bits = %d", sbitval); |
205 | - } |
206 | - if (pngInfoP->color_type & PNG_COLOR_MASK_ALPHA) { |
207 | - pngInfoP->sig_bit.alpha = |
208 | - pm_maxvaltobits(MIN(alphaMaxval, pngMaxval)); |
209 | - if (verbose) |
210 | - pm_message(" alpha bits = %d", pngInfoP->sig_bit.alpha); |
211 | + |
212 | + if (png_get_color_type(pngP, pngInfoP) & PNG_COLOR_MASK_ALPHA) { |
213 | + sbit.alpha = |
214 | + pm_maxvaltobits(MIN(alphaMaxval, pngMaxval)); |
215 | + if (verbose) |
216 | + pm_message(" alpha bits = %d", sbit.alpha); |
217 | + } |
218 | + png_set_sBIT(pngP, pngInfoP, &sbit); |
219 | } |
220 | } |
221 | } |
222 | @@ -2391,6 +2382,8 @@ |
223 | xelval maxmaxval; |
224 | gray ** alpha_mask; |
225 | |
226 | + int color_type; |
227 | + |
228 | /* these guys are initialized to quiet compiler warnings: */ |
229 | maxmaxval = 255; |
230 | alpha_mask = NULL; |
231 | @@ -2576,43 +2569,42 @@ |
232 | pm_error ("setjmp returns error condition (2)"); |
233 | } |
234 | |
235 | - png_init_io (png_ptr, stdout); |
236 | - info_ptr->width = cols; |
237 | - info_ptr->height = rows; |
238 | - info_ptr->bit_depth = depth; |
239 | - |
240 | if (colorMapped) |
241 | - info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; |
242 | - else if (pnm_type == PPM_TYPE) |
243 | - info_ptr->color_type = PNG_COLOR_TYPE_RGB; |
244 | - else |
245 | - info_ptr->color_type = PNG_COLOR_TYPE_GRAY; |
246 | + color_type = PNG_COLOR_TYPE_PALETTE; |
247 | + else if (pnm_type == PPM_TYPE) { |
248 | + if (alpha) |
249 | + color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
250 | + else |
251 | + color_type = PNG_COLOR_TYPE_RGB; |
252 | + } else { |
253 | + if (alpha) |
254 | + color_type = PNG_COLOR_TYPE_GRAY_ALPHA; |
255 | + else |
256 | + color_type = PNG_COLOR_TYPE_GRAY; |
257 | + } |
258 | |
259 | - if (alpha && info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
260 | - info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; |
261 | + png_set_IHDR(png_ptr, info_ptr, cols, rows, depth, color_type, 0, 0, 0); |
262 | + png_init_io (png_ptr, stdout); |
263 | |
264 | - info_ptr->interlace_type = cmdline.interlace; |
265 | + if (cmdline.interlace) |
266 | + png_set_interlace_handling(png_ptr); |
267 | |
268 | - doGamaChunk(cmdline, info_ptr); |
269 | + doGamaChunk(cmdline, png_ptr, info_ptr); |
270 | |
271 | - doChrmChunk(cmdline, info_ptr); |
272 | + doChrmChunk(cmdline, png_ptr, info_ptr); |
273 | |
274 | - doPhysChunk(cmdline, info_ptr); |
275 | + doPhysChunk(cmdline, png_ptr, info_ptr); |
276 | |
277 | - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { |
278 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { |
279 | |
280 | /* creating PNG palette (PLTE and tRNS chunks) */ |
281 | |
282 | createPngPalette(palette_pnm, palette_size, maxval, |
283 | trans_pnm, trans_size, alpha_maxval, |
284 | palette, trans); |
285 | - info_ptr->valid |= PNG_INFO_PLTE; |
286 | - info_ptr->palette = palette; |
287 | - info_ptr->num_palette = palette_size; |
288 | + png_set_PLTE(png_ptr, info_ptr, palette, palette_size); |
289 | if (trans_size > 0) { |
290 | - info_ptr->valid |= PNG_INFO_tRNS; |
291 | - info_ptr->trans = trans; |
292 | - info_ptr->num_trans = trans_size; /* omit opaque values */ |
293 | + png_set_tRNS(png_ptr, info_ptr, trans, trans_size, NULL); |
294 | } |
295 | /* creating hIST chunk */ |
296 | if (cmdline.hist) { |
297 | @@ -2638,18 +2630,17 @@ |
298 | |
299 | ppm_freecolorhash(cht); |
300 | |
301 | - info_ptr->valid |= PNG_INFO_hIST; |
302 | - info_ptr->hist = histogram; |
303 | + png_set_hIST(png_ptr, info_ptr, histogram); |
304 | if (verbose) |
305 | pm_message("histogram created"); |
306 | } |
307 | } else { /* color_type != PNG_COLOR_TYPE_PALETTE */ |
308 | - if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY || |
309 | - info_ptr->color_type == PNG_COLOR_TYPE_RGB) { |
310 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY || |
311 | + png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB) { |
312 | if (transparent > 0) { |
313 | - info_ptr->valid |= PNG_INFO_tRNS; |
314 | - info_ptr->trans_values = |
315 | - xelToPngColor_16(transcolor, maxval, png_maxval); |
316 | + png_color_16 trans_color = xelToPngColor_16(transcolor, maxval, png_maxval); |
317 | + png_set_tRNS(png_ptr, info_ptr, NULL, 0, &trans_color); |
318 | + |
319 | } |
320 | } else { |
321 | /* This is PNG_COLOR_MASK_ALPHA. Transparency will be handled |
322 | @@ -2657,43 +2648,49 @@ |
323 | */ |
324 | } |
325 | if (verbose) { |
326 | - if (info_ptr->valid && PNG_INFO_tRNS) |
327 | + if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) { |
328 | + png_color_16p trans_color; |
329 | + |
330 | + png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_color); |
331 | pm_message("Transparent color {gray, red, green, blue} = " |
332 | "{%d, %d, %d, %d}", |
333 | - info_ptr->trans_values.gray, |
334 | - info_ptr->trans_values.red, |
335 | - info_ptr->trans_values.green, |
336 | - info_ptr->trans_values.blue); |
337 | - else |
338 | + trans_color->gray, |
339 | + trans_color->red, |
340 | + trans_color->green, |
341 | + trans_color->blue); |
342 | + } else |
343 | pm_message("No transparent color"); |
344 | } |
345 | } |
346 | |
347 | /* bKGD chunk */ |
348 | if (cmdline.background) { |
349 | - info_ptr->valid |= PNG_INFO_bKGD; |
350 | - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { |
351 | - info_ptr->background.index = background_index; |
352 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { |
353 | + png_color_16 background; |
354 | + |
355 | + (void)memset(&background, 0, sizeof(background)); |
356 | + background.index = background_index; |
357 | + png_set_bKGD(png_ptr, info_ptr, &background); |
358 | } else { |
359 | - info_ptr->background = |
360 | - xelToPngColor_16(backcolor, maxval, png_maxval); |
361 | + png_color_16 background = xelToPngColor_16(backcolor, maxval, png_maxval); |
362 | + png_set_bKGD(png_ptr, info_ptr, &background); |
363 | if (verbose) |
364 | pm_message("Writing bKGD chunk with background color " |
365 | " {gray, red, green, blue} = {%d, %d, %d, %d}", |
366 | - info_ptr->background.gray, |
367 | - info_ptr->background.red, |
368 | - info_ptr->background.green, |
369 | - info_ptr->background.blue ); |
370 | + background.gray, |
371 | + background.red, |
372 | + background.green, |
373 | + background.blue ); |
374 | } |
375 | } |
376 | |
377 | - doSbitChunk(info_ptr, png_maxval, maxval, alpha, alpha_maxval); |
378 | + doSbitChunk(png_ptr, info_ptr, png_maxval, maxval, alpha, alpha_maxval); |
379 | |
380 | /* tEXT and zTXT chunks */ |
381 | if (cmdline.text || cmdline.ztxt) |
382 | - pnmpng_read_text(info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose); |
383 | + pnmpng_read_text(png_ptr, info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose); |
384 | |
385 | - doTimeChunk(cmdline, info_ptr); |
386 | + doTimeChunk(cmdline, png_ptr, info_ptr); |
387 | |
388 | if (cmdline.filterSet != 0) |
389 | png_set_filter(png_ptr, 0, cmdline.filterSet); |
390 | @@ -2703,6 +2700,7 @@ |
391 | /* write the png-info struct */ |
392 | png_write_info(png_ptr, info_ptr); |
393 | |
394 | +#if 0 |
395 | if (cmdline.text || cmdline.ztxt) |
396 | /* prevent from being written twice with png_write_end */ |
397 | info_ptr->num_text = 0; |
398 | @@ -2710,6 +2708,7 @@ |
399 | if (cmdline.modtime) |
400 | /* prevent from being written twice with png_write_end */ |
401 | info_ptr->valid &= ~PNG_INFO_tIME; |
402 | +#endif |
403 | |
404 | /* let libpng take care of, e.g., bit-depth conversions */ |
405 | png_set_packing (png_ptr); |
406 | $NetBSD: patch-af,v 1.16 2011/04/04 09:17:24 adam Exp $ |
407 | |
408 | Fix build with png-1.5. |
409 | |
410 | --- converter/other/pngtopnm.c.orig 2009-09-03 16:34:36.000000000 +0100 |
411 | +++ converter/other/pngtopnm.c 2011-01-15 18:19:09.000000000 +0000 |
412 | @@ -44,12 +44,6 @@ |
413 | #include "nstring.h" |
414 | #include "shhopt.h" |
415 | |
416 | -#if PNG_LIBPNG_VER >= 10400 |
417 | -#error Your PNG library (<png.h>) is incompatible with this Netpbm source code. |
418 | -#error You need either an older PNG library (older than 1.4) |
419 | -#error newer Netpbm source code (at least 10.48) |
420 | -#endif |
421 | - |
422 | typedef struct _jmpbuf_wrapper { |
423 | jmp_buf jmpbuf; |
424 | } jmpbuf_wrapper; |
425 | @@ -187,7 +181,7 @@ |
426 | |
427 | |
428 | |
429 | -#define get_png_val(p) _get_png_val (&(p), info_ptr->bit_depth) |
430 | +#define get_png_val(p) _get_png_val (&(p), png_get_bit_depth(png_ptr, info_ptr)) |
431 | |
432 | static png_uint_16 |
433 | _get_png_val (png_byte ** const pp, |
434 | @@ -266,33 +260,39 @@ |
435 | } |
436 | |
437 | #ifdef __STDC__ |
438 | -static void save_text (png_info *info_ptr, FILE *tfp) |
439 | +static void save_text (png_structp png_ptr, png_info *info_ptr, FILE *tfp) |
440 | #else |
441 | -static void save_text (info_ptr, tfp) |
442 | +static void save_text (png_ptr, info_ptr, tfp) |
443 | +png_structp png_ptr; |
444 | png_info *info_ptr; |
445 | FILE *tfp; |
446 | #endif |
447 | { |
448 | int i, j, k; |
449 | + png_textp text_ptr; |
450 | + int num_text; |
451 | + |
452 | + if (png_get_text(png_ptr, info_ptr, &text_ptr, &num_text) == 0) |
453 | + return; |
454 | |
455 | - for (i = 0 ; i < info_ptr->num_text ; i++) { |
456 | + for (i = 0 ; i < num_text ; i++) { |
457 | j = 0; |
458 | - while (info_ptr->text[i].key[j] != '\0' && info_ptr->text[i].key[j] != ' ') |
459 | + while (text_ptr[i].key[j] != '\0' && text_ptr[i].key[j] != ' ') |
460 | j++; |
461 | - if (info_ptr->text[i].key[j] != ' ') { |
462 | - fprintf (tfp, "%s", info_ptr->text[i].key); |
463 | - for (j = strlen (info_ptr->text[i].key) ; j < 15 ; j++) |
464 | + if (text_ptr[i].key[j] != ' ') { |
465 | + fprintf (tfp, "%s", text_ptr[i].key); |
466 | + for (j = strlen (text_ptr[i].key) ; j < 15 ; j++) |
467 | putc (' ', tfp); |
468 | } else { |
469 | - fprintf (tfp, "\"%s\"", info_ptr->text[i].key); |
470 | - for (j = strlen (info_ptr->text[i].key) ; j < 13 ; j++) |
471 | + fprintf (tfp, "\"%s\"", text_ptr[i].key); |
472 | + for (j = strlen (text_ptr[i].key) ; j < 13 ; j++) |
473 | putc (' ', tfp); |
474 | } |
475 | putc (' ', tfp); /* at least one space between key and text */ |
476 | |
477 | - for (j = 0 ; j < info_ptr->text[i].text_length ; j++) { |
478 | - putc (info_ptr->text[i].text[j], tfp); |
479 | - if (info_ptr->text[i].text[j] == '\n') |
480 | + for (j = 0 ; j < text_ptr[i].text_length ; j++) { |
481 | + putc (text_ptr[i].text[j], tfp); |
482 | + if (text_ptr[i].text[j] == '\n') |
483 | for (k = 0 ; k < 16 ; k++) |
484 | putc ((int)' ', tfp); |
485 | } |
486 | @@ -301,9 +301,10 @@ |
487 | } |
488 | |
489 | #ifdef __STDC__ |
490 | -static void show_time (png_info *info_ptr) |
491 | +static void show_time (png_structp png_ptr, png_info *info_ptr) |
492 | #else |
493 | -static void show_time (info_ptr) |
494 | +static void show_time (png_ptr, info_ptr) |
495 | +png_structp png_ptr; |
496 | png_info *info_ptr; |
497 | #endif |
498 | { |
499 | @@ -311,12 +312,13 @@ |
500 | "", "January", "February", "March", "April", "May", "June", |
501 | "July", "August", "September", "October", "November", "December" |
502 | }; |
503 | + png_timep mod_time; |
504 | |
505 | - if (info_ptr->valid & PNG_INFO_tIME) { |
506 | + if (png_get_tIME(png_ptr, info_ptr, &mod_time) & PNG_INFO_tIME) { |
507 | pm_message ("modification time: %02d %s %d %02d:%02d:%02d", |
508 | - info_ptr->mod_time.day, month[info_ptr->mod_time.month], |
509 | - info_ptr->mod_time.year, info_ptr->mod_time.hour, |
510 | - info_ptr->mod_time.minute, info_ptr->mod_time.second); |
511 | + mod_time->day, month[mod_time->month], |
512 | + mod_time->year, mod_time->hour, |
513 | + mod_time->minute, mod_time->second); |
514 | } |
515 | } |
516 | |
517 | @@ -353,12 +355,28 @@ |
518 | |
519 | |
520 | static void |
521 | -dump_png_info(png_info *info_ptr) { |
522 | +dump_png_info(png_structp png_ptr, png_info *info_ptr) { |
523 | |
524 | const char *type_string; |
525 | const char *filter_string; |
526 | + png_color_16p background; |
527 | + int num_trans; |
528 | + double gamma; |
529 | + png_color_8p sig_bit; |
530 | + png_colorp palette; |
531 | + int num_palette; |
532 | + png_uint_16p hist; |
533 | + int res_x, res_y, unit_type; |
534 | + png_int_32 offset_x, offset_y; |
535 | + png_timep mod_time; |
536 | + png_charp purpose; |
537 | + png_int_32 X0, X1; |
538 | + int type, nparams; |
539 | + png_charp units; |
540 | + png_charpp params; |
541 | + int file_srgb_intent; |
542 | |
543 | - switch (info_ptr->color_type) { |
544 | + switch (png_get_color_type(png_ptr, info_ptr)) { |
545 | case PNG_COLOR_TYPE_GRAY: |
546 | type_string = "gray"; |
547 | break; |
548 | @@ -380,90 +398,101 @@ |
549 | break; |
550 | } |
551 | |
552 | - switch (info_ptr->filter_type) { |
553 | + switch (png_get_filter_type(png_ptr, info_ptr)) { |
554 | case PNG_FILTER_TYPE_BASE: |
555 | asprintfN(&filter_string, "base filter"); |
556 | break; |
557 | default: |
558 | asprintfN(&filter_string, "unknown filter type %d", |
559 | - info_ptr->filter_type); |
560 | + png_get_filter_type(png_ptr, info_ptr)); |
561 | } |
562 | |
563 | - pm_message("reading a %ldw x %ldh image, %d bit%s", |
564 | - info_ptr->width, info_ptr->height, |
565 | - info_ptr->bit_depth, info_ptr->bit_depth > 1 ? "s" : ""); |
566 | + pm_message("reading a %uw x %uh image, %d bit%s", |
567 | + png_get_image_width(png_ptr, info_ptr), |
568 | + png_get_image_height(png_ptr, info_ptr), |
569 | + png_get_bit_depth(png_ptr, info_ptr), |
570 | + png_get_bit_depth(png_ptr, info_ptr) > 1 ? "s" : ""); |
571 | pm_message("%s, %s, %s", |
572 | type_string, |
573 | - info_ptr->interlace_type ? |
574 | + png_get_interlace_type(png_ptr, info_ptr) ? |
575 | "Adam7 interlaced" : "not interlaced", |
576 | filter_string); |
577 | - pm_message("background {index, gray, red, green, blue} = " |
578 | - "{%d, %d, %d, %d, %d}", |
579 | - info_ptr->background.index, |
580 | - info_ptr->background.gray, |
581 | - info_ptr->background.red, |
582 | - info_ptr->background.green, |
583 | - info_ptr->background.blue); |
584 | + |
585 | + if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) { |
586 | + pm_message("background {index, gray, red, green, blue} = " |
587 | + "{%d, %d, %d, %d, %d}", |
588 | + background->index, |
589 | + background->gray, |
590 | + background->red, |
591 | + background->green, |
592 | + background->blue); |
593 | + } |
594 | |
595 | strfree(filter_string); |
596 | |
597 | - if (info_ptr->valid & PNG_INFO_tRNS) |
598 | + if (png_get_tRNS(png_ptr, info_ptr, |
599 | + NULL, &num_trans, NULL) & PNG_INFO_tRNS) |
600 | pm_message("tRNS chunk (transparency): %u entries", |
601 | - info_ptr->num_trans); |
602 | + num_trans); |
603 | else |
604 | pm_message("tRNS chunk (transparency): not present"); |
605 | |
606 | - if (info_ptr->valid & PNG_INFO_gAMA) |
607 | - pm_message("gAMA chunk (image gamma): gamma = %4.2f", info_ptr->gamma); |
608 | + if (png_get_gAMA(png_ptr, info_ptr, &gamma) & PNG_INFO_gAMA) |
609 | + pm_message("gAMA chunk (image gamma): gamma = %4.2f", gamma); |
610 | else |
611 | pm_message("gAMA chunk (image gamma): not present"); |
612 | |
613 | - if (info_ptr->valid & PNG_INFO_sBIT) |
614 | + if (png_get_sBIT(png_ptr, info_ptr, &sig_bit) & PNG_INFO_sBIT) |
615 | pm_message("sBIT chunk: present"); |
616 | else |
617 | pm_message("sBIT chunk: not present"); |
618 | |
619 | - if (info_ptr->valid & PNG_INFO_cHRM) |
620 | + if (png_get_cHRM(png_ptr, info_ptr, |
621 | + NULL, NULL, NULL, NULL, |
622 | + NULL, NULL, NULL, NULL) & PNG_INFO_cHRM) |
623 | pm_message("cHRM chunk: present"); |
624 | else |
625 | pm_message("cHRM chunk: not present"); |
626 | |
627 | - if (info_ptr->valid & PNG_INFO_PLTE) |
628 | - pm_message("PLTE chunk: %d entries", info_ptr->num_palette); |
629 | + if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) & PNG_INFO_PLTE) |
630 | + pm_message("PLTE chunk: %d entries", num_palette); |
631 | else |
632 | pm_message("PLTE chunk: not present"); |
633 | |
634 | - if (info_ptr->valid & PNG_INFO_bKGD) |
635 | + if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) |
636 | pm_message("bKGD chunk: present"); |
637 | else |
638 | pm_message("bKGD chunk: not present"); |
639 | |
640 | - if (info_ptr->valid & PNG_INFO_hIST) |
641 | + if (png_get_hIST(png_ptr, info_ptr, &hist) & PNG_INFO_hIST) |
642 | pm_message("hIST chunk: present"); |
643 | else |
644 | pm_message("hIST chunk: not present"); |
645 | |
646 | - if (info_ptr->valid & PNG_INFO_pHYs) |
647 | + if (png_get_pHYs(png_ptr, info_ptr, |
648 | + &res_x, &res_y, &unit_type) & PNG_INFO_pHYs) |
649 | pm_message("pHYs chunk: present"); |
650 | else |
651 | pm_message("pHYs chunk: not present"); |
652 | |
653 | - if (info_ptr->valid & PNG_INFO_oFFs) |
654 | + if (png_get_oFFs(png_ptr, info_ptr, |
655 | + &offset_x, &offset_y, &unit_type) & PNG_INFO_oFFs) |
656 | pm_message("oFFs chunk: present"); |
657 | else |
658 | pm_message("oFFs chunk: not present"); |
659 | |
660 | - if (info_ptr->valid & PNG_INFO_tIME) |
661 | + if (png_get_tIME(png_ptr, info_ptr, &mod_time) & PNG_INFO_tIME) |
662 | pm_message("tIME chunk: present"); |
663 | else |
664 | pm_message("tIME chunk: not present"); |
665 | |
666 | - if (info_ptr->valid & PNG_INFO_pCAL) |
667 | + if (png_get_pCAL(png_ptr, info_ptr, &purpose, &X0, &X1, |
668 | + &type, &nparams, &units, ¶ms) & PNG_INFO_pCAL) |
669 | pm_message("pCAL chunk: present"); |
670 | else |
671 | pm_message("pCAL chunk: not present"); |
672 | |
673 | - if (info_ptr->valid & PNG_INFO_sRGB) |
674 | + if (png_get_sRGB(png_ptr, info_ptr, &file_srgb_intent) & PNG_INFO_sRGB) |
675 | pm_message("sRGB chunk: present"); |
676 | else |
677 | pm_message("sRGB chunk: not present"); |
678 | @@ -472,19 +501,19 @@ |
679 | |
680 | |
681 | static bool |
682 | -isTransparentColor(pngcolor const color, |
683 | - png_info * const info_ptr, |
684 | - double const totalgamma) { |
685 | +isTransparentColor(pngcolor const color, |
686 | + png_structp const png_ptr, |
687 | + png_info * const info_ptr, |
688 | + double const totalgamma) { |
689 | /*---------------------------------------------------------------------------- |
690 | Return TRUE iff pixels of color 'color' are supposed to be transparent |
691 | everywhere they occur. Assume it's an RGB image. |
692 | -----------------------------------------------------------------------------*/ |
693 | bool retval; |
694 | + png_color_16p transColorP; |
695 | |
696 | - if (info_ptr->valid & PNG_INFO_tRNS) { |
697 | - const png_color_16 * const transColorP = &info_ptr->trans_values; |
698 | - |
699 | - |
700 | + if (png_get_tRNS(png_ptr, info_ptr, |
701 | + NULL, NULL, &transColorP) & PNG_INFO_tRNS) { |
702 | /* There seems to be a problem here: you can't compare real |
703 | numbers for equality. Also, I'm not sure the gamma |
704 | corrected/uncorrected color spaces are right here. |
705 | @@ -530,9 +559,11 @@ |
706 | if (displaygamma == -1.0) |
707 | *totalgammaP = -1.0; |
708 | else { |
709 | + double fileGamma; |
710 | float imageGamma; |
711 | - if (info_ptr->valid & PNG_INFO_gAMA) |
712 | - imageGamma = info_ptr->gamma; |
713 | + |
714 | + if (png_get_gAMA(png_ptr, info_ptr, &fileGamma) & PNG_INFO_gAMA) |
715 | + imageGamma = fileGamma; |
716 | else { |
717 | if (verbose) |
718 | pm_message("PNG doesn't specify image gamma. Assuming 1.0"); |
719 | @@ -548,10 +579,14 @@ |
720 | } else { |
721 | png_set_gamma(png_ptr, displaygamma, imageGamma); |
722 | *totalgammaP = imageGamma * displaygamma; |
723 | +#ifdef NOT_SUPPORTED_ANYMORE |
724 | + /* The API doesn't clearing PNG_INFO_sBIT. */ |
725 | + |
726 | /* in case of gamma-corrections, sBIT's as in the |
727 | PNG-file are not valid anymore |
728 | */ |
729 | info_ptr->valid &= ~PNG_INFO_sBIT; |
730 | +#endif |
731 | if (verbose) |
732 | pm_message("image gamma is %4.2f, " |
733 | "converted for display gamma of %4.2f", |
734 | @@ -563,20 +598,24 @@ |
735 | |
736 | |
737 | static bool |
738 | -paletteHasPartialTransparency(png_info * const info_ptr) { |
739 | +paletteHasPartialTransparency(png_structp png_ptr, png_info * const info_ptr) { |
740 | |
741 | bool retval; |
742 | |
743 | - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { |
744 | - if (info_ptr->valid & PNG_INFO_tRNS) { |
745 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { |
746 | + png_bytep trans_alpha; |
747 | + int num_trans; |
748 | + |
749 | + if (png_get_tRNS(png_ptr, info_ptr, |
750 | + &trans_alpha, &num_trans, NULL) & PNG_INFO_tRNS) { |
751 | bool foundGray; |
752 | unsigned int i; |
753 | |
754 | for (i = 0, foundGray = FALSE; |
755 | - i < info_ptr->num_trans && !foundGray; |
756 | + i < num_trans && !foundGray; |
757 | ++i) { |
758 | - if (info_ptr->trans[i] != 0 && |
759 | - info_ptr->trans[i] != maxval) { |
760 | + if (trans_alpha[i] != 0 && |
761 | + trans_alpha[i] != maxval) { |
762 | foundGray = TRUE; |
763 | } |
764 | } |
765 | @@ -604,14 +643,16 @@ |
766 | |
767 | Return the result as *maxvalP. |
768 | -----------------------------------------------------------------------------*/ |
769 | + png_color_8p sig_bit; |
770 | + |
771 | /* Initial assumption of maxval */ |
772 | - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { |
773 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { |
774 | if (alpha == ALPHA_ONLY) { |
775 | - if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY || |
776 | - info_ptr->color_type == PNG_COLOR_TYPE_RGB) |
777 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY || |
778 | + png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB) |
779 | /* The alpha mask will be all opaque, so maxval 1 is plenty */ |
780 | *maxvalP = 1; |
781 | - else if (paletteHasPartialTransparency(info_ptr)) |
782 | + else if (paletteHasPartialTransparency(png_ptr, info_ptr)) |
783 | /* Use same maxval as PNG transparency palette for simplicity*/ |
784 | *maxvalP = 255; |
785 | else |
786 | @@ -621,7 +662,7 @@ |
787 | /* Use same maxval as PNG palette for simplicity */ |
788 | *maxvalP = 255; |
789 | } else { |
790 | - *maxvalP = (1l << info_ptr->bit_depth) - 1; |
791 | + *maxvalP = (1l << png_get_bit_depth(png_ptr, info_ptr)) - 1; |
792 | } |
793 | |
794 | /* sBIT handling is very tricky. If we are extracting only the |
795 | @@ -634,20 +675,26 @@ |
796 | is used |
797 | */ |
798 | |
799 | - if (info_ptr->valid & PNG_INFO_sBIT) { |
800 | + if (png_get_sBIT(png_ptr, info_ptr, &sig_bit) & PNG_INFO_sBIT) { |
801 | + png_byte color_type; |
802 | + png_bytep trans_alpha; |
803 | + int num_trans; |
804 | + |
805 | + color_type = png_get_color_type(png_ptr, info_ptr); |
806 | switch (alpha) { |
807 | case ALPHA_MIX: |
808 | - if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
809 | - info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
810 | + if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
811 | + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
812 | break; |
813 | - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
814 | - (info_ptr->valid & PNG_INFO_tRNS)) { |
815 | + if (color_type == PNG_COLOR_TYPE_PALETTE && |
816 | + png_get_tRNS(png_ptr, info_ptr, |
817 | + &trans_alpha, &num_trans, NULL) & PNG_INFO_tRNS) { |
818 | |
819 | bool trans_mix; |
820 | unsigned int i; |
821 | trans_mix = TRUE; |
822 | - for (i = 0; i < info_ptr->num_trans; ++i) |
823 | - if (info_ptr->trans[i] != 0 && info_ptr->trans[i] != 255) { |
824 | + for (i = 0; i < num_trans; ++i) |
825 | + if (trans_alpha[i] != 0 && trans_alpha[i] != 255) { |
826 | trans_mix = FALSE; |
827 | break; |
828 | } |
829 | @@ -658,70 +705,76 @@ |
830 | /* else fall though to normal case */ |
831 | |
832 | case ALPHA_NONE: |
833 | - if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE || |
834 | - info_ptr->color_type == PNG_COLOR_TYPE_RGB || |
835 | - info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) && |
836 | - (info_ptr->sig_bit.red != info_ptr->sig_bit.green || |
837 | - info_ptr->sig_bit.red != info_ptr->sig_bit.blue) && |
838 | + if ((color_type == PNG_COLOR_TYPE_PALETTE || |
839 | + color_type == PNG_COLOR_TYPE_RGB || |
840 | + color_type == PNG_COLOR_TYPE_RGB_ALPHA) && |
841 | + (sig_bit->red != sig_bit->green || |
842 | + sig_bit->red != sig_bit->blue) && |
843 | alpha == ALPHA_NONE) { |
844 | pm_message("This program cannot handle " |
845 | "different bit depths for color channels"); |
846 | pm_message("writing file with %d bit resolution", |
847 | - info_ptr->bit_depth); |
848 | + png_get_bit_depth(png_ptr, info_ptr)); |
849 | *errorlevelP = PNMTOPNG_WARNING_LEVEL; |
850 | } else { |
851 | - if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) && |
852 | - (info_ptr->sig_bit.red < 255)) { |
853 | + png_colorp palette; |
854 | + int num_palette; |
855 | + |
856 | + if ((color_type == PNG_COLOR_TYPE_PALETTE) && |
857 | + (sig_bit->red < 255) && |
858 | + png_get_PLTE(png_ptr, info_ptr, |
859 | + &palette, &num_palette) & PNG_INFO_PLTE) { |
860 | unsigned int i; |
861 | - for (i = 0; i < info_ptr->num_palette; ++i) { |
862 | - info_ptr->palette[i].red >>= |
863 | - (8 - info_ptr->sig_bit.red); |
864 | - info_ptr->palette[i].green >>= |
865 | - (8 - info_ptr->sig_bit.green); |
866 | - info_ptr->palette[i].blue >>= |
867 | - (8 - info_ptr->sig_bit.blue); |
868 | + |
869 | + for (i = 0; i < num_palette; ++i) { |
870 | + palette[i].red >>= |
871 | + (8 - sig_bit->red); |
872 | + palette[i].green >>= |
873 | + (8 - sig_bit->green); |
874 | + palette[i].blue >>= |
875 | + (8 - sig_bit->blue); |
876 | } |
877 | - *maxvalP = (1l << info_ptr->sig_bit.red) - 1; |
878 | + *maxvalP = (1l << sig_bit->red) - 1; |
879 | if (verbose) |
880 | pm_message ("image has fewer significant bits, " |
881 | "writing file with %d bits per channel", |
882 | - info_ptr->sig_bit.red); |
883 | + sig_bit->red); |
884 | } else |
885 | - if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB || |
886 | - info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) && |
887 | - (info_ptr->sig_bit.red < info_ptr->bit_depth)) { |
888 | - png_set_shift (png_ptr, &(info_ptr->sig_bit)); |
889 | - *maxvalP = (1l << info_ptr->sig_bit.red) - 1; |
890 | + if ((color_type == PNG_COLOR_TYPE_RGB || |
891 | + color_type == PNG_COLOR_TYPE_RGB_ALPHA) && |
892 | + (sig_bit->red < png_get_bit_depth(png_ptr, info_ptr))) { |
893 | + png_set_shift (png_ptr, sig_bit); |
894 | + *maxvalP = (1l << sig_bit->red) - 1; |
895 | if (verbose) |
896 | pm_message("image has fewer significant bits, " |
897 | "writing file with %d " |
898 | "bits per channel", |
899 | - info_ptr->sig_bit.red); |
900 | + sig_bit->red); |
901 | } else |
902 | - if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY || |
903 | - info_ptr->color_type == |
904 | + if ((color_type == PNG_COLOR_TYPE_GRAY || |
905 | + color_type == |
906 | PNG_COLOR_TYPE_GRAY_ALPHA) && |
907 | - (info_ptr->sig_bit.gray < info_ptr->bit_depth)) { |
908 | - png_set_shift (png_ptr, &(info_ptr->sig_bit)); |
909 | - *maxvalP = (1l << info_ptr->sig_bit.gray) - 1; |
910 | + (sig_bit->gray < png_get_bit_depth(png_ptr, info_ptr))) { |
911 | + png_set_shift (png_ptr, sig_bit); |
912 | + *maxvalP = (1l << sig_bit->gray) - 1; |
913 | if (verbose) |
914 | pm_message("image has fewer significant bits, " |
915 | "writing file with %d bits", |
916 | - info_ptr->sig_bit.gray); |
917 | + sig_bit->gray); |
918 | } |
919 | } |
920 | break; |
921 | |
922 | case ALPHA_ONLY: |
923 | - if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
924 | - info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) && |
925 | - (info_ptr->sig_bit.gray < info_ptr->bit_depth)) { |
926 | - png_set_shift (png_ptr, &(info_ptr->sig_bit)); |
927 | + if ((color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
928 | + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) && |
929 | + (sig_bit->gray < png_get_bit_depth(png_ptr, info_ptr))) { |
930 | + png_set_shift (png_ptr, sig_bit); |
931 | if (verbose) |
932 | pm_message ("image has fewer significant bits, " |
933 | "writing file with %d bits", |
934 | - info_ptr->sig_bit.alpha); |
935 | - *maxvalP = (1l << info_ptr->sig_bit.alpha) - 1; |
936 | + sig_bit->alpha); |
937 | + *maxvalP = (1l << sig_bit->alpha) - 1; |
938 | } |
939 | break; |
940 | |
941 | @@ -732,22 +785,28 @@ |
942 | |
943 | |
944 | static bool |
945 | -imageHasColor(png_info * const info_ptr) { |
946 | +imageHasColor(png_structp const png_ptr, png_info * const info_ptr) { |
947 | |
948 | bool retval; |
949 | - |
950 | - if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY || |
951 | - info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
952 | + png_byte color_type; |
953 | + png_colorp palette; |
954 | + int num_palette; |
955 | + |
956 | + color_type = png_get_color_type(png_ptr, info_ptr); |
957 | + if (color_type == PNG_COLOR_TYPE_GRAY || |
958 | + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
959 | |
960 | retval = FALSE; |
961 | - else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { |
962 | + else if (color_type == PNG_COLOR_TYPE_PALETTE && |
963 | + png_get_PLTE(png_ptr, info_ptr, |
964 | + &palette, &num_palette) & PNG_INFO_PLTE) { |
965 | bool foundColor; |
966 | unsigned int i; |
967 | |
968 | for (i = 0, foundColor = FALSE; |
969 | - i < info_ptr->num_palette && !foundColor; |
970 | + i < num_palette && !foundColor; |
971 | ++i) { |
972 | - if (iscolor(info_ptr->palette[i])) |
973 | + if (iscolor(palette[i])) |
974 | foundColor = TRUE; |
975 | } |
976 | retval = foundColor; |
977 | @@ -760,14 +819,15 @@ |
978 | |
979 | |
980 | static void |
981 | -determineOutputType(png_info * const info_ptr, |
982 | +determineOutputType(png_structp const png_ptr, |
983 | + png_info * const info_ptr, |
984 | enum alpha_handling const alphaHandling, |
985 | pngcolor const bgColor, |
986 | xelval const maxval, |
987 | int * const pnmTypeP) { |
988 | |
989 | if (alphaHandling != ALPHA_ONLY && |
990 | - (imageHasColor(info_ptr) || !isGrayscale(bgColor))) |
991 | + (imageHasColor(png_ptr, info_ptr) || !isGrayscale(bgColor))) |
992 | *pnmTypeP = PPM_TYPE; |
993 | else { |
994 | if (maxval > 1) |
995 | @@ -780,7 +840,8 @@ |
996 | |
997 | |
998 | static void |
999 | -getBackgroundColor(png_info * const info_ptr, |
1000 | +getBackgroundColor(png_structp const png_ptr, |
1001 | + png_info * const info_ptr, |
1002 | const char * const requestedColor, |
1003 | float const totalgamma, |
1004 | xelval const maxval, |
1005 | @@ -791,6 +852,8 @@ |
1006 | Otherwise, if the PNG specifies a background color, that's the one. |
1007 | And otherwise, it's white. |
1008 | -----------------------------------------------------------------------------*/ |
1009 | + png_color_16p background; |
1010 | + |
1011 | if (requestedColor) { |
1012 | /* Background was specified from the command-line; we always |
1013 | use that. I chose to do no gamma-correction in this case; |
1014 | @@ -802,27 +865,32 @@ |
1015 | bgColorP->g = PPM_GETG(backcolor); |
1016 | bgColorP->b = PPM_GETB(backcolor); |
1017 | |
1018 | - } else if (info_ptr->valid & PNG_INFO_bKGD) { |
1019 | + } else if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) { |
1020 | /* didn't manage to get libpng to work (bugs?) concerning background |
1021 | processing, therefore we do our own. |
1022 | */ |
1023 | - switch (info_ptr->color_type) { |
1024 | + switch (png_get_color_type(png_ptr, info_ptr)) { |
1025 | case PNG_COLOR_TYPE_GRAY: |
1026 | case PNG_COLOR_TYPE_GRAY_ALPHA: |
1027 | bgColorP->r = bgColorP->g = bgColorP->b = |
1028 | - gamma_correct(info_ptr->background.gray, totalgamma); |
1029 | + gamma_correct(background->gray, totalgamma); |
1030 | break; |
1031 | case PNG_COLOR_TYPE_PALETTE: { |
1032 | - png_color const rawBgcolor = |
1033 | - info_ptr->palette[info_ptr->background.index]; |
1034 | - bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma); |
1035 | - bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma); |
1036 | - bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma); |
1037 | + png_colorp palette; |
1038 | + int num_palette; |
1039 | + |
1040 | + if (png_get_PLTE(png_ptr, info_ptr, |
1041 | + &palette, &num_palette) & PNG_INFO_PLTE) { |
1042 | + png_color const rawBgcolor = palette[background->index]; |
1043 | + bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma); |
1044 | + bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma); |
1045 | + bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma); |
1046 | + } |
1047 | } |
1048 | break; |
1049 | case PNG_COLOR_TYPE_RGB: |
1050 | case PNG_COLOR_TYPE_RGB_ALPHA: { |
1051 | - png_color_16 const rawBgcolor = info_ptr->background; |
1052 | + png_color_16 const rawBgcolor = *background; |
1053 | |
1054 | bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma); |
1055 | bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma); |
1056 | @@ -841,6 +909,7 @@ |
1057 | writePnm(FILE * const ofP, |
1058 | xelval const maxval, |
1059 | int const pnm_type, |
1060 | + png_structp const png_ptr, |
1061 | png_info * const info_ptr, |
1062 | png_byte ** const png_image, |
1063 | pngcolor const bgColor, |
1064 | @@ -858,6 +927,7 @@ |
1065 | -----------------------------------------------------------------------------*/ |
1066 | xel * xelrow; |
1067 | unsigned int row; |
1068 | + png_uint_32 width, height; |
1069 | |
1070 | if (verbose) |
1071 | pm_message ("writing a %s file (maxval=%u)", |
1072 | @@ -867,27 +937,35 @@ |
1073 | "UNKNOWN!", |
1074 | maxval); |
1075 | |
1076 | - xelrow = pnm_allocrow(info_ptr->width); |
1077 | + xelrow = pnm_allocrow(png_get_image_width(png_ptr, info_ptr)); |
1078 | |
1079 | - pnm_writepnminit(stdout, info_ptr->width, info_ptr->height, maxval, |
1080 | - pnm_type, FALSE); |
1081 | + width = png_get_image_width(png_ptr, info_ptr); |
1082 | + height = png_get_image_height(png_ptr, info_ptr); |
1083 | |
1084 | - for (row = 0; row < info_ptr->height; ++row) { |
1085 | + pnm_writepnminit(stdout, width, height, maxval, pnm_type, FALSE); |
1086 | + |
1087 | + for (row = 0; row < height; ++row) { |
1088 | png_byte * png_pixelP; |
1089 | int col; |
1090 | |
1091 | png_pixelP = &png_image[row][0]; /* initial value */ |
1092 | - for (col = 0; col < info_ptr->width; ++col) { |
1093 | - switch (info_ptr->color_type) { |
1094 | + for (col = 0; col < width; ++col) { |
1095 | + switch (png_get_color_type(png_ptr, info_ptr)) { |
1096 | case PNG_COLOR_TYPE_GRAY: { |
1097 | pngcolor fgColor; |
1098 | + png_color_16p trans_color; |
1099 | + |
1100 | fgColor.r = fgColor.g = fgColor.b = get_png_val(png_pixelP); |
1101 | - setXel(&xelrow[col], fgColor, bgColor, alpha_handling, |
1102 | - ((info_ptr->valid & PNG_INFO_tRNS) && |
1103 | - (fgColor.r == |
1104 | - gamma_correct(info_ptr->trans_values.gray, |
1105 | - totalgamma))) ? |
1106 | - 0 : maxval); |
1107 | + |
1108 | + if (png_get_tRNS(png_ptr, info_ptr, |
1109 | + NULL, NULL, &trans_color) & PNG_INFO_tRNS && |
1110 | + (fgColor.r == gamma_correct(trans_color->gray, |
1111 | + totalgamma))) { |
1112 | + setXel(&xelrow[col], fgColor, bgColor, alpha_handling, 0); |
1113 | + } else { |
1114 | + setXel(&xelrow[col], fgColor, bgColor, alpha_handling, |
1115 | + maxval); |
1116 | + } |
1117 | } |
1118 | break; |
1119 | |
1120 | @@ -902,19 +980,31 @@ |
1121 | break; |
1122 | |
1123 | case PNG_COLOR_TYPE_PALETTE: { |
1124 | - png_uint_16 const index = get_png_val(png_pixelP); |
1125 | - png_color const paletteColor = info_ptr->palette[index]; |
1126 | - |
1127 | - pngcolor fgColor; |
1128 | - |
1129 | - fgColor.r = paletteColor.red; |
1130 | - fgColor.g = paletteColor.green; |
1131 | - fgColor.b = paletteColor.blue; |
1132 | - |
1133 | - setXel(&xelrow[col], fgColor, bgColor, alpha_handling, |
1134 | - (info_ptr->valid & PNG_INFO_tRNS) && |
1135 | - index < info_ptr->num_trans ? |
1136 | - info_ptr->trans[index] : maxval); |
1137 | + png_uint_16 const index = get_png_val(png_pixelP); |
1138 | + png_colorp palette; |
1139 | + int num_palette; |
1140 | + |
1141 | + if (png_get_PLTE(png_ptr, info_ptr, |
1142 | + &palette, &num_palette) & PNG_INFO_PLTE) { |
1143 | + png_color const paletteColor = palette[index]; |
1144 | + pngcolor fgColor; |
1145 | + png_bytep trans_alpha; |
1146 | + int num_trans; |
1147 | + |
1148 | + fgColor.r = paletteColor.red; |
1149 | + fgColor.g = paletteColor.green; |
1150 | + fgColor.b = paletteColor.blue; |
1151 | + |
1152 | + if (png_get_tRNS(png_ptr, info_ptr, |
1153 | + &trans_alpha, |
1154 | + &num_trans, NULL) & PNG_INFO_tRNS) { |
1155 | + setXel(&xelrow[col], fgColor, bgColor, alpha_handling, |
1156 | + index < num_trans ? trans_alpha[index] : maxval); |
1157 | + } else { |
1158 | + setXel(&xelrow[col], fgColor, bgColor, alpha_handling, |
1159 | + maxval); |
1160 | + } |
1161 | + } |
1162 | } |
1163 | break; |
1164 | |
1165 | @@ -925,8 +1015,8 @@ |
1166 | fgColor.g = get_png_val(png_pixelP); |
1167 | fgColor.b = get_png_val(png_pixelP); |
1168 | setXel(&xelrow[col], fgColor, bgColor, alpha_handling, |
1169 | - isTransparentColor(fgColor, info_ptr, totalgamma) ? |
1170 | - 0 : maxval); |
1171 | + isTransparentColor(fgColor, png_ptr, info_ptr, |
1172 | + totalgamma) ? 0 : maxval); |
1173 | } |
1174 | break; |
1175 | |
1176 | @@ -943,10 +1033,10 @@ |
1177 | break; |
1178 | |
1179 | default: |
1180 | - pm_error ("unknown PNG color type: %d", info_ptr->color_type); |
1181 | + pm_error ("unknown PNG color type: %d", png_get_color_type(png_ptr, info_ptr)); |
1182 | } |
1183 | } |
1184 | - pnm_writepnmrow(ofP, xelrow, info_ptr->width, maxval, pnm_type, FALSE); |
1185 | + pnm_writepnmrow(ofP, xelrow, width, maxval, pnm_type, FALSE); |
1186 | } |
1187 | pnm_freerow (xelrow); |
1188 | } |
1189 | @@ -967,6 +1057,7 @@ |
1190 | int pnm_type; |
1191 | pngcolor bgColor; |
1192 | float totalgamma; |
1193 | + int res_x, res_y, unit_type; |
1194 | |
1195 | *errorlevelP = 0; |
1196 | |
1197 | @@ -989,28 +1080,28 @@ |
1198 | png_set_sig_bytes (png_ptr, SIG_CHECK_SIZE); |
1199 | png_read_info (png_ptr, info_ptr); |
1200 | |
1201 | - MALLOCARRAY(png_image, info_ptr->height); |
1202 | + MALLOCARRAY(png_image, png_get_image_height(png_ptr, info_ptr)); |
1203 | if (png_image == NULL) { |
1204 | png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL); |
1205 | pm_closer (ifp); |
1206 | pm_error ("couldn't allocate space for image"); |
1207 | } |
1208 | |
1209 | - if (info_ptr->bit_depth == 16) |
1210 | - linesize = 2 * info_ptr->width; |
1211 | + if (png_get_bit_depth(png_ptr, info_ptr) == 16) |
1212 | + linesize = 2 * png_get_image_width(png_ptr, info_ptr); |
1213 | else |
1214 | - linesize = info_ptr->width; |
1215 | + linesize = png_get_image_width(png_ptr, info_ptr); |
1216 | |
1217 | - if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
1218 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY_ALPHA) |
1219 | linesize *= 2; |
1220 | else |
1221 | - if (info_ptr->color_type == PNG_COLOR_TYPE_RGB) |
1222 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB) |
1223 | linesize *= 3; |
1224 | else |
1225 | - if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
1226 | + if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB_ALPHA) |
1227 | linesize *= 4; |
1228 | |
1229 | - for (y = 0 ; y < info_ptr->height ; y++) { |
1230 | + for (y = 0 ; y < png_get_image_height(png_ptr, info_ptr) ; y++) { |
1231 | png_image[y] = malloc (linesize); |
1232 | if (png_image[y] == NULL) { |
1233 | for (x = 0 ; x < y ; x++) |
1234 | @@ -1022,7 +1113,7 @@ |
1235 | } |
1236 | } |
1237 | |
1238 | - if (info_ptr->bit_depth < 8) |
1239 | + if (png_get_bit_depth(png_ptr, info_ptr) < 8) |
1240 | png_set_packing (png_ptr); |
1241 | |
1242 | setupGammaCorrection(png_ptr, info_ptr, cmdline.gamma, &totalgamma); |
1243 | @@ -1030,8 +1121,8 @@ |
1244 | setupSignificantBits(png_ptr, info_ptr, cmdline.alpha, |
1245 | &maxval, errorlevelP); |
1246 | |
1247 | - getBackgroundColor(info_ptr, cmdline.background, totalgamma, maxval, |
1248 | - &bgColor); |
1249 | + getBackgroundColor(png_ptr, info_ptr, cmdline.background, totalgamma, |
1250 | + maxval, &bgColor); |
1251 | |
1252 | png_read_image (png_ptr, png_image); |
1253 | png_read_end (png_ptr, info_ptr); |
1254 | @@ -1041,16 +1132,17 @@ |
1255 | completes. That's because it comes from chunks that are at the |
1256 | end of the stream. |
1257 | */ |
1258 | - dump_png_info(info_ptr); |
1259 | + dump_png_info(png_ptr, info_ptr); |
1260 | |
1261 | if (mtime) |
1262 | - show_time (info_ptr); |
1263 | + show_time (png_ptr, info_ptr); |
1264 | if (tfp) |
1265 | - save_text (info_ptr, tfp); |
1266 | + save_text (png_ptr, info_ptr, tfp); |
1267 | |
1268 | - if (info_ptr->valid & PNG_INFO_pHYs) { |
1269 | + if (png_get_pHYs(png_ptr, info_ptr, |
1270 | + &res_x, &res_y, &unit_type) & PNG_INFO_pHYs) { |
1271 | float r; |
1272 | - r = (float)info_ptr->x_pixels_per_unit / info_ptr->y_pixels_per_unit; |
1273 | + r = (float)res_x / res_y; |
1274 | if (r != 1.0) { |
1275 | pm_message ("warning - non-square pixels; " |
1276 | "to fix do a 'pamscale -%cscale %g'", |
1277 | @@ -1060,13 +1152,13 @@ |
1278 | } |
1279 | } |
1280 | |
1281 | - determineOutputType(info_ptr, cmdline.alpha, bgColor, maxval, &pnm_type); |
1282 | + determineOutputType(png_ptr, info_ptr, cmdline.alpha, bgColor, maxval, &pnm_type); |
1283 | |
1284 | - writePnm(stdout, maxval, pnm_type, info_ptr, png_image, bgColor, |
1285 | + writePnm(stdout, maxval, pnm_type, png_ptr, info_ptr, png_image, bgColor, |
1286 | cmdline.alpha, totalgamma); |
1287 | |
1288 | fflush(stdout); |
1289 | - for (y = 0 ; y < info_ptr->height ; y++) |
1290 | + for (y = 0 ; y < png_get_image_height(png_ptr, info_ptr) ; y++) |
1291 | free (png_image[y]); |
1292 | free (png_image); |
1293 | png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL); |
1294 | $NetBSD: patch-aj,v 1.13 2011/01/14 21:51:59 tron Exp $ |
1295 | |
1296 | Fix build with png-1.5. |
1297 | |
1298 | --- converter/other/pngtxt.h.orig 2006-08-19 04:12:28.000000000 +0100 |
1299 | +++ converter/other/pngtxt.h 2011-01-14 21:39:26.000000000 +0000 |
1300 | @@ -5,7 +5,8 @@ |
1301 | #include <png.h> |
1302 | |
1303 | void |
1304 | -pnmpng_read_text (png_info * const info_ptr, |
1305 | +pnmpng_read_text (png_struct * png_ptr, |
1306 | + png_info * const info_ptr, |
1307 | FILE * const tfp, |
1308 | bool const ztxt, |
1309 | bool const verbose); |
1310 | $NetBSD: patch-ak,v 1.9 2011/01/14 21:51:59 tron Exp $ |
1311 | |
1312 | Fix build with png-1.5. |
1313 | |
1314 | --- converter/other/pngtxt.c.orig 2006-08-19 04:12:28.000000000 +0100 |
1315 | +++ converter/other/pngtxt.c 2011-01-14 21:28:09.000000000 +0000 |
1316 | @@ -240,7 +240,8 @@ |
1317 | |
1318 | |
1319 | void |
1320 | -pnmpng_read_text (png_info * const info_ptr, |
1321 | +pnmpng_read_text (png_struct * png_ptr, |
1322 | + png_info * info_ptr, |
1323 | FILE * const tfp, |
1324 | bool const ztxt, |
1325 | bool const verbose) { |
1326 | @@ -250,6 +251,7 @@ |
1327 | unsigned int commentIdx; |
1328 | bool noCommentsYet; |
1329 | bool eof; |
1330 | + png_textp text_ptr; |
1331 | unsigned int allocatedComments; |
1332 | /* Number of entries currently allocated for the info_ptr->text |
1333 | array |
1334 | @@ -257,8 +259,8 @@ |
1335 | |
1336 | allocatedComments = 256; /* initial value */ |
1337 | |
1338 | - MALLOCARRAY(info_ptr->text, allocatedComments); |
1339 | - if (info_ptr->text == NULL) |
1340 | + MALLOCARRAY(text_ptr, allocatedComments); |
1341 | + if (text_ptr == NULL) |
1342 | pm_error("unable to allocate memory for comment array"); |
1343 | |
1344 | commentIdx = 0; |
1345 | @@ -273,7 +275,7 @@ |
1346 | if (lineLength == 0) { |
1347 | /* skip this empty line */ |
1348 | } else { |
1349 | - handleArrayAllocation(&info_ptr->text, &allocatedComments, |
1350 | + handleArrayAllocation(&text_ptr, &allocatedComments, |
1351 | commentIdx); |
1352 | if ((textline[0] != ' ') && (textline[0] != '\t')) { |
1353 | /* Line doesn't start with white space, which |
1354 | @@ -285,7 +287,7 @@ |
1355 | ++commentIdx; |
1356 | noCommentsYet = FALSE; |
1357 | |
1358 | - startComment(&info_ptr->text[commentIdx], |
1359 | + startComment(&text_ptr[commentIdx], |
1360 | textline, lineLength, ztxt); |
1361 | } else { |
1362 | /* Line starts with whitespace, which means it is |
1363 | @@ -295,20 +297,20 @@ |
1364 | pm_error("Invalid comment file format: " |
1365 | "first line is a continuation line! " |
1366 | "(It starts with whitespace)"); |
1367 | - continueComment(&info_ptr->text[commentIdx], |
1368 | + continueComment(&text_ptr[commentIdx], |
1369 | textline, lineLength); |
1370 | } |
1371 | } |
1372 | strfree(textline); |
1373 | } |
1374 | } |
1375 | - if (noCommentsYet) |
1376 | - info_ptr->num_text = 0; |
1377 | - else |
1378 | - info_ptr->num_text = commentIdx + 1; |
1379 | + if (!noCommentsYet) |
1380 | + png_set_text(png_ptr, info_ptr, text_ptr, commentIdx + 1); |
1381 | |
1382 | if (verbose) |
1383 | - pm_message("%d comments placed in text chunk", info_ptr->num_text); |
1384 | + pm_message("%d comments placed in text chunk", commentIdx + 1); |
1385 | + |
1386 | + free(text_ptr); |
1387 | } |
1388 | |
1389 | |
1390 | $NetBSD: patch-al,v 1.5 2011/01/15 18:37:46 tron Exp $ |
1391 | |
1392 | Fix build with png-1.5. |
1393 | |
1394 | --- converter/other/pamrgbatopng.c.orig 2006-08-19 04:12:28.000000000 +0100 |
1395 | +++ converter/other/pamrgbatopng.c 2011-01-15 18:24:36.000000000 +0000 |
1396 | @@ -101,10 +101,8 @@ |
1397 | if (!infoP) |
1398 | pm_error("Could not allocate PNG info structure"); |
1399 | else { |
1400 | - infoP->width = pamP->width; |
1401 | - infoP->height = pamP->height; |
1402 | - infoP->bit_depth = 8; |
1403 | - infoP->color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
1404 | + png_set_IHDR(pngP, infoP, pamP->width, pamP->height, |
1405 | + 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0, 0); |
1406 | |
1407 | png_init_io(pngP, ofP); |
1408 |