]> git.pld-linux.org Git - packages/netpbm.git/blame - netpbm-build.patch
projects / packages / netpbm.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- explicitly list programs to track changes in future versions
[packages/netpbm.git] / netpbm-build.patch
CommitLineData
11530675
JB		 1--- netpbm-10.47.73/converter/other/pnmtopng.c.orig 2019-06-28 23:02:17.000000000 +0200
2+++ netpbm-10.47.73/converter/other/pnmtopng.c 2019-07-27 10:44:23.878530313 +0200
0418bf0c 3@@ -59,7 +59,8 @@
baa327a2
JB		 4 #include <assert.h>
5 #include <string.h> /* strcat() */
6 #include <limits.h>
7-#include <png.h> /* includes zlib.h and setjmp.h */
8+#include <png.h> /* includes setjmp.h */
9+#include <zlib.h>
0418bf0c
JB		 10
11 #include "pm_c_util.h"
baa327a2 12 #include "pnm.h"
e0ff5d9a 13@@ -69,20 +70,6 @@
c3f3506c
JB		 14 #include "nstring.h"
15 #include "version.h"
16
e0ff5d9a
JB		 17-#if PNG_LIBPNG_VER >= 10500
18-#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
19-#error You need either an older PNG library (older than 1.5) or
20-#error newer Netpbm source code (at least 10.55)
21-#endif
22-
0418bf0c 23-/* A hack until we can remove direct access to png_info from the program */
c3f3506c 24-#if PNG_LIBPNG_VER >= 10400
0418bf0c
JB		 25-#define trans_values trans_color
26-#define TRANS_ALPHA trans_alpha
27-#else
28-#define TRANS_ALPHA trans
c3f3506c 29-#endif
0418bf0c 30-
c3f3506c
JB		 31
32 struct zlibCompression {
0418bf0c 33 /* These are parameters that describe a form of zlib compression.
11530675 34@@ -2131,6 +2118,7 @@ makePngLine(png_byte * const l
baa327a2
JB		 35 gray * const alpha_mask,
36 colorhash_table const cht,
37 coloralphahash_table const caht,
0418bf0c 38+ png_struct * const png_ptr,
baa327a2
JB		 39 png_info * const info_ptr,
40 xelval const png_maxval,
41 unsigned int const depth) {
11530675 42@@ -2142,21 +2130,22 @@ makePngLine(png_byte * const l
baa327a2
JB		 43 for (col = 0; col < cols; ++col) {
44 xel p_png;
45 xel const p = xelrow[col];
0418bf0c 46+ png_byte color_type = png_get_color_type(png_ptr, info_ptr);
baa327a2
JB		 47 PPM_DEPTH(p_png, p, maxval, png_maxval);
48- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
49- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
50+ if (color_type == PNG_COLOR_TYPE_GRAY ||
51+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
52 if (depth == 16)
53 *pp++ = PNM_GET1(p_png) >> 8;
54 *pp++ = PNM_GET1(p_png) & 0xff;
55- } else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
56+ } else if (color_type == PNG_COLOR_TYPE_PALETTE) {
57 unsigned int paletteIndex;
58 if (alpha)
59 paletteIndex = lookupColorAlpha(caht, &p, &alpha_mask[col]);
60 else
61 paletteIndex = ppm_lookupcolor(cht, &p);
62 *pp++ = paletteIndex;
63- } else if (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
64- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
65+ } else if (color_type == PNG_COLOR_TYPE_RGB ||
66+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
67 if (depth == 16)
68 *pp++ = PPM_GETR(p_png) >> 8;
69 *pp++ = PPM_GETR(p_png) & 0xff;
11530675 70@@ -2169,7 +2158,7 @@ makePngLine(png_byte * const l
baa327a2
JB		 71 } else
72 pm_error("INTERNAL ERROR: undefined color_type");
73
74- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) {
75+ if (color_type & PNG_COLOR_MASK_ALPHA) {
76 int const png_alphaval = (int)
77 alpha_mask[col] * (float) png_maxval / maxval + 0.5;
78 if (depth == 16)
11530675 79@@ -2226,7 +2215,7 @@ writeRaster(png_struct * const p
baa327a2
JB		 80
81 makePngLine(line, xelrow, cols, maxval,
82 alpha, alpha ? alpha_mask[row] : NULL,
83- cht, caht, info_ptr, png_maxval, depth);
84+ cht, caht, png_ptr, info_ptr, png_maxval, depth);
85
86 png_write_row(png_ptr, line);
87 }
11530675 88@@ -2238,12 +2227,12 @@ writeRaster(png_struct * const p
baa327a2
JB		 89
90 static void
91 doGamaChunk(struct cmdlineInfo const cmdline,
92+ png_struct * const png_ptr,
93 png_info * const info_ptr) {
94
95 if (cmdline.gammaSpec) {
96 /* gAMA chunk */
97- info_ptr->valid |= PNG_INFO_gAMA;
98- info_ptr->gamma = cmdline.gamma;
99+ png_set_gAMA(png_ptr, info_ptr, cmdline.gamma);
100 }
101 }
102
11530675 103@@ -2251,20 +2240,16 @@ doGamaChunk(struct cmdlineInfo const cmd
baa327a2
JB		 104
105 static void
106 doChrmChunk(struct cmdlineInfo const cmdline,
107+ png_struct * const png_ptr,
108 png_info * const info_ptr) {
109
110 if (cmdline.rgbSpec) {
111 /* cHRM chunk */
112- info_ptr->valid |= PNG_INFO_cHRM;
113-
114- info_ptr->x_white = cmdline.rgb.wx;
115- info_ptr->y_white = cmdline.rgb.wy;
116- info_ptr->x_red = cmdline.rgb.rx;
117- info_ptr->y_red = cmdline.rgb.ry;
118- info_ptr->x_green = cmdline.rgb.gx;
119- info_ptr->y_green = cmdline.rgb.gy;
120- info_ptr->x_blue = cmdline.rgb.bx;
121- info_ptr->y_blue = cmdline.rgb.by;
122+ png_set_cHRM(png_ptr, info_ptr,
123+ cmdline.rgb.wx, cmdline.rgb.wy,
124+ cmdline.rgb.rx, cmdline.rgb.ry,
125+ cmdline.rgb.gx, cmdline.rgb.gy,
126+ cmdline.rgb.bx, cmdline.rgb.by);
127 }
128 }
129
11530675 130@@ -2272,15 +2257,13 @@ doChrmChunk(struct cmdlineInfo const cmd
baa327a2
JB		 131
132 static void
133 doPhysChunk(struct cmdlineInfo const cmdline,
134+ png_struct * const png_ptr,
135 png_info * const info_ptr) {
136
137 if (cmdline.sizeSpec) {
138 /* pHYS chunk */
139- info_ptr->valid |= PNG_INFO_pHYs;
140-
141- info_ptr->x_pixels_per_unit = cmdline.size.x;
142- info_ptr->y_pixels_per_unit = cmdline.size.y;
143- info_ptr->phys_unit_type = cmdline.size.unit;
144+ png_set_pHYs(png_ptr, info_ptr,
145+ cmdline.size.x, cmdline.size.y, cmdline.size.unit);
146 }
147 }
148
11530675 149@@ -2289,26 +2272,29 @@ doPhysChunk(struct cmdlineInfo const cmd
baa327a2
JB		 150
151 static void
152 doTimeChunk(struct cmdlineInfo const cmdline,
153+ png_struct * const png_ptr,
154 png_info * const info_ptr) {
155
156 if (cmdline.modtimeSpec) {
157 /* tIME chunk */
158- info_ptr->valid |= PNG_INFO_tIME;
159-
160- png_convert_from_time_t(&info_ptr->mod_time, cmdline.modtime);
161+ png_time ptime;
162+ png_convert_from_time_t(&ptime, cmdline.modtime);
0418bf0c 163+ png_set_tIME(png_ptr, info_ptr, &ptime);
baa327a2
JB		 164 }
165 }
166
167
168
169 static void
170-doSbitChunk(png_info * const pngInfoP,
171+doSbitChunk(png_struct * const png_ptr,
172+ png_info * const pngInfoP,
173 xelval const pngMaxval,
174 xelval const maxval,
175 bool const alpha,
176 xelval const alphaMaxval) {
177
178- if (pngInfoP->color_type != PNG_COLOR_TYPE_PALETTE &&
179+ png_byte color_type = png_get_color_type(png_ptr, pngInfoP);
180+ if (color_type != PNG_COLOR_TYPE_PALETTE &&
181 (pngMaxval > maxval || (alpha && pngMaxval > alphaMaxval))) {
182
183 /* We're writing in a bit depth that doesn't match the maxval
11530675 184@@ -2327,27 +2313,27 @@ doSbitChunk(png_info * const pngInfoP,
baa327a2
JB		 185 sBIT chunk.
186 */
187
188- pngInfoP->valid |= PNG_INFO_sBIT;
189-
190+ png_color_8 sbit;
191 {
192 int const sbitval = pm_maxvaltobits(MIN(maxval, pngMaxval));
193
194- if (pngInfoP->color_type & PNG_COLOR_MASK_COLOR) {
195- pngInfoP->sig_bit.red = sbitval;
196- pngInfoP->sig_bit.green = sbitval;
197- pngInfoP->sig_bit.blue = sbitval;
198+ if (color_type & PNG_COLOR_MASK_COLOR) {
199+ sbit.red = sbitval;
200+ sbit.green = sbitval;
201+ sbit.blue = sbitval;
202 } else
203- pngInfoP->sig_bit.gray = sbitval;
204+ sbit.gray = sbitval;
205
206 if (verbose)
207 pm_message("Writing sBIT chunk with bits = %d", sbitval);
208 }
209- if (pngInfoP->color_type & PNG_COLOR_MASK_ALPHA) {
210- pngInfoP->sig_bit.alpha =
211+ if (color_type & PNG_COLOR_MASK_ALPHA) {
212+ sbit.alpha =
213 pm_maxvaltobits(MIN(alphaMaxval, pngMaxval));
214 if (verbose)
215- pm_message(" alpha bits = %d", pngInfoP->sig_bit.alpha);
216+ pm_message(" alpha bits = %d", sbit.alpha);
217 }
0418bf0c 218+ png_set_sBIT(png_ptr, pngInfoP, &sbit);
baa327a2
JB		 219 }
220 }
221
11530675 222@@ -2628,43 +2614,40 @@ convertpnm(struct cmdlineInfo const cmdl
baa327a2
JB		 223 pm_error ("setjmp returns error condition (2)");
224 }
225
226- png_init_io (png_ptr, stdout);
227- info_ptr->width = cols;
228- info_ptr->height = rows;
229- info_ptr->bit_depth = depth;
230-
231+ {
232+ int color_type;
233 if (colorMapped)
234- info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
235+ color_type = PNG_COLOR_TYPE_PALETTE;
236 else if (pnm_type == PPM_TYPE)
237- info_ptr->color_type = PNG_COLOR_TYPE_RGB;
238+ color_type = PNG_COLOR_TYPE_RGB;
239 else
240- info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
241+ color_type = PNG_COLOR_TYPE_GRAY;
e0ff5d9a 242+
0418bf0c 243+ if (alpha && color_type != PNG_COLOR_TYPE_PALETTE)
baa327a2
JB		 244+ color_type |= PNG_COLOR_MASK_ALPHA;
245
e0ff5d9a
JB		 246- if (alpha && info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
247- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
0418bf0c 248+ png_set_IHDR(png_ptr, info_ptr, cols, rows, depth, color_type, cmdline.interlace, 0, 0);
baa327a2 249+ }
e0ff5d9a
JB		 250
251- info_ptr->interlace_type = cmdline.interlace;
0418bf0c
JB		 252+ if (cmdline.interlace)
253+ png_set_interlace_handling(png_ptr);
baa327a2
JB		 254
255- doGamaChunk(cmdline, info_ptr);
0418bf0c 256+ doGamaChunk(cmdline, png_ptr, info_ptr);
baa327a2
JB		 257
258- doChrmChunk(cmdline, info_ptr);
0418bf0c 259+ doChrmChunk(cmdline, png_ptr, info_ptr);
baa327a2
JB		 260
261- doPhysChunk(cmdline, info_ptr);
0418bf0c 262+ doPhysChunk(cmdline, png_ptr, info_ptr);
baa327a2
JB		 263
264- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
baa327a2
JB		 265+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
266
267 /* creating PNG palette (PLTE and tRNS chunks) */
268
269 createPngPalette(palette_pnm, palette_size, maxval,
270 trans_pnm, trans_size, alpha_maxval,
271 palette, trans);
272- info_ptr->valid |= PNG_INFO_PLTE;
273- info_ptr->palette = palette;
274- info_ptr->num_palette = palette_size;
275+ png_set_PLTE(png_ptr, info_ptr, palette, palette_size);
c27d2a5c 276 if (trans_size > 0) {
baa327a2 277- info_ptr->valid |= PNG_INFO_tRNS;
0418bf0c 278- info_ptr->TRANS_ALPHA = trans;
baa327a2
JB		 279- info_ptr->num_trans = trans_size; /* omit opaque values */
280+ png_set_tRNS(png_ptr, info_ptr, trans, trans_size, NULL);
c27d2a5c
AM		 281 }
282 /* creating hIST chunk */
baa327a2 283 if (cmdline.hist) {
11530675 284@@ -2690,18 +2673,17 @@ convertpnm(struct cmdlineInfo const cmdl
baa327a2
JB		 285
286 ppm_freecolorhash(cht);
287
288- info_ptr->valid |= PNG_INFO_hIST;
289- info_ptr->hist = histogram;
0418bf0c 290+ png_set_hIST(png_ptr, info_ptr, histogram);
baa327a2
JB		 291 if (verbose)
292 pm_message("histogram created");
293 }
294 } else { /* color_type != PNG_COLOR_TYPE_PALETTE */
295- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
296- info_ptr->color_type == PNG_COLOR_TYPE_RGB) {
297+ png_byte color_type = png_get_color_type(png_ptr, info_ptr);
298+ if (color_type == PNG_COLOR_TYPE_GRAY ||
299+ color_type == PNG_COLOR_TYPE_RGB) {
c27d2a5c 300 if (transparent > 0) {
baa327a2 301- info_ptr->valid |= PNG_INFO_tRNS;
c27d2a5c 302- info_ptr->trans_values =
baa327a2
JB		 303- xelToPngColor_16(transcolor, maxval, png_maxval);
304+ png_color_16 c = xelToPngColor_16(transcolor, maxval, png_maxval);
0418bf0c 305+ png_set_tRNS(png_ptr, info_ptr, NULL, 0, &c);
c27d2a5c
AM		 306 }
307 } else {
baa327a2 308 /* This is PNG_COLOR_MASK_ALPHA. Transparency will be handled
11530675 309@@ -2709,13 +2691,17 @@ convertpnm(struct cmdlineInfo const cmdl
baa327a2
JB		 310 */
311 }
312 if (verbose) {
313- if (info_ptr->valid && PNG_INFO_tRNS)
314+ png_color_16p trans_colorp = NULL;
315+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
0418bf0c
JB		 316+ png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_colorp);
317+ }
318+ if(trans_colorp != NULL)
c27d2a5c
AM		 319 pm_message("Transparent color {gray, red, green, blue} = "
320 "{%d, %d, %d, %d}",
321- info_ptr->trans_values.gray,
322- info_ptr->trans_values.red,
323- info_ptr->trans_values.green,
324- info_ptr->trans_values.blue);
baa327a2
JB		 325+ trans_colorp->gray,
326+ trans_colorp->red,
327+ trans_colorp->green,
328+ trans_colorp->blue);
e0ff5d9a 329 else
c27d2a5c
AM		 330 pm_message("No transparent color");
331 }
11530675 332@@ -2723,29 +2709,29 @@ convertpnm(struct cmdlineInfo const cmdl
baa327a2
JB		 333
334 /* bKGD chunk */
335 if (cmdline.background) {
336- info_ptr->valid |= PNG_INFO_bKGD;
337- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
338- info_ptr->background.index = background_index;
339+ png_color_16 bkgd;
340+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
341+ bkgd.index = background_index;
342 } else {
343- info_ptr->background =
344- xelToPngColor_16(backcolor, maxval, png_maxval);
0418bf0c 345+ bkgd = xelToPngColor_16(backcolor, maxval, png_maxval);
baa327a2
JB		 346 if (verbose)
347 pm_message("Writing bKGD chunk with background color "
348 " {gray, red, green, blue} = {%d, %d, %d, %d}",
349- info_ptr->background.gray,
350- info_ptr->background.red,
351- info_ptr->background.green,
352- info_ptr->background.blue );
353+ bkgd.gray,
354+ bkgd.red,
355+ bkgd.green,
356+ bkgd.blue );
357 }
358+ png_set_bKGD(png_ptr, info_ptr, &bkgd);
359 }
360
361- doSbitChunk(info_ptr, png_maxval, maxval, alpha, alpha_maxval);
362+ doSbitChunk(png_ptr, info_ptr, png_maxval, maxval, alpha, alpha_maxval);
363
364 /* tEXT and zTXT chunks */
365 if (cmdline.text || cmdline.ztxt)
366- pnmpng_read_text(info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose);
367+ pnmpng_read_text(png_ptr, info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose);
368
369- doTimeChunk(cmdline, info_ptr);
370+ doTimeChunk(cmdline, png_ptr, info_ptr);
371
11530675 372 if (cmdline.filterSetSpec)
baa327a2 373 png_set_filter(png_ptr, 0, cmdline.filterSet);
11530675 374@@ -2755,17 +2741,11 @@ convertpnm(struct cmdlineInfo const cmdl
baa327a2
JB		 375
376 setZlibCompression(png_ptr, cmdline.zlibCompression);
377
378+ png_init_io (png_ptr, stdout);
379+
380 /* write the png-info struct */
381 png_write_info(png_ptr, info_ptr);
382
383- if (cmdline.text || cmdline.ztxt)
384- /* prevent from being written twice with png_write_end */
385- info_ptr->num_text = 0;
386-
387- if (cmdline.modtime)
388- /* prevent from being written twice with png_write_end */
389- info_ptr->valid &= ~PNG_INFO_tIME;
390-
391 /* let libpng take care of, e.g., bit-depth conversions */
392 png_set_packing (png_ptr);
393
e0ff5d9a
JB		 394--- netpbm-10.47.63/converter/other/pngtopnm.c.orig 2016-09-26 18:44:20.000000000 +0200
395+++ netpbm-10.47.63/converter/other/pngtopnm.c 2016-10-26 20:40:14.913792290 +0200
396@@ -32,19 +32,6 @@
c3f3506c 397 #include "shhopt.h"
0418bf0c 398 #include "pnm.h"
c3f3506c 399
e0ff5d9a
JB		 400-#if PNG_LIBPNG_VER >= 10500
401-#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
402-#error You need either an older PNG library (older than 1.5) or
403-#error newer Netpbm source code (at least 10.55)
404-#endif
405-
0418bf0c 406-/* A hack until we can remove direct access to png_info from the program */
c3f3506c 407-#if PNG_LIBPNG_VER >= 10400
0418bf0c
JB		 408-#define TRANS_ALPHA trans_alpha
409-#else
410-#define TRANS_ALPHA trans
c3f3506c 411-#endif
0418bf0c 412-
c3f3506c 413
0418bf0c 414 enum alpha_handling {ALPHA_NONE, ALPHA_ONLY, ALPHA_MIX};
baa327a2 415
e0ff5d9a 416@@ -269,23 +256,25 @@ verifyFileIsPng(FILE * const ifP,
0418bf0c
JB		 417 static unsigned int
418 computePngLineSize(struct pngx * const pngxP) {
baa327a2 419
0418bf0c
JB		 420- unsigned int const bytesPerSample =
421- pngxP->info_ptr->bit_depth == 16 ? 2 : 1;
422-
423+ png_uint_32 width;
424+ int bit_depth, color_type;
425+ unsigned int bytesPerSample;
426 unsigned int samplesPerPixel;
427
428- switch (pngxP->info_ptr->color_type) {
429+ png_get_IHDR(pngxP->png_ptr, pngxP->info_ptr, &width, NULL, &bit_depth, &color_type, NULL, NULL, NULL);
430+ bytesPerSample = (bit_depth == 16) ? 2 : 1;
431+ switch (color_type) {
432 case PNG_COLOR_TYPE_GRAY_ALPHA: samplesPerPixel = 2; break;
433 case PNG_COLOR_TYPE_RGB: samplesPerPixel = 3; break;
434 case PNG_COLOR_TYPE_RGB_ALPHA: samplesPerPixel = 4; break;
435 default: samplesPerPixel = 1;
436 }
baa327a2 437
0418bf0c
JB		 438- if (UINT_MAX / bytesPerSample / samplesPerPixel < pngxP->info_ptr->width)
439+ if (UINT_MAX / bytesPerSample / samplesPerPixel < width)
440 pm_error("Width %u of PNG is uncomputably large",
441- (unsigned int)pngxP->info_ptr->width);
442+ (unsigned int)width);
443
444- return pngxP->info_ptr->width * bytesPerSample * samplesPerPixel;
445+ return width * bytesPerSample * samplesPerPixel;
baa327a2
JB		 446 }
447
baa327a2 448
e0ff5d9a 449@@ -297,15 +286,16 @@ allocPngRaster(struct pngx * const pngxP
0418bf0c 450 unsigned int const lineSize = computePngLineSize(pngxP);
baa327a2 451
0418bf0c
JB		 452 png_byte ** pngImage;
453+ png_uint_32 height = png_get_image_height(pngxP->png_ptr, pngxP->info_ptr);
454 unsigned int row;
baa327a2 455
0418bf0c
JB		 456- MALLOCARRAY(pngImage, pngxP->info_ptr->height);
457+ MALLOCARRAY(pngImage, height);
baa327a2 458
0418bf0c
JB		 459 if (pngImage == NULL)
460 pm_error("couldn't allocate space for %u PNG raster rows",
461- (unsigned int)pngxP->info_ptr->height);
462+ (unsigned int)height);
baa327a2 463
0418bf0c
JB		 464- for (row = 0; row < pngxP->info_ptr->height; ++row) {
465+ for (row = 0; row < height; ++row) {
466 MALLOCARRAY(pngImage[row], lineSize);
467 if (pngImage[row] == NULL)
468 pm_error("couldn't allocate space for %uth row of PNG raster",
e0ff5d9a 469@@ -322,7 +312,7 @@ freePngRaster(png_byte ** const pngRas
baa327a2 470
0418bf0c 471 unsigned int row;
baa327a2 472
0418bf0c
JB		 473- for (row = 0; row < pngxP->info_ptr->height; ++row)
474+ for (row = 0; row < png_get_image_height(pngxP->png_ptr, pngxP->info_ptr); ++row)
475 free(pngRaster[row]);
476
477 free(pngRaster);
e0ff5d9a 478@@ -349,7 +339,7 @@ readPng(struct pngx * const pngxP,
0418bf0c
JB		 479
480 allocPngRaster(pngxP, &pngRaster);
481
482- if (pngxP->info_ptr->bit_depth < 8)
483+ if (png_get_bit_depth(pngxP->png_ptr, pngxP->info_ptr) < 8)
484 png_set_packing(pngxP->png_ptr);
485
486 png_read_image(pngxP->png_ptr, pngRaster);
e0ff5d9a 487@@ -445,31 +435,34 @@ saveText(struct pngx * const pngxP,
0418bf0c
JB		 488 FILE * const tfP) {
489
490 png_info * const info_ptr = pngxP->info_ptr;
491-
492+ png_text *text;
493+ int num_text;
494 unsigned int i;
495
496- for (i = 0 ; i < info_ptr->num_text; ++i) {
497+ png_get_text(pngxP->png_ptr, info_ptr, &text, &num_text);
498+
499+ for (i = 0 ; i < num_text; ++i) {
500 unsigned int j;
501 j = 0;
502
503- while (info_ptr->text[i].key[j] != '\0' &&
504- info_ptr->text[i].key[j] != ' ')
505+ while (text[i].key[j] != '\0' &&
506+ text[i].key[j] != ' ')
507 ++j;
508
509- if (info_ptr->text[i].key[j] != ' ') {
510- fprintf(tfP, "%s", info_ptr->text[i].key);
511- for (j = strlen (info_ptr->text[i].key); j < 15; ++j)
512+ if (text[i].key[j] != ' ') {
513+ fprintf(tfP, "%s", text[i].key);
514+ for (j = strlen (text[i].key); j < 15; ++j)
515 putc(' ', tfP);
516 } else {
517- fprintf(tfP, "\"%s\"", info_ptr->text[i].key);
518- for (j = strlen (info_ptr->text[i].key); j < 13; ++j)
519+ fprintf(tfP, "\"%s\"", text[i].key);
520+ for (j = strlen (text[i].key); j < 13; ++j)
521 putc(' ', tfP);
522 }
523 putc(' ', tfP); /* at least one space between key and text */
524
525- for (j = 0; j < info_ptr->text[i].text_length; ++j) {
526- putc(info_ptr->text[i].text[j], tfP);
527- if (info_ptr->text[i].text[j] == '\n') {
528+ for (j = 0; j < text[i].text_length; ++j) {
529+ putc(text[i].text[j], tfP);
530+ if (text[i].text[j] == '\n') {
531 unsigned int k;
532 for (k = 0; k < 16; ++k)
533 putc(' ', tfP);
e0ff5d9a 534@@ -489,21 +482,23 @@ showTime(struct pngx * const pngxP) {
0418bf0c
JB		 535 "July", "August", "September", "October", "November", "December"
536 };
537
538- if (pngxP->info_ptr->valid & PNG_INFO_tIME) {
539- if (pngxP->info_ptr->mod_time.month < 1 ||
540- pngxP->info_ptr->mod_time.month >= ARRAY_SIZE(month)) {
541+ if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_tIME)) {
542+ png_timep mod_timep;
543+ png_get_tIME(pngxP->png_ptr, pngxP->info_ptr, &mod_timep);
544+ if (mod_timep->month < 1 ||
545+ mod_timep->month >= ARRAY_SIZE(month)) {
546 pm_message("tIME chunk in PNG input is invalid; "
547 "modification time of image is unknown. "
548 "The month value, which should be in the range "
549- "1-12, is %u", pngxP->info_ptr->mod_time.month);
550+ "1-12, is %u", mod_timep->month);
551 } else
552 pm_message("modification time: %02d %s %d %02d:%02d:%02d",
553- pngxP->info_ptr->mod_time.day,
554- month[pngxP->info_ptr->mod_time.month],
555- pngxP->info_ptr->mod_time.year,
556- pngxP->info_ptr->mod_time.hour,
557- pngxP->info_ptr->mod_time.minute,
558- pngxP->info_ptr->mod_time.second);
559+ mod_timep->day,
560+ month[mod_timep->month],
561+ mod_timep->year,
562+ mod_timep->hour,
563+ mod_timep->minute,
564+ mod_timep->second);
565 }
566 }
567
e0ff5d9a 568@@ -516,7 +511,7 @@ dumpPngInfo(struct pngx * const pngxP) {
baa327a2
JB		 569 const char *type_string;
570 const char *filter_string;
571
572- switch (info_ptr->color_type) {
0418bf0c 573+ switch (png_get_color_type(pngxP->png_ptr, info_ptr)) {
baa327a2
JB		 574 case PNG_COLOR_TYPE_GRAY:
575 type_string = "gray";
576 break;
e0ff5d9a 577@@ -538,90 +533,106 @@ dumpPngInfo(struct pngx * const pngxP) {
baa327a2
JB		 578 break;
579 }
580
581- switch (info_ptr->filter_type) {
0418bf0c 582+ switch (png_get_filter_type(pngxP->png_ptr, info_ptr)) {
baa327a2
JB		 583 case PNG_FILTER_TYPE_BASE:
584 asprintfN(&filter_string, "base filter");
585 break;
586 default:
587 asprintfN(&filter_string, "unknown filter type %d",
588- info_ptr->filter_type);
0418bf0c 589+ png_get_filter_type(pngxP->png_ptr, info_ptr));
baa327a2
JB		 590 }
591
592+ {
593+ png_uint_32 width, height;
0418bf0c
JB		 594+ int bit_depth;
595+ png_get_IHDR(pngxP->png_ptr, pngxP->info_ptr, &width, &height, &bit_depth, NULL, NULL, NULL, NULL);
baa327a2
JB		 596 pm_message("reading a %ldw x %ldh image, %d bit%s",
597- info_ptr->width, info_ptr->height,
598- info_ptr->bit_depth, info_ptr->bit_depth > 1 ? "s" : "");
0418bf0c 599+ (long)width, (long)height,
baa327a2
JB		 600+ bit_depth, bit_depth > 1 ? "s" : "");
601+ }
602 pm_message("%s, %s, %s",
603 type_string,
604- info_ptr->interlace_type ?
0418bf0c 605+ png_get_interlace_type(pngxP->png_ptr, info_ptr) ?
baa327a2
JB		 606 "Adam7 interlaced" : "not interlaced",
607 filter_string);
608+ {
609+ png_color_16p bkgp;
0418bf0c 610+ if(png_get_bKGD(pngxP->png_ptr, info_ptr, &bkgp) && (bkgp != NULL))
baa327a2
JB		 611 pm_message("background {index, gray, red, green, blue} = "
612 "{%d, %d, %d, %d, %d}",
613- info_ptr->background.index,
614- info_ptr->background.gray,
615- info_ptr->background.red,
616- info_ptr->background.green,
617- info_ptr->background.blue);
618+ bkgp->index,
619+ bkgp->gray,
620+ bkgp->red,
621+ bkgp->green,
622+ bkgp->blue);
623+ }
624
625 strfree(filter_string);
626
627- if (info_ptr->valid & PNG_INFO_tRNS)
0418bf0c
JB		 628+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_tRNS)) {
629+ int num_trans;
630+ png_get_tRNS(pngxP->png_ptr, info_ptr, NULL, &num_trans, NULL);
baa327a2
JB		 631 pm_message("tRNS chunk (transparency): %u entries",
632- info_ptr->num_trans);
633- else
634+ num_trans);
635+ } else
636 pm_message("tRNS chunk (transparency): not present");
637
638- if (info_ptr->valid & PNG_INFO_gAMA)
639- pm_message("gAMA chunk (image gamma): gamma = %4.2f", info_ptr->gamma);
640- else
0418bf0c
JB		 641+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_gAMA)) {
642+ double gamma;
643+ png_get_gAMA(pngxP->png_ptr, info_ptr, &gamma);
baa327a2
JB		 644+ pm_message("gAMA chunk (image gamma): gamma = %4.2f", gamma);
645+ } else
646 pm_message("gAMA chunk (image gamma): not present");
647
648- if (info_ptr->valid & PNG_INFO_sBIT)
0418bf0c 649+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_sBIT))
baa327a2
JB		 650 pm_message("sBIT chunk: present");
651 else
652 pm_message("sBIT chunk: not present");
653
654- if (info_ptr->valid & PNG_INFO_cHRM)
0418bf0c 655+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_cHRM))
baa327a2
JB		 656 pm_message("cHRM chunk: present");
657 else
658 pm_message("cHRM chunk: not present");
659
660- if (info_ptr->valid & PNG_INFO_PLTE)
661- pm_message("PLTE chunk: %d entries", info_ptr->num_palette);
662- else
0418bf0c
JB		 663+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_PLTE)) {
664+ png_colorp palette;
665+ int num_palette;
666+ png_get_PLTE(pngxP->png_ptr, info_ptr, &palette, &num_palette);
baa327a2
JB		 667+ pm_message("PLTE chunk: %d entries", num_palette);
668+ } else
669 pm_message("PLTE chunk: not present");
670
671- if (info_ptr->valid & PNG_INFO_bKGD)
0418bf0c 672+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_bKGD))
baa327a2
JB		 673 pm_message("bKGD chunk: present");
674 else
675 pm_message("bKGD chunk: not present");
676
0418bf0c
JB		 677- if (info_ptr->valid & PNG_INFO_PLTE)
678+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_hIST))
baa327a2
JB		 679 pm_message("hIST chunk: present");
680 else
681 pm_message("hIST chunk: not present");
682
683- if (info_ptr->valid & PNG_INFO_pHYs)
0418bf0c 684+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_pHYs))
baa327a2
JB		 685 pm_message("pHYs chunk: present");
686 else
687 pm_message("pHYs chunk: not present");
688
689- if (info_ptr->valid & PNG_INFO_oFFs)
0418bf0c 690+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_oFFs))
baa327a2
JB		 691 pm_message("oFFs chunk: present");
692 else
693 pm_message("oFFs chunk: not present");
694
695- if (info_ptr->valid & PNG_INFO_tIME)
0418bf0c 696+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_tIME))
baa327a2
JB		 697 pm_message("tIME chunk: present");
698 else
699 pm_message("tIME chunk: not present");
700
701- if (info_ptr->valid & PNG_INFO_pCAL)
0418bf0c 702+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_pCAL))
baa327a2
JB		 703 pm_message("pCAL chunk: present");
704 else
705 pm_message("pCAL chunk: not present");
706
707- if (info_ptr->valid & PNG_INFO_sRGB)
0418bf0c 708+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_sRGB))
baa327a2
JB		 709 pm_message("sRGB chunk: present");
710 else
711 pm_message("sRGB chunk: not present");
e0ff5d9a 712@@ -675,7 +686,7 @@ isTransparentColor(pngcolor const c
0418bf0c
JB		 713 pixels, and just do it ourselves.
714 */
715
716- switch (pngxP->info_ptr->color_type) {
717+ switch (png_get_color_type(pngxP->png_ptr, pngxP->info_ptr)) {
718 case PNG_COLOR_TYPE_GRAY:
719 retval = color.r == gamma_correct(transColorP->gray, totalgamma);
720 break;
e0ff5d9a 721@@ -702,9 +713,11 @@ setupGammaCorrection(struct pngx * const
baa327a2
JB		 722 *totalgammaP = -1.0;
723 else {
724 float imageGamma;
0418bf0c
JB		 725- if (pngxP->info_ptr->valid & PNG_INFO_gAMA)
726- imageGamma = pngxP->info_ptr->gamma;
baa327a2 727- else {
0418bf0c
JB		 728+ if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_gAMA)) {
729+ double gamma;
730+ png_get_gAMA(pngxP->png_ptr, pngxP->info_ptr, &gamma);
731+ imageGamma = gamma;
baa327a2
JB		 732+ } else {
733 if (verbose)
734 pm_message("PNG doesn't specify image gamma. Assuming 1.0");
735 imageGamma = 1.0;
e0ff5d9a 736@@ -722,7 +735,7 @@ setupGammaCorrection(struct pngx * const
baa327a2
JB		 737 /* in case of gamma-corrections, sBIT's as in the
738 PNG-file are not valid anymore
739 */
0418bf0c
JB		 740- pngxP->info_ptr->valid &= ~PNG_INFO_sBIT;
741+ png_set_invalid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_sBIT);
baa327a2
JB		 742 if (verbose)
743 pm_message("image gamma is %4.2f, "
744 "converted for display gamma of %4.2f",
e0ff5d9a 745@@ -734,20 +747,23 @@ setupGammaCorrection(struct pngx * const
baa327a2
JB		 746
747
748 static bool
749-paletteHasPartialTransparency(png_info * const info_ptr) {
750+paletteHasPartialTransparency(png_struct * const png_ptr, png_info * const info_ptr) {
751
752 bool retval;
753
754- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
755- if (info_ptr->valid & PNG_INFO_tRNS) {
756+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
757+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
758 bool foundGray;
759 unsigned int i;
0418bf0c
JB		 760+ int num_trans;
761+ png_bytep trans_alpha;
762+ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
baa327a2 763
c27d2a5c 764 for (i = 0, foundGray = FALSE;
baa327a2
JB		 765- i < info_ptr->num_trans && !foundGray;
766+ i < num_trans && !foundGray;
c27d2a5c 767 ++i) {
0418bf0c
JB		 768- if (info_ptr->TRANS_ALPHA[i] != 0 &&
769- info_ptr->TRANS_ALPHA[i] != maxval) {
baa327a2
JB		 770+ if (trans_alpha[i] != 0 &&
771+ trans_alpha[i] != maxval) {
c27d2a5c
AM		 772 foundGray = TRUE;
773 }
774 }
e0ff5d9a 775@@ -777,13 +793,14 @@ setupSignificantBits(struct pngx *
0418bf0c
JB		 776 png_info * const info_ptr = pngxP->info_ptr;
777
baa327a2
JB		 778 /* Initial assumption of maxval */
779- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
0418bf0c 780+ png_byte color_type = png_get_color_type(pngxP->png_ptr, info_ptr);
baa327a2
JB		 781+ if (color_type == PNG_COLOR_TYPE_PALETTE) {
782 if (alpha == ALPHA_ONLY) {
783- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
784- info_ptr->color_type == PNG_COLOR_TYPE_RGB)
785+ if (color_type == PNG_COLOR_TYPE_GRAY ||
786+ color_type == PNG_COLOR_TYPE_RGB)
787 /* The alpha mask will be all opaque, so maxval 1 is plenty */
788 *maxvalP = 1;
789- else if (paletteHasPartialTransparency(info_ptr))
0418bf0c 790+ else if (paletteHasPartialTransparency(pngxP->png_ptr, info_ptr))
baa327a2
JB		 791 /* Use same maxval as PNG transparency palette for simplicity*/
792 *maxvalP = 255;
793 else
e0ff5d9a 794@@ -793,7 +810,7 @@ setupSignificantBits(struct pngx *
baa327a2
JB		 795 /* Use same maxval as PNG palette for simplicity */
796 *maxvalP = 255;
797 } else {
798- *maxvalP = (1l << info_ptr->bit_depth) - 1;
0418bf0c 799+ *maxvalP = (1l << png_get_bit_depth(pngxP->png_ptr, info_ptr)) - 1;
baa327a2
JB		 800 }
801
802 /* sBIT handling is very tricky. If we are extracting only the
e0ff5d9a 803@@ -806,20 +823,25 @@ setupSignificantBits(struct pngx *
baa327a2
JB		 804 is used
805 */
806
807- if (info_ptr->valid & PNG_INFO_sBIT) {
0418bf0c
JB		 808+ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_sBIT)) {
809+ png_color_8p sig_bit;
810+ png_get_sBIT(pngxP->png_ptr, info_ptr, &sig_bit);
baa327a2
JB		 811 switch (alpha) {
812 case ALPHA_MIX:
813- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
814- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
815+ if (color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
816+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
817 break;
818- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
819- (info_ptr->valid & PNG_INFO_tRNS)) {
820+ if (color_type == PNG_COLOR_TYPE_PALETTE &&
0418bf0c 821+ (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_tRNS))) {
baa327a2
JB		 822
823+ png_bytep trans_alpha;
0418bf0c 824+ int num_trans;
baa327a2 825 bool trans_mix;
c27d2a5c
AM		 826 unsigned int i;
827 trans_mix = TRUE;
baa327a2 828- for (i = 0; i < info_ptr->num_trans; ++i)
0418bf0c
JB		 829- if (info_ptr->TRANS_ALPHA[i] != 0 && info_ptr->TRANS_ALPHA[i] != 255) {
830+ png_get_tRNS(pngxP->png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
baa327a2
JB		 831+ for (i = 0; i < num_trans; ++i)
832+ if (trans_alpha[i] != 0 && trans_alpha[i] != 255) {
c27d2a5c
AM		 833 trans_mix = FALSE;
834 break;
835 }
e0ff5d9a 836@@ -830,70 +852,73 @@ setupSignificantBits(struct pngx *
baa327a2
JB		 837 /* else fall though to normal case */
838
839 case ALPHA_NONE:
840- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
841- info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
842- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
843- (info_ptr->sig_bit.red != info_ptr->sig_bit.green ||
844- info_ptr->sig_bit.red != info_ptr->sig_bit.blue) &&
845+ if ((color_type == PNG_COLOR_TYPE_PALETTE ||
846+ color_type == PNG_COLOR_TYPE_RGB ||
847+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
848+ (sig_bit->red != sig_bit->green ||
849+ sig_bit->red != sig_bit->blue) &&
850 alpha == ALPHA_NONE) {
851 pm_message("This program cannot handle "
852 "different bit depths for color channels");
853 pm_message("writing file with %d bit resolution",
854- info_ptr->bit_depth);
0418bf0c
JB		 855+ png_get_bit_depth(pngxP->png_ptr, info_ptr));
856 *errorLevelP = PNMTOPNG_WARNING_LEVEL;
baa327a2
JB		 857 } else {
858- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) &&
859- (info_ptr->sig_bit.red < 255)) {
860+ if ((color_type == PNG_COLOR_TYPE_PALETTE) &&
0418bf0c 861+ (sig_bit->red < 255)) {
baa327a2
JB		 862 unsigned int i;
863- for (i = 0; i < info_ptr->num_palette; ++i) {
864- info_ptr->palette[i].red >>=
865- (8 - info_ptr->sig_bit.red);
866- info_ptr->palette[i].green >>=
867- (8 - info_ptr->sig_bit.green);
868- info_ptr->palette[i].blue >>=
869- (8 - info_ptr->sig_bit.blue);
0418bf0c
JB		 870+ png_colorp palette;
871+ int num_palette;
872+ png_get_PLTE(pngxP->png_ptr, info_ptr, &palette, &num_palette);
baa327a2
JB		 873+ for (i = 0; i < num_palette; ++i) {
874+ palette[i].red >>=
875+ (8 - sig_bit->red);
876+ palette[i].green >>=
877+ (8 - sig_bit->green);
878+ palette[i].blue >>=
879+ (8 - sig_bit->blue);
880 }
881- *maxvalP = (1l << info_ptr->sig_bit.red) - 1;
882+ *maxvalP = (1l << sig_bit->red) - 1;
883 if (verbose)
884 pm_message ("image has fewer significant bits, "
885 "writing file with %d bits per channel",
886- info_ptr->sig_bit.red);
887+ sig_bit->red);
888 } else
889- if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
890- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
891- (info_ptr->sig_bit.red < info_ptr->bit_depth)) {
0418bf0c 892- png_set_shift(pngxP->png_ptr, &(info_ptr->sig_bit));
baa327a2
JB		 893- *maxvalP = (1l << info_ptr->sig_bit.red) - 1;
894+ if ((color_type == PNG_COLOR_TYPE_RGB ||
895+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
0418bf0c
JB		 896+ (sig_bit->red < png_get_bit_depth(pngxP->png_ptr, info_ptr))) {
897+ png_set_shift(pngxP->png_ptr, sig_bit);
baa327a2
JB		 898+ *maxvalP = (1l << sig_bit->red) - 1;
899 if (verbose)
900 pm_message("image has fewer significant bits, "
901 "writing file with %d "
902 "bits per channel",
903- info_ptr->sig_bit.red);
904+ sig_bit->red);
905 } else
906- if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
907- info_ptr->color_type ==
908+ if ((color_type == PNG_COLOR_TYPE_GRAY ||
909+ color_type ==
910 PNG_COLOR_TYPE_GRAY_ALPHA) &&
911- (info_ptr->sig_bit.gray < info_ptr->bit_depth)) {
0418bf0c 912- png_set_shift(pngxP->png_ptr, &info_ptr->sig_bit);
baa327a2 913- *maxvalP = (1l << info_ptr->sig_bit.gray) - 1;
0418bf0c
JB		 914+ (sig_bit->gray < png_get_bit_depth(pngxP->png_ptr, info_ptr))) {
915+ png_set_shift(pngxP->png_ptr, sig_bit);
baa327a2
JB		 916+ *maxvalP = (1l << sig_bit->gray) - 1;
917 if (verbose)
918 pm_message("image has fewer significant bits, "
919 "writing file with %d bits",
920- info_ptr->sig_bit.gray);
921+ sig_bit->gray);
922 }
923 }
924 break;
925
926 case ALPHA_ONLY:
927- if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
928- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) &&
929- (info_ptr->sig_bit.gray < info_ptr->bit_depth)) {
0418bf0c 930- png_set_shift(pngxP->png_ptr, &info_ptr->sig_bit);
baa327a2
JB		 931+ if ((color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
932+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) &&
0418bf0c
JB		 933+ (sig_bit->gray < png_get_bit_depth(pngxP->png_ptr, info_ptr))) {
934+ png_set_shift(pngxP->png_ptr, sig_bit);
baa327a2
JB		 935 if (verbose)
936 pm_message ("image has fewer significant bits, "
937 "writing file with %d bits",
938- info_ptr->sig_bit.alpha);
939- *maxvalP = (1l << info_ptr->sig_bit.alpha) - 1;
940+ sig_bit->alpha);
941+ *maxvalP = (1l << sig_bit->alpha) - 1;
942 }
943 break;
944
e0ff5d9a 945@@ -908,18 +933,23 @@ imageHasColor(struct pngx * const pngxP)
baa327a2
JB		 946
947 bool retval;
baa327a2 948
0418bf0c
JB		 949- if (pngxP->info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
950- pngxP->info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
951+ png_byte color_type = png_get_color_type(pngxP->png_ptr, pngxP->info_ptr);
baa327a2
JB		 952+ if (color_type == PNG_COLOR_TYPE_GRAY ||
953+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
954
955 retval = FALSE;
0418bf0c 956- else if (pngxP->info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
baa327a2
JB		 957+ else if (color_type == PNG_COLOR_TYPE_PALETTE) {
958 bool foundColor;
959 unsigned int i;
0418bf0c
JB		 960+ png_colorp palette;
961+ int num_palette;
baa327a2 962+
0418bf0c
JB		 963+ png_get_PLTE(pngxP->png_ptr, pngxP->info_ptr, &palette, &num_palette);
964
baa327a2 965 for (i = 0, foundColor = FALSE;
0418bf0c 966- i < pngxP->info_ptr->num_palette && !foundColor;
baa327a2
JB		 967+ i < num_palette && !foundColor;
968 ++i) {
0418bf0c 969- if (iscolor(pngxP->info_ptr->palette[i]))
baa327a2
JB		 970+ if (iscolor(palette[i]))
971 foundColor = TRUE;
972 }
973 retval = foundColor;
e0ff5d9a 974@@ -974,19 +1004,24 @@ getBackgroundColor(struct pngx * const p
baa327a2
JB		 975 bgColorP->g = PPM_GETG(backcolor);
976 bgColorP->b = PPM_GETB(backcolor);
977
0418bf0c
JB		 978- } else if (pngxP->info_ptr->valid & PNG_INFO_bKGD) {
979+ } else if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_bKGD)) {
980+ png_color_16p background;
981+ png_get_bKGD(pngxP->png_ptr, pngxP->info_ptr, &background);
baa327a2
JB		 982 /* didn't manage to get libpng to work (bugs?) concerning background
983 processing, therefore we do our own.
984 */
0418bf0c
JB		 985- switch (pngxP->info_ptr->color_type) {
986+ switch (png_get_color_type(pngxP->png_ptr, pngxP->info_ptr)) {
baa327a2
JB		 987 case PNG_COLOR_TYPE_GRAY:
988 case PNG_COLOR_TYPE_GRAY_ALPHA:
989 bgColorP->r = bgColorP->g = bgColorP->b =
0418bf0c 990- gamma_correct(pngxP->info_ptr->background.gray, totalgamma);
baa327a2
JB		 991+ gamma_correct(background->gray, totalgamma);
992 break;
993 case PNG_COLOR_TYPE_PALETTE: {
0418bf0c
JB		 994+ png_colorp palette;
995+ int num_palette;
996+ png_get_PLTE(pngxP->png_ptr, pngxP->info_ptr, &palette, &num_palette);
baa327a2 997 png_color const rawBgcolor =
0418bf0c 998- pngxP->info_ptr->palette[pngxP->info_ptr->background.index];
baa327a2
JB		 999+ palette[background->index];
1000 bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
1001 bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
1002 bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma);
e0ff5d9a 1003@@ -994,7 +1029,7 @@ getBackgroundColor(struct pngx * const p
baa327a2
JB		 1004 break;
1005 case PNG_COLOR_TYPE_RGB:
1006 case PNG_COLOR_TYPE_RGB_ALPHA: {
0418bf0c 1007- png_color_16 const rawBgcolor = pngxP->info_ptr->background;
baa327a2
JB		 1008+ png_color_16 const rawBgcolor = *background;
1009
1010 bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
1011 bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
e0ff5d9a 1012@@ -1013,10 +1048,12 @@ static void
0418bf0c
JB		 1013 warnNonsquarePixels(struct pngx * const pngxP,
1014 int * const errorLevelP) {
1015
1016- if (pngxP->info_ptr->valid & PNG_INFO_pHYs) {
1017+ if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_pHYs)) {
1018+ png_uint_32 x_pixels_per_unit, y_pixels_per_unit;
1019+ png_get_pHYs(pngxP->png_ptr, pngxP->info_ptr, &x_pixels_per_unit, &y_pixels_per_unit, NULL);
1020 float const r =
1021- (float)pngxP->info_ptr->x_pixels_per_unit /
1022- pngxP->info_ptr->y_pixels_per_unit;
1023+ (float)x_pixels_per_unit /
1024+ y_pixels_per_unit;
1025
1026 if (r != 1.0) {
1027 pm_message ("warning - non-square pixels; "
e0ff5d9a 1028@@ -1030,7 +1067,7 @@ warnNonsquarePixels(struct pngx * const
0418bf0c
JB		 1029
1030
1031
1032-#define GET_PNG_VAL(p) get_png_val(&(p), pngxP->info_ptr->bit_depth)
1033+#define GET_PNG_VAL(p) get_png_val(&(p), png_get_bit_depth(pngxP->png_ptr, pngxP->info_ptr))
1034
1035
1036
e0ff5d9a 1037@@ -1048,8 +1085,8 @@ makeXelRow(xel * const xel
0418bf0c
JB		 1038 unsigned int col;
1039
1040 pngPixelP = &pngRasterRow[0]; /* initial value */
1041- for (col = 0; col < pngxP->info_ptr->width; ++col) {
1042- switch (pngxP->info_ptr->color_type) {
1043+ for (col = 0; col < png_get_image_width(pngxP->png_ptr, pngxP->info_ptr); ++col) {
1044+ switch (png_get_color_type(pngxP->png_ptr, pngxP->info_ptr)) {
1045 case PNG_COLOR_TYPE_GRAY: {
1046 pngcolor fgColor;
1047 fgColor.r = fgColor.g = fgColor.b = GET_PNG_VAL(pngPixelP);
e0ff5d9a 1048@@ -1071,7 +1108,15 @@ makeXelRow(xel * const xel
0418bf0c
JB		 1049
1050 case PNG_COLOR_TYPE_PALETTE: {
1051 png_uint_16 const index = GET_PNG_VAL(pngPixelP);
1052- png_color const paletteColor = pngxP->info_ptr->palette[index];
1053+ png_color paletteColor;
1054+ png_colorp palette;
1055+ png_bytep trans_alpha;
1056+ int num_palette, num_trans;
1057+ bool trans_valid = png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_tRNS);
1058+ png_get_PLTE(pngxP->png_ptr, pngxP->info_ptr, &palette, &num_palette);
1059+ if (trans_valid)
1060+ png_get_tRNS(pngxP->png_ptr, pngxP->info_ptr, &trans_alpha, &num_trans, NULL);
1061+ paletteColor = palette[index];
1062
1063 pngcolor fgColor;
1064
e0ff5d9a 1065@@ -1080,9 +1125,9 @@ makeXelRow(xel * const xel
0418bf0c
JB		 1066 fgColor.b = paletteColor.blue;
1067
1068 setXel(&xelrow[col], fgColor, bgColor, alphaHandling,
1069- (pngxP->info_ptr->valid & PNG_INFO_tRNS) &&
1070- index < pngxP->info_ptr->num_trans ?
1071- pngxP->info_ptr->TRANS_ALPHA[index] : maxval);
1072+ trans_valid &&
1073+ index < num_trans ?
1074+ trans_alpha[index] : maxval);
1075 }
1076 break;
1077
e0ff5d9a 1078@@ -1112,13 +1157,20 @@ makeXelRow(xel * const xel
0418bf0c
JB		 1079
1080 default:
1081 pm_error("unknown PNG color type: %d",
1082- pngxP->info_ptr->color_type);
1083+ png_get_color_type(pngxP->png_ptr, pngxP->info_ptr));
1084 }
1085 }
baa327a2
JB		 1086 }
1087
baa327a2 1088
0418bf0c
JB		 1089
1090+static png_bytep get_png_trans_alpha(struct pngx * const pngxP)
baa327a2
JB		 1091+{
1092+ png_bytep trans_alpha;
0418bf0c 1093+ png_get_tRNS(pngxP->png_ptr, pngxP->info_ptr, &trans_alpha, NULL, NULL);
baa327a2
JB		 1094+ return trans_alpha;
1095+}
0418bf0c 1096+
baa327a2
JB		 1097 static void
1098 writePnm(FILE * const ofP,
1099 xelval const maxval,
e0ff5d9a 1100@@ -1142,6 +1194,8 @@ writePnm(FILE * const ofP,
0418bf0c 1101
baa327a2
JB		 1102 xel * xelrow;
1103 unsigned int row;
0418bf0c
JB		 1104+ png_uint_32 width = png_get_image_width(pngxP->png_ptr, pngxP->info_ptr),
1105+ height = png_get_image_height(pngxP->png_ptr, pngxP->info_ptr);
baa327a2
JB		 1106
1107 if (verbose)
0418bf0c 1108 pm_message("writing a %s file (maxval=%u)",
e0ff5d9a 1109@@ -1151,17 +1205,17 @@ writePnm(FILE * const ofP,
0418bf0c
JB		 1110 "UNKNOWN!",
1111 maxval);
baa327a2 1112
0418bf0c 1113- xelrow = pnm_allocrow(pngxP->info_ptr->width);
baa327a2 1114+ xelrow = pnm_allocrow(width);
baa327a2 1115
0418bf0c
JB		 1116 pnm_writepnminit(stdout,
1117- pngxP->info_ptr->width, pngxP->info_ptr->height, maxval,
1118+ width, height, maxval,
1119 pnmType, plainFalse);
baa327a2 1120
0418bf0c
JB		 1121- for (row = 0; row < pngxP->info_ptr->height; ++row) {
1122+ for (row = 0; row < height; ++row) {
1123 makeXelRow(xelrow, maxval, pnmType, pngxP, pngRaster[row], bgColor,
1124 alphaHandling, totalgamma);
baa327a2 1125
0418bf0c
JB		 1126- pnm_writepnmrow(ofP, xelrow, pngxP->info_ptr->width, maxval,
1127+ pnm_writepnmrow(ofP, xelrow, width, maxval,
1128 pnmType, plainFalse);
baa327a2
JB		 1129 }
1130 pnm_freerow (xelrow);
0418bf0c
JB		 1131--- netpbm-10.35.83/converter/other/pngtxt.c.orig 2006-08-19 05:12:28.000000000 +0200
1132+++ netpbm-10.35.83/converter/other/pngtxt.c 2012-01-29 09:59:22.463431985 +0100
1133@@ -240,7 +240,8 @@
baa327a2 1134
baa327a2 1135
0418bf0c
JB		 1136 void
1137-pnmpng_read_text (png_info * const info_ptr,
1138+pnmpng_read_text (png_struct * const png_ptr,
1139+ png_info * const info_ptr,
1140 FILE * const tfp,
1141 bool const ztxt,
1142 bool const verbose) {
1143@@ -250,15 +251,16 @@
1144 unsigned int commentIdx;
1145 bool noCommentsYet;
1146 bool eof;
1147+ png_textp text;
1148 unsigned int allocatedComments;
1149- /* Number of entries currently allocated for the info_ptr->text
1150+ /* Number of entries currently allocated for the text
1151 array
1152 */
baa327a2
JB		 1153
1154 allocatedComments = 256; /* initial value */
1155
1156- MALLOCARRAY(info_ptr->text, allocatedComments);
1157- if (info_ptr->text == NULL)
1158+ MALLOCARRAY(text, allocatedComments);
1159+ if (text == NULL)
1160 pm_error("unable to allocate memory for comment array");
1161
1162 commentIdx = 0;
1163@@ -273,7 +275,7 @@
1164 if (lineLength == 0) {
1165 /* skip this empty line */
1166 } else {
1167- handleArrayAllocation(&info_ptr->text, &allocatedComments,
1168+ handleArrayAllocation(&text, &allocatedComments,
1169 commentIdx);
1170 if ((textline[0] != ' ') && (textline[0] != '\t')) {
1171 /* Line doesn't start with white space, which
1172@@ -285,7 +287,7 @@
1173 ++commentIdx;
1174 noCommentsYet = FALSE;
1175
1176- startComment(&info_ptr->text[commentIdx],
1177+ startComment(&text[commentIdx],
1178 textline, lineLength, ztxt);
1179 } else {
1180 /* Line starts with whitespace, which means it is
1181@@ -295,20 +297,20 @@
1182 pm_error("Invalid comment file format: "
1183 "first line is a continuation line! "
1184 "(It starts with whitespace)");
1185- continueComment(&info_ptr->text[commentIdx],
1186+ continueComment(&text[commentIdx],
1187 textline, lineLength);
1188 }
1189 }
1190 strfree(textline);
1191 }
1192 }
1193- if (noCommentsYet)
1194- info_ptr->num_text = 0;
1195- else
1196- info_ptr->num_text = commentIdx + 1;
1197+ if (!noCommentsYet)
1198+ png_set_text(png_ptr, info_ptr, text, commentIdx + 1);
1199
1200 if (verbose)
1201- pm_message("%d comments placed in text chunk", info_ptr->num_text);
1202+ pm_message("%d comments placed in text chunk", commentIdx + 1);
1203+
1204+ free(text);
1205 }
1206
1207
1208--- netpbm-10.35.83/converter/other/pngtxt.h.orig 2006-08-19 05:12:28.000000000 +0200
1209+++ netpbm-10.35.83/converter/other/pngtxt.h 2012-01-29 09:59:59.566766561 +0100
1210@@ -5,7 +5,8 @@
1211 #include <png.h>
1212
1213 void
1214-pnmpng_read_text (png_info * const info_ptr,
1215+pnmpng_read_text (png_struct * const png_ptr,
1216+ png_info * const info_ptr,
1217 FILE * const tfp,
1218 bool const ztxt,
1219 bool const verbose);
1220--- netpbm-10.35.83/converter/other/pamrgbatopng.c.orig 2006-08-19 05:12:28.000000000 +0200
1221+++ netpbm-10.35.83/converter/other/pamrgbatopng.c 2012-01-29 14:02:47.790587693 +0100
1222@@ -101,10 +101,9 @@
1223 if (!infoP)
1224 pm_error("Could not allocate PNG info structure");
1225 else {
1226- infoP->width = pamP->width;
1227- infoP->height = pamP->height;
1228- infoP->bit_depth = 8;
1229- infoP->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
1230+ png_set_IHDR(pngP, infoP,
1231+ pamP->width, pamP->height,
1232+ 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0, 0);
1233
1234 png_init_io(pngP, ofP);
1235
b34cc149
AM		 1236--- netpbm-10.35.90/converter/other/tifftopnm.c~ 2006-08-19 05:12:28.000000000 +0200
1237+++ netpbm-10.35.90/converter/other/tifftopnm.c 2013-10-31 17:58:49.296479893 +0100
1238@@ -902,14 +902,14 @@
1239
1240 ok = TIFFRGBAImageBegin(&img, tif, stopOnErrorFalse, emsg) ;
1241 if (!ok) {
1242- pm_message(emsg);
1243+ pm_message("%s", emsg);
1244 *statusP = CONV_FAILED;
1245 } else {
1246 int ok;
1247 ok = TIFFRGBAImageGet(&img, raster, cols, rows);
1248 TIFFRGBAImageEnd(&img) ;
1249 if (!ok) {
1250- pm_message(emsg);
1251+ pm_message("%s", emsg);
1252 *statusP = CONV_FAILED;
1253 } else {
1254 *statusP = CONV_DONE;
1255--- netpbm-10.35.90/converter/other/tifftopnm.c~ 2013-10-31 17:59:04.000000000 +0100
1256+++ netpbm-10.35.90/converter/other/tifftopnm.c 2013-10-31 18:00:05.761780998 +0100
1257@@ -882,7 +882,7 @@
1258 int ok;
1259 ok = TIFFRGBAImageOK(tif, emsg);
1260 if (!ok) {
1261- pm_message(emsg);
1262+ pm_message("%s", emsg);
1263 *statusP = CONV_UNABLE;
1264 } else {
1265 uint32* raster ;
1266--- netpbm-10.35.90/converter/other/fiasco/pnmtofiasco.c~ 2006-08-19 05:12:28.000000000 +0200
1267+++ netpbm-10.35.90/converter/other/fiasco/pnmtofiasco.c 2013-10-31 18:02:13.731936837 +0100
1268@@ -176,7 +176,7 @@
1269 return 0;
1270 else
1271 {
1272- fprintf (stderr, fiasco_get_error_message ());
1273+ fprintf (stderr, "%s", fiasco_get_error_message ());
1274 fprintf (stderr, "\n");
1275 return 1;
1276 }
1277--- netpbm-10.35.90/converter/other/fiasco/params.c~ 2006-08-19 05:12:28.000000000 +0200
1278+++ netpbm-10.35.90/converter/other/fiasco/params.c 2013-10-31 18:05:00.869560937 +0100
1279@@ -652,7 +652,7 @@
1280 fprintf (stderr, "Usage: %s [OPTION]...%s\n", progname,
1281 non_opt_string ? non_opt_string : " ");
1282 if (synopsis != NULL)
1283- fprintf (stderr, synopsis);
1284+ fprintf (stderr, "%s", synopsis);
1285 fprintf (stderr, "\n\n");
1286 fprintf (stderr, "Mandatory or optional arguments to long options "
1287 "are mandatory or optional\nfor short options too. "
0418bf0c
JB		 1288--- netpbm-10.47.61/converter/pbm/cmuwmtopbm.c.orig 2016-03-27 03:38:28.000000000 +0200
1289+++ netpbm-10.47.61/converter/pbm/cmuwmtopbm.c 2016-06-08 20:43:31.277330446 +0200
1290@@ -39,20 +39,20 @@
1291
1292 rc = pm_readbiglong(ifP, &l);
1293 if (rc == -1 )
1294- pm_error(initReadError);
1295+ pm_error("%s", initReadError);
1296 if ((uint32_t)l != CMUWM_MAGIC)
1297 pm_error("bad magic number in CMU window manager file");
1298 rc = pm_readbiglong(ifP, &l);
1299 if (rc == -1)
1300- pm_error(initReadError);
1301+ pm_error("%s", initReadError);
1302 *colsP = l;
1303 rc = pm_readbiglong(ifP, &l);
1304 if (rc == -1 )
1305- pm_error(initReadError);
1306+ pm_error("%s", initReadError);
1307 *rowsP = l;
1308 rc = pm_readbigshort(ifP, &s);
1309 if (rc == -1)
1310- pm_error(initReadError);
1311+ pm_error("%s", initReadError);
1312 *depthP = s;
1313 }
1314
1315--- netpbm-10.47.61/converter/pbm/pbmtocmuwm.c.orig 2016-03-27 03:38:28.000000000 +0200
1316+++ netpbm-10.47.61/converter/pbm/pbmtocmuwm.c 2016-06-08 20:48:55.797316874 +0200
1317@@ -31,16 +31,16 @@
1318
1319 rc = pm_writebiglong(stdout, CMUWM_MAGIC);
1320 if (rc == -1)
1321- pm_error(initWriteError);
1322+ pm_error("%s", initWriteError);
1323 rc = pm_writebiglong(stdout, cols);
1324 if (rc == -1)
1325- pm_error(initWriteError);
1326+ pm_error("%s", initWriteError);
1327 rc = pm_writebiglong(stdout, rows);
1328 if (rc == -1)
1329- pm_error(initWriteError);
1330+ pm_error("%s", initWriteError);
1331 rc = pm_writebigshort(stdout, (short) 1);
1332 if (rc == -1)
1333- pm_error(initWriteError);
1334+ pm_error("%s", initWriteError);
1335 }
1336
1337
1338--- netpbm-10.47.61/converter/other/pngtopam.c.orig 2016-03-27 03:38:28.000000000 +0200
1339+++ netpbm-10.47.61/converter/other/pngtopam.c 2016-06-10 21:50:14.703243717 +0200
1340@@ -30,14 +30,6 @@
1341 #include "shhopt.h"
1342 #include "pam.h"
1343
1344-/* A hack until we can remove direct access to png_info from the program */
1345-#if PNG_LIBPNG_VER >= 10400
1346-#define trans_values trans_color
1347-#define TRANS_ALPHA trans_alpha
1348-#else
1349-#define TRANS_ALPHA trans
1350-#endif
1351-
1352 typedef struct _jmpbuf_wrapper {
1353 jmp_buf jmpbuf;
1354 } jmpbuf_wrapper;
1355@@ -268,28 +260,31 @@ static int iscolor (png_color c)
1356 return c.red != c.green || c.green != c.blue;
1357 }
1358
1359-static void save_text (png_info *info_ptr, FILE *tfp)
1360+static void save_text (png_struct *png_ptr, png_info *info_ptr, FILE *tfp)
1361 {
1362 int i, j, k;
1363+ png_text *text;
1364+ int num_text;
1365
1366- for (i = 0 ; i < info_ptr->num_text ; i++) {
1367+ png_get_text(png_ptr, info_ptr, &text, &num_text);
1368+ for (i = 0 ; i < num_text ; i++) {
1369 j = 0;
1370- while (info_ptr->text[i].key[j] != '\0' && info_ptr->text[i].key[j] != ' ')
1371+ while (text[i].key[j] != '\0' && text[i].key[j] != ' ')
1372 j++;
1373- if (info_ptr->text[i].key[j] != ' ') {
1374- fprintf (tfp, "%s", info_ptr->text[i].key);
1375- for (j = strlen (info_ptr->text[i].key) ; j < 15 ; j++)
1376+ if (text[i].key[j] != ' ') {
1377+ fprintf (tfp, "%s", text[i].key);
1378+ for (j = strlen (text[i].key) ; j < 15 ; j++)
1379 putc (' ', tfp);
1380 } else {
1381- fprintf (tfp, "\"%s\"", info_ptr->text[i].key);
1382- for (j = strlen (info_ptr->text[i].key) ; j < 13 ; j++)
1383+ fprintf (tfp, "\"%s\"", text[i].key);
1384+ for (j = strlen (text[i].key) ; j < 13 ; j++)
1385 putc (' ', tfp);
1386 }
1387 putc (' ', tfp); /* at least one space between key and text */
1388
1389- for (j = 0 ; j < info_ptr->text[i].text_length ; j++) {
1390- putc (info_ptr->text[i].text[j], tfp);
1391- if (info_ptr->text[i].text[j] == '\n')
1392+ for (j = 0 ; j < text[i].text_length ; j++) {
1393+ putc (text[i].text[j], tfp);
1394+ if (text[i].text[j] == '\n')
1395 for (k = 0 ; k < 16 ; k++)
1396 putc ((int)' ', tfp);
1397 }
1398@@ -297,25 +292,28 @@ static void save_text (png_info *info_pt
1399 }
1400 }
1401
1402-static void show_time (png_info *info_ptr)
1403+static void show_time (png_struct *png_ptr, png_info *info_ptr)
1404 {
1405 static const char * const month[] = {
1406 "", "January", "February", "March", "April", "May", "June",
1407 "July", "August", "September", "October", "November", "December"
1408 };
1409
1410- if (info_ptr->valid & PNG_INFO_tIME) {
1411- if (info_ptr->mod_time.month < 1 ||
1412- info_ptr->mod_time.month >= ARRAY_SIZE(month)) {
1413+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tIME)) {
1414+ png_timep mod_timep;
1415+
1416+ png_get_tIME(png_ptr, info_ptr, &mod_timep);
1417+ if (mod_timep->month < 1 ||
1418+ mod_timep->month >= ARRAY_SIZE(month)) {
1419 pm_message("tIME chunk in PNG input is invalid; "
1420 "modification time of image is unknown. "
1421 "The month value, which should be in the range "
1422- "1-12, is %u", info_ptr->mod_time.month);
1423+ "1-12, is %u", mod_timep->month);
1424 } else
1425 pm_message ("modification time: %02d %s %d %02d:%02d:%02d",
1426- info_ptr->mod_time.day, month[info_ptr->mod_time.month],
1427- info_ptr->mod_time.year, info_ptr->mod_time.hour,
1428- info_ptr->mod_time.minute, info_ptr->mod_time.second);
1429+ mod_timep->day, month[mod_timep->month],
1430+ mod_timep->year, mod_timep->hour,
1431+ mod_timep->minute, mod_timep->second);
1432 }
1433 }
1434
1435@@ -346,12 +344,12 @@ static void pngtopnm_error_handler (png_
1436
1437
1438 static void
1439-dump_png_info(png_info *info_ptr) {
1440+dump_png_info(png_struct *png_ptr, png_info *info_ptr) {
1441
1442 const char *type_string;
1443 const char *filter_string;
1444
1445- switch (info_ptr->color_type) {
1446+ switch (png_get_color_type(png_ptr, info_ptr)) {
1447 case PNG_COLOR_TYPE_GRAY:
1448 type_string = "gray";
1449 break;
1450@@ -373,90 +371,106 @@ dump_png_info(png_info *info_ptr) {
1451 break;
1452 }
1453
1454- switch (info_ptr->filter_type) {
1455+ switch (png_get_filter_type(png_ptr, info_ptr)) {
1456 case PNG_FILTER_TYPE_BASE:
1457 asprintfN(&filter_string, "base filter");
1458 break;
1459 default:
1460 asprintfN(&filter_string, "unknown filter type %d",
1461- info_ptr->filter_type);
1462+ png_get_filter_type(png_ptr, info_ptr));
1463 }
1464
1465+ {
1466+ png_uint_32 width, height;
1467+ int bit_depth;
1468+ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, NULL, NULL, NULL, NULL);
1469 pm_message("reading a %ldw x %ldh image, %d bit%s",
1470- info_ptr->width, info_ptr->height,
1471- info_ptr->bit_depth, info_ptr->bit_depth > 1 ? "s" : "");
1472+ (long)width, (long)height,
1473+ bit_depth, bit_depth > 1 ? "s" : "");
1474+ }
1475 pm_message("%s, %s, %s",
1476 type_string,
1477- info_ptr->interlace_type ?
1478+ png_get_interlace_type(png_ptr, info_ptr) ?
1479 "Adam7 interlaced" : "not interlaced",
1480 filter_string);
1481+ {
1482+ png_color_16p bkgp;
1483+ if(png_get_bKGD(png_ptr, info_ptr, &bkgp) && (bkgp != NULL))
1484 pm_message("background {index, gray, red, green, blue} = "
1485 "{%d, %d, %d, %d, %d}",
1486- info_ptr->background.index,
1487- info_ptr->background.gray,
1488- info_ptr->background.red,
1489- info_ptr->background.green,
1490- info_ptr->background.blue);
1491+ bkgp->index,
1492+ bkgp->gray,
1493+ bkgp->red,
1494+ bkgp->green,
1495+ bkgp->blue);
1496+ }
1497
1498 strfree(filter_string);
1499
1500- if (info_ptr->valid & PNG_INFO_tRNS)
1501+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
1502+ int num_trans;
1503+ png_get_tRNS(png_ptr, info_ptr, NULL, &num_trans, NULL);
1504 pm_message("tRNS chunk (transparency): %u entries",
1505- info_ptr->num_trans);
1506- else
1507+ num_trans);
1508+ } else
1509 pm_message("tRNS chunk (transparency): not present");
1510
1511- if (info_ptr->valid & PNG_INFO_gAMA)
1512- pm_message("gAMA chunk (image gamma): gamma = %4.2f", info_ptr->gamma);
1513- else
1514+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
1515+ double gamma;
1516+ png_get_gAMA(png_ptr, info_ptr, &gamma);
1517+ pm_message("gAMA chunk (image gamma): gamma = %4.2f", gamma);
1518+ } else
1519 pm_message("gAMA chunk (image gamma): not present");
1520
1521- if (info_ptr->valid & PNG_INFO_sBIT)
1522+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
1523 pm_message("sBIT chunk: present");
1524 else
1525 pm_message("sBIT chunk: not present");
1526
1527- if (info_ptr->valid & PNG_INFO_cHRM)
1528+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_cHRM))
1529 pm_message("cHRM chunk: present");
1530 else
1531 pm_message("cHRM chunk: not present");
1532
1533- if (info_ptr->valid & PNG_INFO_PLTE)
1534- pm_message("PLTE chunk: %d entries", info_ptr->num_palette);
1535- else
1536+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE)) {
1537+ png_colorp palette;
1538+ int num_palette;
1539+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
1540+ pm_message("PLTE chunk: %d entries", num_palette);
1541+ } else
1542 pm_message("PLTE chunk: not present");
1543
1544- if (info_ptr->valid & PNG_INFO_bKGD)
1545+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
1546 pm_message("bKGD chunk: present");
1547 else
1548 pm_message("bKGD chunk: not present");
1549
1550- if (info_ptr->valid & PNG_INFO_hIST)
1551+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_hIST))
1552 pm_message("hIST chunk: present");
1553 else
1554 pm_message("hIST chunk: not present");
1555
1556- if (info_ptr->valid & PNG_INFO_pHYs)
1557+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs))
1558 pm_message("pHYs chunk: present");
1559 else
1560 pm_message("pHYs chunk: not present");
1561
1562- if (info_ptr->valid & PNG_INFO_oFFs)
1563+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_oFFs))
1564 pm_message("oFFs chunk: present");
1565 else
1566 pm_message("oFFs chunk: not present");
1567
1568- if (info_ptr->valid & PNG_INFO_tIME)
1569+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tIME))
1570 pm_message("tIME chunk: present");
1571 else
1572 pm_message("tIME chunk: not present");
1573
1574- if (info_ptr->valid & PNG_INFO_pCAL)
1575+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pCAL))
1576 pm_message("pCAL chunk: present");
1577 else
1578 pm_message("pCAL chunk: not present");
1579
1580- if (info_ptr->valid & PNG_INFO_sRGB)
1581+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sRGB))
1582 pm_message("sRGB chunk: present");
1583 else
1584 pm_message("sRGB chunk: not present");
1585@@ -465,44 +479,50 @@ dump_png_info(png_info *info_ptr) {
1586
1587
1588 static unsigned int
1589-computePngLineSize(png_info * const pngInfoP) {
1590-
1591- unsigned int const bytesPerSample = pngInfoP->bit_depth == 16 ? 2 : 1;
1592+computePngLineSize(png_struct * const pngP, png_info * const pngInfoP) {
1593
1594+ png_uint_32 width;
1595+ int bit_depth, color_type;
1596+ unsigned int bytesPerSample;
1597 unsigned int samplesPerPixel;
1598
1599- switch (pngInfoP->color_type) {
1600+ png_get_IHDR(pngP, pngInfoP, &width, NULL, &bit_depth, &color_type, NULL, NULL, NULL);
1601+ bytesPerSample = (bit_depth == 16) ? 2 : 1;
1602+
1603+ switch (color_type) {
1604 case PNG_COLOR_TYPE_GRAY_ALPHA: samplesPerPixel = 2; break;
1605 case PNG_COLOR_TYPE_RGB: samplesPerPixel = 3; break;
1606 case PNG_COLOR_TYPE_RGB_ALPHA: samplesPerPixel = 4; break;
1607 default: samplesPerPixel = 1;
1608 }
1609
1610- if (UINT_MAX / bytesPerSample / samplesPerPixel < pngInfoP->width)
1611+ if (UINT_MAX / bytesPerSample / samplesPerPixel < width)
1612 pm_error("Width %u of PNG is uncomputably large",
1613- (unsigned int)pngInfoP->width);
1614+ (unsigned int)width);
1615
1616- return pngInfoP->width * bytesPerSample * samplesPerPixel;
1617+ return width * bytesPerSample * samplesPerPixel;
1618 }
1619
1620
1621
1622 static void
1623-allocPngRaster(png_info * const pngInfoP,
1624+allocPngRaster(png_struct * const pngP,
1625+ png_info * const pngInfoP,
1626 png_byte *** const pngImageP) {
1627
1628- unsigned int const lineSize = computePngLineSize(pngInfoP);
1629+ unsigned int const lineSize = computePngLineSize(pngP, pngInfoP);
1630
1631 png_byte ** pngImage;
1632+ png_uint_32 height = png_get_image_height(pngP, pngInfoP);
1633 unsigned int row;
1634
1635- MALLOCARRAY(pngImage, pngInfoP->height);
1636+ MALLOCARRAY(pngImage, height);
1637
1638 if (pngImage == NULL)
1639 pm_error("couldn't allocate space for %u PNG raster rows",
1640- (unsigned int)pngInfoP->height);
1641+ (unsigned int)height);
1642
1643- for (row = 0; row < pngInfoP->height; ++row) {
1644+ for (row = 0; row < height; ++row) {
1645 MALLOCARRAY(pngImage[row], lineSize);
1646 if (pngImage[row] == NULL)
1647 pm_error("couldn't allocate space for %uth row of PNG raster",
1648@@ -515,11 +535,12 @@ allocPngRaster(png_info * const pngInf
1649
1650 static void
1651 freePngRaster(png_byte ** const pngRaster,
1652+ png_struct* const pngP,
1653 png_info * const pngInfoP) {
1654
1655 unsigned int row;
1656
1657- for (row = 0; row < pngInfoP->height; ++row)
1658+ for (row = 0; row < png_get_image_height(pngP, pngInfoP); ++row)
1659 free(pngRaster[row]);
1660
1661 free(pngRaster);
1662@@ -529,6 +550,7 @@ freePngRaster(png_byte ** const pngRaste
1663
1664 static bool
1665 isTransparentColor(pngcolor const color,
1666+ png_struct * const pngP,
1667 png_info * const pngInfoP,
1668 double const totalgamma) {
1669 /*----------------------------------------------------------------------------
1670@@ -539,8 +561,9 @@ isTransparentColor(pngcolor const colo
1671 -----------------------------------------------------------------------------*/
1672 bool retval;
1673
1674- if (pngInfoP->valid & PNG_INFO_tRNS) {
1675- const png_color_16 * const transColorP = &pngInfoP->trans_values;
1676+ if (png_get_valid(pngP, pngInfoP, PNG_INFO_tRNS)) {
1677+ png_color_16 * transColorP;
1678+ png_get_tRNS(pngP, pngInfoP, NULL, NULL, &transColorP);
1679
1680 /* It seems odd that libpng lets you get gamma-corrected pixel
1681 values, but not gamma-corrected transparency or background
1682@@ -556,7 +579,7 @@ isTransparentColor(pngcolor const colo
1683 pixels, and just do it ourselves.
1684 */
1685
1686- switch (pngInfoP->color_type) {
1687+ switch (png_get_color_type(pngP, pngInfoP)) {
1688 case PNG_COLOR_TYPE_GRAY:
1689 retval = color.r == gamma_correct(transColorP->gray, totalgamma);
1690 break;
1691@@ -603,9 +626,11 @@ setupGammaCorrection(png_struct * const
1692 *totalgammaP = -1.0;
1693 else {
1694 float imageGamma;
1695- if (info_ptr->valid & PNG_INFO_gAMA)
1696- imageGamma = info_ptr->gamma;
1697- else {
1698+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
1699+ double gamma;
1700+ png_get_gAMA(png_ptr, info_ptr, &gamma);
1701+ imageGamma = gamma;
1702+ } else {
1703 if (verbose)
1704 pm_message("PNG doesn't specify image gamma. Assuming 1.0");
1705 imageGamma = 1.0;
1706@@ -623,7 +648,7 @@ setupGammaCorrection(png_struct * const
1707 /* in case of gamma-corrections, sBIT's as in the
1708 PNG-file are not valid anymore
1709 */
1710- info_ptr->valid &= ~PNG_INFO_sBIT;
1711+ png_set_invalid(png_ptr, info_ptr, PNG_INFO_sBIT);
1712 if (verbose)
1713 pm_message("image gamma is %4.2f, "
1714 "converted for display gamma of %4.2f",
1715@@ -635,20 +660,23 @@ setupGammaCorrection(png_struct * const
1716
1717
1718 static bool
1719-paletteHasPartialTransparency(png_info * const info_ptr) {
1720+paletteHasPartialTransparency(png_struct * const png_ptr, png_info * const info_ptr) {
1721
1722 bool retval;
1723
1724- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
1725- if (info_ptr->valid & PNG_INFO_tRNS) {
1726+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
1727+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
1728 bool foundGray;
1729 unsigned int i;
1730+ int num_trans;
1731+ png_bytep trans_alpha;
1732+ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
1733
1734 for (i = 0, foundGray = FALSE;
1735- i < info_ptr->num_trans && !foundGray;
1736+ i < num_trans && !foundGray;
1737 ++i) {
1738- if (info_ptr->TRANS_ALPHA[i] != 0 &&
1739- info_ptr->TRANS_ALPHA[i] != maxval) {
1740+ if (trans_alpha[i] != 0 &&
1741+ trans_alpha[i] != maxval) {
1742 foundGray = TRUE;
1743 }
1744 }
1745@@ -664,34 +692,44 @@ paletteHasPartialTransparency(png_info *
1746
1747
1748 static void
1749-getComponentSbitFg(png_info * const pngInfoP,
1750+getComponentSbitFg(png_struct * const pngP,
1751+ png_info * const pngInfoP,
1752 png_byte * const fgSbitP,
1753 bool * const notUniformP) {
1754
1755- if (pngInfoP->color_type == PNG_COLOR_TYPE_RGB ||
1756- pngInfoP->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
1757- pngInfoP->color_type == PNG_COLOR_TYPE_PALETTE) {
1758- if (pngInfoP->sig_bit.red == pngInfoP->sig_bit.blue &&
1759- pngInfoP->sig_bit.red == pngInfoP->sig_bit.green) {
1760+ int color_type = png_get_color_type(pngP, pngInfoP);
1761+ png_color_8p sig_bit;
1762+ png_get_sBIT(pngP, pngInfoP, &sig_bit);
1763+
1764+ if (color_type == PNG_COLOR_TYPE_RGB ||
1765+ color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
1766+ color_type == PNG_COLOR_TYPE_PALETTE) {
1767+
1768+ if (sig_bit->red == sig_bit->blue &&
1769+ sig_bit->red == sig_bit->green) {
1770 *notUniformP = false;
1771- *fgSbitP = pngInfoP->sig_bit.red;
1772+ *fgSbitP = sig_bit->red;
1773 } else
1774 *notUniformP = true;
1775 } else {
1776 /* It has only a gray channel so it's obviously uniform */
1777 *notUniformP = false;
1778- *fgSbitP = pngInfoP->sig_bit.gray;
1779+ *fgSbitP = sig_bit->gray;
1780 }
1781 }
1782
1783
1784
1785 static void
1786-getComponentSbit(png_info * const pngInfoP,
1787+getComponentSbit(png_struct * const pngP,
1788+ png_info * const pngInfoP,
1789 enum alpha_handling const alphaHandling,
1790 png_byte * const componentSbitP,
1791 bool * const notUniformP) {
1792
1793+ png_color_8p sig_bit;
1794+ png_get_sBIT(pngP, pngInfoP, &sig_bit);
1795+
1796 switch (alphaHandling) {
1797
1798 case ALPHA_ONLY:
1799@@ -699,26 +737,26 @@ getComponentSbit(png_info * con
1800 the alpha Sbit
1801 */
1802 *notUniformP = false;
1803- *componentSbitP = pngInfoP->sig_bit.alpha;
1804+ *componentSbitP = sig_bit->alpha;
1805 break;
1806 case ALPHA_NONE:
1807 case ALPHA_MIX:
1808 /* We aren't going to produce an alpha channel, so we care only
1809 about the uniformity of the foreground channels.
1810 */
1811- getComponentSbitFg(pngInfoP, componentSbitP, notUniformP);
1812+ getComponentSbitFg(pngP, pngInfoP, componentSbitP, notUniformP);
1813 break;
1814 case ALPHA_IN: {
1815 /* We care about both the foreground and the alpha */
1816 bool fgNotUniform;
1817 png_byte fgSbit;
1818
1819- getComponentSbitFg(pngInfoP, &fgSbit, &fgNotUniform);
1820+ getComponentSbitFg(pngP, pngInfoP, &fgSbit, &fgNotUniform);
1821
1822 if (fgNotUniform)
1823 *notUniformP = true;
1824 else {
1825- if (fgSbit == pngInfoP->sig_bit.alpha) {
1826+ if (fgSbit == sig_bit->alpha) {
1827 *notUniformP = false;
1828 *componentSbitP = fgSbit;
1829 } else
1830@@ -731,7 +769,8 @@ getComponentSbit(png_info * con
1831
1832
1833 static void
1834-shiftPalette(png_info * const pngInfoP,
1835+shiftPalette(png_struct * const pngP,
1836+ png_info * const pngInfoP,
1837 unsigned int const shift) {
1838 /*----------------------------------------------------------------------------
1839 Shift every component of every color in the PNG palette right by
1840@@ -744,11 +783,14 @@ shiftPalette(png_info * const pngInfoP
1841 shift);
1842 else {
1843 unsigned int i;
1844-
1845- for (i = 0; i < pngInfoP->num_palette; ++i) {
1846- pngInfoP->palette[i].red >>= (8 - shift);
1847- pngInfoP->palette[i].green >>= (8 - shift);
1848- pngInfoP->palette[i].blue >>= (8 - shift);
1849+ int num_palette;
1850+ png_colorp palette;
1851+ png_get_PLTE(pngP, pngInfoP, &palette, &num_palette);
1852+
1853+ for (i = 0; i < num_palette; ++i) {
1854+ palette[i].red >>= (8 - shift);
1855+ palette[i].green >>= (8 - shift);
1856+ palette[i].blue >>= (8 - shift);
1857 }
1858 }
1859 }
1860@@ -782,12 +824,12 @@ computeMaxvalFromSbit(png_struct *
1861 Meaningless if they aren't all the same (i.e. 'notUniform')
1862 */
1863
1864- getComponentSbit(pngInfoP, alphaHandling, &componentSigBit, &notUniform);
1865+ getComponentSbit(pngP, pngInfoP, alphaHandling, &componentSigBit, &notUniform);
1866
1867 if (notUniform) {
1868 pm_message("This program cannot handle "
1869 "different bit depths for color channels");
1870- pm_message("writing file with %u bit resolution", pngInfoP->bit_depth);
1871+ pm_message("writing file with %u bit resolution", png_get_bit_depth(pngP, pngInfoP));
1872 *succeededP = false;
1873 *errorlevelP = PNMTOPNG_WARNING_LEVEL;
1874 } else if (componentSigBit > 15) {
1875@@ -797,22 +839,26 @@ computeMaxvalFromSbit(png_struct *
1876 *succeededP = false;
1877 *errorlevelP = PNMTOPNG_WARNING_LEVEL;
1878 } else {
1879+ int color_type = png_get_color_type(pngP, pngInfoP);
1880 if (alphaHandling == ALPHA_MIX &&
1881- (pngInfoP->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
1882- pngInfoP->color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
1883- paletteHasPartialTransparency(pngInfoP)))
1884+ (color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
1885+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
1886+ paletteHasPartialTransparency(pngP, pngInfoP)))
1887 *succeededP = false;
1888 else {
1889- if (componentSigBit < pngInfoP->bit_depth) {
1890+ if (componentSigBit < png_get_bit_depth(pngP, pngInfoP)) {
1891 pm_message("Image has fewer significant bits, "
1892 "writing file with %u bits", componentSigBit);
1893 *maxvalP = (1l << componentSigBit) - 1;
1894 *succeededP = true;
1895
1896- if (pngInfoP->color_type == PNG_COLOR_TYPE_PALETTE)
1897- shiftPalette(pngInfoP, componentSigBit);
1898- else
1899- png_set_shift(pngP, &pngInfoP->sig_bit);
1900+ if (color_type == PNG_COLOR_TYPE_PALETTE)
1901+ shiftPalette(pngP, pngInfoP, componentSigBit);
1902+ else {
1903+ png_color_8p sig_bit;
1904+ png_get_sBIT(pngP, pngInfoP, &sig_bit);
1905+ png_set_shift(pngP, sig_bit);
1906+ }
1907 } else
1908 *succeededP = false;
1909 }
1910@@ -838,22 +884,23 @@ setupSignificantBits(png_struct *
1911 -----------------------------------------------------------------------------*/
1912 bool gotItFromSbit;
1913
1914- if (pngInfoP->valid & PNG_INFO_sBIT)
1915+ if (png_get_valid(pngP, pngInfoP, PNG_INFO_sBIT))
1916 computeMaxvalFromSbit(pngP, pngInfoP, alphaHandling,
1917 maxvalP, &gotItFromSbit, errorlevelP);
1918 else
1919 gotItFromSbit = false;
1920
1921 if (!gotItFromSbit) {
1922- if (pngInfoP->color_type == PNG_COLOR_TYPE_PALETTE) {
1923+ int color_type = png_get_color_type(pngP, pngInfoP);
1924+ if (color_type == PNG_COLOR_TYPE_PALETTE) {
1925 if (alphaHandling == ALPHA_ONLY) {
1926- if (pngInfoP->color_type == PNG_COLOR_TYPE_GRAY ||
1927- pngInfoP->color_type == PNG_COLOR_TYPE_RGB)
1928+ if (color_type == PNG_COLOR_TYPE_GRAY ||
1929+ color_type == PNG_COLOR_TYPE_RGB)
1930 /* The alpha mask will be all opaque, so maxval 1
1931 is plenty
1932 */
1933 *maxvalP = 1;
1934- else if (paletteHasPartialTransparency(pngInfoP))
1935+ else if (paletteHasPartialTransparency(pngP, pngInfoP))
1936 /* Use same maxval as PNG transparency palette for
1937 simplicity
1938 */
1939@@ -865,7 +912,7 @@ setupSignificantBits(png_struct *
1940 /* Use same maxval as PNG palette for simplicity */
1941 *maxvalP = 255;
1942 } else {
1943- *maxvalP = (1l << pngInfoP->bit_depth) - 1;
1944+ *maxvalP = (1l << png_get_bit_depth(pngP, pngInfoP)) - 1;
1945 }
1946 }
1947 }
1948@@ -873,22 +920,27 @@ setupSignificantBits(png_struct *
1949
1950
1951 static bool
1952-imageHasColor(png_info * const info_ptr) {
1953+imageHasColor(png_struct * const png_ptr, png_info * const info_ptr) {
1954
1955 bool retval;
1956+ int color_type = png_get_color_type(png_ptr, info_ptr);
1957
1958- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
1959- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
1960+ if (color_type == PNG_COLOR_TYPE_GRAY ||
1961+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
1962
1963 retval = FALSE;
1964- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
1965+ else if (color_type == PNG_COLOR_TYPE_PALETTE) {
1966 bool foundColor;
1967 unsigned int i;
1968+ int num_palette;
1969+ png_colorp palette;
1970+
1971+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
1972
1973 for (i = 0, foundColor = FALSE;
1974- i < info_ptr->num_palette && !foundColor;
1975+ i < num_palette && !foundColor;
1976 ++i) {
1977- if (iscolor(info_ptr->palette[i]))
1978+ if (iscolor(palette[i]))
1979 foundColor = TRUE;
1980 }
1981 retval = foundColor;
1982@@ -901,7 +953,8 @@ imageHasColor(png_info * const info_ptr)
1983
1984
1985 static void
1986-determineOutputType(png_info * const pngInfoP,
1987+determineOutputType(png_struct * const pngP,
1988+ png_info * const pngInfoP,
1989 enum alpha_handling const alphaHandling,
1990 pngcolor const bgColor,
1991 xelval const maxval,
1992@@ -916,7 +969,7 @@ determineOutputType(png_info *
1993 } else {
1994 /* The output is a normal Netpbm image */
1995 bool const outputIsColor =
1996- imageHasColor(pngInfoP) || !isGrayscale(bgColor);
1997+ imageHasColor(pngP, pngInfoP) || !isGrayscale(bgColor);
1998
1999 if (alphaHandling == ALPHA_IN) {
2000 *formatP = PAM_FORMAT;
2001@@ -942,7 +995,8 @@ determineOutputType(png_info *
2002
2003
2004 static void
2005-getBackgroundColor(png_info * const info_ptr,
2006+getBackgroundColor(png_struct * const png_ptr,
2007+ png_info * const info_ptr,
2008 const char * const requestedColor,
2009 float const totalgamma,
2010 xelval const maxval,
2011@@ -964,19 +1018,26 @@ getBackgroundColor(png_info * const in
2012 bgColorP->g = PPM_GETG(backcolor);
2013 bgColorP->b = PPM_GETB(backcolor);
2014
2015- } else if (info_ptr->valid & PNG_INFO_bKGD) {
2016+ } else if (png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD)) {
2017+ png_color_16p background;
2018+ png_get_bKGD(png_ptr, info_ptr, &background);
2019 /* didn't manage to get libpng to work (bugs?) concerning background
2020 processing, therefore we do our own.
2021 */
2022- switch (info_ptr->color_type) {
2023+ switch (png_get_color_type(png_ptr, info_ptr)) {
2024 case PNG_COLOR_TYPE_GRAY:
2025 case PNG_COLOR_TYPE_GRAY_ALPHA:
2026 bgColorP->r = bgColorP->g = bgColorP->b =
2027- gamma_correct(info_ptr->background.gray, totalgamma);
2028+ gamma_correct(background->gray, totalgamma);
2029 break;
2030 case PNG_COLOR_TYPE_PALETTE: {
2031- png_color const rawBgcolor =
2032- info_ptr->palette[info_ptr->background.index];
2033+ png_color rawBgcolor;
2034+ png_colorp palette;
2035+ int num_palette;
2036+
2037+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
2038+ rawBgcolor =
2039+ palette[background->index];
2040 bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
2041 bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
2042 bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma);
2043@@ -984,7 +1045,7 @@ getBackgroundColor(png_info * const in
2044 break;
2045 case PNG_COLOR_TYPE_RGB:
2046 case PNG_COLOR_TYPE_RGB_ALPHA: {
2047- png_color_16 const rawBgcolor = info_ptr->background;
2048+ png_color_16 const rawBgcolor = *background;
2049
2050 bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
2051 bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
2052@@ -999,13 +1060,14 @@ getBackgroundColor(png_info * const in
2053
2054
2055
2056-#define GET_PNG_VAL(p) get_png_val(&(p), pngInfoP->bit_depth)
2057+#define GET_PNG_VAL(p) get_png_val(&(p), png_get_bit_depth(pngP, pngInfoP))
2058
2059
2060
2061 static void
2062 makeTupleRow(const struct pam * const pamP,
2063 const tuple * const tuplerow,
2064+ png_struct * const pngP,
2065 png_info * const pngInfoP,
2066 const png_byte * const pngRasterRow,
2067 pngcolor const bgColor,
2068@@ -1016,13 +1078,13 @@ makeTupleRow(const struct pam * const p
2069 unsigned int col;
2070
2071 pngPixelP = &pngRasterRow[0]; /* initial value */
2072- for (col = 0; col < pngInfoP->width; ++col) {
2073- switch (pngInfoP->color_type) {
2074+ for (col = 0; col < png_get_image_width(pngP, pngInfoP); ++col) {
2075+ switch (png_get_color_type(pngP, pngInfoP)) {
2076 case PNG_COLOR_TYPE_GRAY: {
2077 pngcolor fgColor;
2078 fgColor.r = fgColor.g = fgColor.b = GET_PNG_VAL(pngPixelP);
2079 setTuple(pamP, tuplerow[col], fgColor, bgColor, alphaHandling,
2080- isTransparentColor(fgColor, pngInfoP, totalgamma) ?
2081+ isTransparentColor(fgColor, pngP, pngInfoP, totalgamma) ?
2082 0 : maxval);
2083 }
2084 break;
2085@@ -1040,18 +1102,26 @@ makeTupleRow(const struct pam * const p
2086
2087 case PNG_COLOR_TYPE_PALETTE: {
2088 png_uint_16 const index = GET_PNG_VAL(pngPixelP);
2089- png_color const paletteColor = pngInfoP->palette[index];
2090-
2091+ png_color paletteColor;
2092+ bool transValid = png_get_valid(pngP, pngInfoP, PNG_INFO_tRNS);
2093+ png_bytep trans_alpha;
2094+ int num_trans, num_palette;
2095+ png_colorp palette;
2096 pngcolor fgColor;
2097
2098+ png_get_PLTE(pngP, pngInfoP, &palette, &num_palette);
2099+ paletteColor = palette[index];
2100+
2101 fgColor.r = paletteColor.red;
2102 fgColor.g = paletteColor.green;
2103 fgColor.b = paletteColor.blue;
2104
2105+ if (transValid)
2106+ png_get_tRNS(pngP, pngInfoP, &trans_alpha, &num_trans, NULL);
2107 setTuple(pamP, tuplerow[col], fgColor, bgColor, alphaHandling,
2108- (pngInfoP->valid & PNG_INFO_tRNS) &&
2109- index < pngInfoP->num_trans ?
2110- pngInfoP->TRANS_ALPHA[index] : maxval);
2111+ transValid &&
2112+ index < num_trans ?
2113+ trans_alpha[index] : maxval);
2114 }
2115 break;
2116
2117@@ -1062,7 +1132,7 @@ makeTupleRow(const struct pam * const p
2118 fgColor.g = GET_PNG_VAL(pngPixelP);
2119 fgColor.b = GET_PNG_VAL(pngPixelP);
2120 setTuple(pamP, tuplerow[col], fgColor, bgColor, alphaHandling,
2121- isTransparentColor(fgColor, pngInfoP, totalgamma) ?
2122+ isTransparentColor(fgColor, pngP, pngInfoP, totalgamma) ?
2123 0 : maxval);
2124 }
2125 break;
2126@@ -1081,7 +1151,7 @@ makeTupleRow(const struct pam * const p
2127 break;
2128
2129 default:
2130- pm_error("unknown PNG color type: %d", pngInfoP->color_type);
2131+ pm_error("unknown PNG color type: %d", png_get_color_type(pngP, pngInfoP));
2132 }
2133 }
2134 }
2135@@ -1115,6 +1185,7 @@ reportOutputFormat(const struct pam * co
2136
2137 static void
2138 writeNetpbm(struct pam * const pamP,
2139+ png_struct * const pngP,
2140 png_info * const pngInfoP,
2141 png_byte ** const pngRaster,
2142 pngcolor const bgColor,
2143@@ -1141,8 +1212,8 @@ writeNetpbm(struct pam * const pa
2144
2145 tuplerow = pnm_allocpamrow(pamP);
2146
2147- for (row = 0; row < pngInfoP->height; ++row) {
2148- makeTupleRow(pamP, tuplerow, pngInfoP, pngRaster[row], bgColor,
2149+ for (row = 0; row < png_get_image_height(pngP, pngInfoP); ++row) {
2150+ makeTupleRow(pamP, tuplerow, pngP, pngInfoP, pngRaster[row], bgColor,
2151 alphaHandling, totalgamma);
2152
2153 pnm_writepamrow(pamP, tuplerow);
2154@@ -1186,9 +1257,9 @@ convertpng(FILE * const ifp,
2155 png_set_sig_bytes (png_ptr, SIG_CHECK_SIZE);
2156 png_read_info (png_ptr, info_ptr);
2157
2158- allocPngRaster(info_ptr, &png_image);
2159+ allocPngRaster(png_ptr, info_ptr, &png_image);
2160
2161- if (info_ptr->bit_depth < 8)
2162+ if (png_get_bit_depth(png_ptr, info_ptr) < 8)
2163 png_set_packing (png_ptr);
2164
2165 setupGammaCorrection(png_ptr, info_ptr, cmdline.gamma, &totalgamma);
2166@@ -1196,7 +1267,7 @@ convertpng(FILE * const ifp,
2167 setupSignificantBits(png_ptr, info_ptr, cmdline.alpha,
2168 &maxval, errorlevelP);
2169
2170- getBackgroundColor(info_ptr, cmdline.background, totalgamma, maxval,
2171+ getBackgroundColor(png_ptr, info_ptr, cmdline.background, totalgamma, maxval,
2172 &bgColor);
2173
2174 png_read_image(png_ptr, png_image);
2175@@ -1207,16 +1278,19 @@ convertpng(FILE * const ifp,
2176 completes. That's because it comes from chunks that are at the
2177 end of the stream.
2178 */
2179- dump_png_info(info_ptr);
2180+ dump_png_info(png_ptr, info_ptr);
2181
2182 if (cmdline.time)
2183- show_time(info_ptr);
2184+ show_time(png_ptr, info_ptr);
2185 if (tfp)
2186- save_text(info_ptr, tfp);
2187+ save_text(png_ptr, info_ptr, tfp);
2188+
2189+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs)) {
2190+ float r;
2191+ png_uint_32 x_pixels_per_unit, y_pixels_per_unit;
2192
2193- if (info_ptr->valid & PNG_INFO_pHYs) {
2194- float const r =
2195- (float)info_ptr->x_pixels_per_unit / info_ptr->y_pixels_per_unit;
2196+ png_get_pHYs(png_ptr, info_ptr, &x_pixels_per_unit, &y_pixels_per_unit, NULL);
2197+ r = (float)x_pixels_per_unit / y_pixels_per_unit;
2198 if (r != 1.0) {
2199 pm_message ("warning - non-square pixels; "
2200 "to fix do a 'pamscale -%cscale %g'",
2201@@ -1230,18 +1304,18 @@ convertpng(FILE * const ifp,
2202 pam.len = PAM_STRUCT_SIZE(tuple_type);
2203 pam.file = stdout;
2204 pam.plainformat = 0;
2205- pam.height = info_ptr->height;
2206- pam.width = info_ptr->width;
2207+ pam.height = png_get_image_height(png_ptr, info_ptr);
2208+ pam.width = png_get_image_width(png_ptr, info_ptr);
2209 pam.maxval = maxval;
2210
2211- determineOutputType(info_ptr, cmdline.alpha, bgColor, maxval,
2212+ determineOutputType(png_ptr, info_ptr, cmdline.alpha, bgColor, maxval,
2213 &pam.format, &pam.depth, pam.tuple_type);
2214
2215- writeNetpbm(&pam, info_ptr, png_image, bgColor, cmdline.alpha, totalgamma);
2216+ writeNetpbm(&pam, png_ptr, info_ptr, png_image, bgColor, cmdline.alpha, totalgamma);
2217
2218 fflush(stdout);
2219
2220- freePngRaster(png_image, info_ptr);
2221+ freePngRaster(png_image, png_ptr, info_ptr);
2222
2223 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
2224 }
A library for handling different graphics file formats
This page took 0.345898 seconds and 4 git commands to generate.