[packages/netpbm] - updated to 10.47.61 (now latest superstable) - updated build patch
qboosh
qboosh at pld-linux.org
Sat Jun 11 13:07:40 CEST 2016
commit 0418bf0c78c2eacf8688ab7272ef1f0765b290bf
Author: Jakub Bogusz <qboosh at pld-linux.org>
Date: Sat Jun 11 13:07:58 2016 +0200
- updated to 10.47.61 (now latest superstable)
- updated build patch
netpbm-build.patch | 1905 +++++++++++++++++++++++++++++++++++++---------------
netpbm.spec | 37 +-
2 files changed, 1376 insertions(+), 566 deletions(-)
---
diff --git a/netpbm.spec b/netpbm.spec
index aad9668..dc834bf 100644
--- a/netpbm.spec
+++ b/netpbm.spec
@@ -10,14 +10,14 @@ Summary(pt_BR.UTF-8): Ferramentas para manipular arquivos graficos nos formatos
Summary(ru.UTF-8): Набор библиотек для работы с различными графическими файлами
Summary(uk.UTF-8): Набір бібліотек для роботи з різними графічними файлами
Name: netpbm
-Version: 10.35.94
-Release: 2
+Version: 10.47.61
+Release: 1
License: Freeware
Group: Libraries
# svn export https://netpbm.svn.sourceforge.net/svnroot/netpbm/stable netpbm-%{version} (where version from doc/HISTORY)
# svn export https://netpbm.svn.sourceforge.net/svnroot/netpbm/userguide netpbm-%{version}/userguide
Source0: http://downloads.sourceforge.net/netpbm/%{name}-%{version}.tgz
-# Source0-md5: 72323677c5f2d7e2ff99caee8e0d8b41
+# Source0-md5: a5d2ec8acc99f60e5b92a720ed292c3e
Source1: http://www.mif.pg.gda.pl/homepages/ankry/man-PLD/%{name}-non-english-man-pages.tar.bz2
# Source1-md5: 8fb174f8da02ea01bf72a9dc61be10f1
Source2: %{name}-docs-20030520.tar.bz2
@@ -31,7 +31,7 @@ BuildRequires: jbigkit-devel
BuildRequires: libjpeg-devel >= 7
BuildRequires: libpng-devel
BuildRequires: libtiff-devel
-BuildRequires: libxml2-devel
+BuildRequires: libxml2-devel >= 2
BuildRequires: perl-base
BuildRequires: perl-modules
%{?with_svga:BuildRequires: svgalib-devel}
@@ -266,15 +266,15 @@ rm -rf PKG
%{__rm} PKG/bin/doc.url
cp -df PKG/bin/* $RPM_BUILD_ROOT%{_bindir}
cp -df PKG/lib/* $RPM_BUILD_ROOT%{_libdir}
-install PKG/link/*.a $RPM_BUILD_ROOT%{_libdir}
-install PKG/include/*.h $RPM_BUILD_ROOT%{_includedir}
-install PKG/man/man1/*.1 $RPM_BUILD_ROOT%{_mandir}/man1
-install PKG/man/man3/*.3 $RPM_BUILD_ROOT%{_mandir}/man3
-install PKG/man/man5/*.5 $RPM_BUILD_ROOT%{_mandir}/man5
+cp -p PKG/link/*.a $RPM_BUILD_ROOT%{_libdir}
+cp -pr PKG/include/netpbm $RPM_BUILD_ROOT%{_includedir}
+cp -p PKG/man/man1/*.1 $RPM_BUILD_ROOT%{_mandir}/man1
+cp -p PKG/man/man3/*.3 $RPM_BUILD_ROOT%{_mandir}/man3
+cp -p PKG/man/man5/*.5 $RPM_BUILD_ROOT%{_mandir}/man5
# Install the static-only librle.a
-install urt/{rle,rle_config}.h $RPM_BUILD_ROOT%{_includedir}
-install urt/librle.a $RPM_BUILD_ROOT%{_libdir}
+cp -p urt/{rle,rle_config}.h $RPM_BUILD_ROOT%{_includedir}
+cp -p urt/librle.a $RPM_BUILD_ROOT%{_libdir}
bzip2 -dc %{SOURCE1} | tar xf - -C $RPM_BUILD_ROOT%{_mandir}
%{__rm} $RPM_BUILD_ROOT%{_mandir}/README.netpbm-non-english-man-pages
@@ -294,18 +294,7 @@ rm -rf $RPM_BUILD_ROOT
%files devel
%defattr(644,root,root,755)
%attr(755,root,root) %{_libdir}/libnetpbm.so
-%{_includedir}/bitio.h
-%{_includedir}/colorname.h
-%{_includedir}/mallocvar.h
-%{_includedir}/nstring.h
-%{_includedir}/pam*.h
-%{_includedir}/pbm*.h
-%{_includedir}/pgm.h
-%{_includedir}/pm*.h
-%{_includedir}/pnm.h
-%{_includedir}/ppm*.h
-%{_includedir}/rle*.h
-%{_includedir}/shhopt.h
+%{_includedir}/netpbm
%{_mandir}/man3/libnetpbm.3*
%files static
@@ -315,6 +304,8 @@ rm -rf $RPM_BUILD_ROOT
%files rle-static
%defattr(644,root,root,755)
%{_libdir}/librle.a
+%{_includedir}/rle.h
+%{_includedir}/rle_config.h
%files progs
%defattr(644,root,root,755)
diff --git a/netpbm-build.patch b/netpbm-build.patch
index f4ca061..f012bc4 100644
--- a/netpbm-build.patch
+++ b/netpbm-build.patch
@@ -1,51 +1,43 @@
---- netpbm-10.35.65/converter/ppm/ppmtompeg/jpeg.c~ 2006-08-19 05:12:28.000000000 +0200
-+++ netpbm-10.35.65/converter/ppm/ppmtompeg/jpeg.c 2009-07-15 08:52:06.372101451 +0200
-@@ -469,7 +469,7 @@
- #ifdef JPEG4
- buffer_height = 8; /* could be 2, 4,8 rows high */
- #else
-- buffer_height = cinfo.max_v_samp_factor * cinfo.min_DCT_scaled_size;
-+ buffer_height = cinfo.max_v_samp_factor * cinfo.min_DCT_v_scaled_size;
- #endif
-
- for(cp=0,compptr = cinfo.comp_info;cp<cinfo.num_components;
---- netpbm-10.35.83/converter/other/pnmtopng.c.orig 2011-09-25 20:51:44.000000000 +0200
-+++ netpbm-10.35.83/converter/other/pnmtopng.c 2012-01-29 08:48:17.363289175 +0100
-@@ -61,7 +61,8 @@
+--- netpbm-10.47.61/converter/other/pnmtopng.c.orig 2016-03-27 03:38:28.000000000 +0200
++++ netpbm-10.47.61/converter/other/pnmtopng.c 2016-06-08 21:11:49.243925856 +0200
+@@ -59,7 +59,8 @@
#include <assert.h>
#include <string.h> /* strcat() */
#include <limits.h>
-#include <png.h> /* includes zlib.h and setjmp.h */
+#include <png.h> /* includes setjmp.h */
+#include <zlib.h>
+
+ #include "pm_c_util.h"
#include "pnm.h"
- #include "pngtxt.h"
- #include "shhopt.h"
-@@ -69,11 +70,6 @@
+@@ -69,14 +70,6 @@
#include "nstring.h"
#include "version.h"
+-/* A hack until we can remove direct access to png_info from the program */
-#if PNG_LIBPNG_VER >= 10400
--#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
--#error You need either an older PNG library (older than 1.4)
--#error newer Netpbm source code (at least 10.47.04)
+-#define trans_values trans_color
+-#define TRANS_ALPHA trans_alpha
+-#else
+-#define TRANS_ALPHA trans
-#endif
-
+-
struct zlibCompression {
-@@ -2098,6 +2094,7 @@
+ /* These are parameters that describe a form of zlib compression.
+@@ -2117,6 +2110,7 @@ makePngLine(png_byte * const l
gray * const alpha_mask,
colorhash_table const cht,
coloralphahash_table const caht,
-+ png_struct * const png_ptr,
++ png_struct * const png_ptr,
png_info * const info_ptr,
xelval const png_maxval,
unsigned int const depth) {
-@@ -2109,21 +2106,22 @@
+@@ -2128,21 +2122,22 @@ makePngLine(png_byte * const l
for (col = 0; col < cols; ++col) {
xel p_png;
xel const p = xelrow[col];
-+ png_byte color_type = png_get_color_type(png_ptr, info_ptr);
++ png_byte color_type = png_get_color_type(png_ptr, info_ptr);
PPM_DEPTH(p_png, p, maxval, png_maxval);
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
@@ -69,7 +61,7 @@
if (depth == 16)
*pp++ = PPM_GETR(p_png) >> 8;
*pp++ = PPM_GETR(p_png) & 0xff;
-@@ -2136,7 +2134,7 @@
+@@ -2155,7 +2150,7 @@ makePngLine(png_byte * const l
} else
pm_error("INTERNAL ERROR: undefined color_type");
@@ -78,7 +70,7 @@
int const png_alphaval = (int)
alpha_mask[col] * (float) png_maxval / maxval + 0.5;
if (depth == 16)
-@@ -2193,7 +2191,7 @@
+@@ -2212,7 +2207,7 @@ writeRaster(png_struct * const p
makePngLine(line, xelrow, cols, maxval,
alpha, alpha ? alpha_mask[row] : NULL,
@@ -87,7 +79,7 @@
png_write_row(png_ptr, line);
}
-@@ -2205,12 +2203,12 @@
+@@ -2224,12 +2219,12 @@ writeRaster(png_struct * const p
static void
doGamaChunk(struct cmdlineInfo const cmdline,
@@ -102,7 +94,7 @@
}
}
-@@ -2218,20 +2216,16 @@
+@@ -2237,20 +2232,16 @@ doGamaChunk(struct cmdlineInfo const cmd
static void
doChrmChunk(struct cmdlineInfo const cmdline,
@@ -129,7 +121,7 @@
}
}
-@@ -2239,15 +2233,13 @@
+@@ -2258,15 +2249,13 @@ doChrmChunk(struct cmdlineInfo const cmd
static void
doPhysChunk(struct cmdlineInfo const cmdline,
@@ -148,7 +140,7 @@
}
}
-@@ -2256,26 +2248,29 @@
+@@ -2275,26 +2264,29 @@ doPhysChunk(struct cmdlineInfo const cmd
static void
doTimeChunk(struct cmdlineInfo const cmdline,
@@ -162,7 +154,7 @@
- png_convert_from_time_t(&info_ptr->mod_time, cmdline.modtime);
+ png_time ptime;
+ png_convert_from_time_t(&ptime, cmdline.modtime);
-+ png_set_tIME(png_ptr, info_ptr, &ptime);
++ png_set_tIME(png_ptr, info_ptr, &ptime);
}
}
@@ -183,7 +175,7 @@
(pngMaxval > maxval || (alpha && pngMaxval > alphaMaxval))) {
/* We're writing in a bit depth that doesn't match the maxval
-@@ -2294,27 +2289,27 @@
+@@ -2313,27 +2305,27 @@ doSbitChunk(png_info * const pngInfoP,
sBIT chunk.
*/
@@ -217,11 +209,11 @@
- pm_message(" alpha bits = %d", pngInfoP->sig_bit.alpha);
+ pm_message(" alpha bits = %d", sbit.alpha);
}
-+ png_set_sBIT(png_ptr, pngInfoP, &sbit);
++ png_set_sBIT(png_ptr, pngInfoP, &sbit);
}
}
-@@ -2595,43 +2590,41 @@
+@@ -2614,43 +2606,40 @@ convertpnm(struct cmdlineInfo const cmdl
pm_error ("setjmp returns error condition (2)");
}
@@ -244,27 +236,26 @@
- if (alpha && info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
-+ if (alpha && (color_type != PNG_COLOR_TYPE_PALETTE))
++ if (alpha && color_type != PNG_COLOR_TYPE_PALETTE)
+ color_type |= PNG_COLOR_MASK_ALPHA;
- info_ptr->interlace_type = cmdline.interlace;
-+ png_set_IHDR(png_ptr, info_ptr,
-+ cols, rows, depth, color_type, 0, 0, 0);
++ png_set_IHDR(png_ptr, info_ptr, cols, rows, depth, color_type, cmdline.interlace, 0, 0);
+ }
++
++ if (cmdline.interlace)
++ png_set_interlace_handling(png_ptr);
- doGamaChunk(cmdline, info_ptr);
-+ if(cmdline.interlace)
-+ png_set_interlace_handling(png_ptr);
++ doGamaChunk(cmdline, png_ptr, info_ptr);
- doChrmChunk(cmdline, info_ptr);
-+ doGamaChunk(cmdline, png_ptr, info_ptr);
++ doChrmChunk(cmdline, png_ptr, info_ptr);
- doPhysChunk(cmdline, info_ptr);
-+ doChrmChunk(cmdline, png_ptr, info_ptr);
++ doPhysChunk(cmdline, png_ptr, info_ptr);
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
-+ doPhysChunk(cmdline, png_ptr, info_ptr);
-+
+ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
/* creating PNG palette (PLTE and tRNS chunks) */
@@ -278,19 +269,19 @@
+ png_set_PLTE(png_ptr, info_ptr, palette, palette_size);
if (trans_size > 0) {
- info_ptr->valid |= PNG_INFO_tRNS;
-- info_ptr->trans = trans;
+- info_ptr->TRANS_ALPHA = trans;
- info_ptr->num_trans = trans_size; /* omit opaque values */
+ png_set_tRNS(png_ptr, info_ptr, trans, trans_size, NULL);
}
/* creating hIST chunk */
if (cmdline.hist) {
-@@ -2657,18 +2650,17 @@
+@@ -2676,18 +2665,17 @@ convertpnm(struct cmdlineInfo const cmdl
ppm_freecolorhash(cht);
- info_ptr->valid |= PNG_INFO_hIST;
- info_ptr->hist = histogram;
-+ png_set_hIST(png_ptr, info_ptr, histogram);
++ png_set_hIST(png_ptr, info_ptr, histogram);
if (verbose)
pm_message("histogram created");
}
@@ -305,20 +296,20 @@
- info_ptr->trans_values =
- xelToPngColor_16(transcolor, maxval, png_maxval);
+ png_color_16 c = xelToPngColor_16(transcolor, maxval, png_maxval);
-+ png_set_tRNS(png_ptr, info_ptr, NULL, 0, &c);
++ png_set_tRNS(png_ptr, info_ptr, NULL, 0, &c);
}
} else {
/* This is PNG_COLOR_MASK_ALPHA. Transparency will be handled
-@@ -2676,60 +2668,58 @@
+@@ -2695,60 +2683,58 @@ convertpnm(struct cmdlineInfo const cmdl
*/
}
if (verbose) {
- if (info_ptr->valid && PNG_INFO_tRNS)
+ png_color_16p trans_colorp = NULL;
+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-+ png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_colorp);
-+ }
-+ if(trans_colorp != NULL)
++ png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_colorp);
++ }
++ if(trans_colorp != NULL)
pm_message("Transparent color {gray, red, green, blue} = "
"{%d, %d, %d, %d}",
- info_ptr->trans_values.gray,
@@ -330,7 +321,7 @@
+ trans_colorp->red,
+ trans_colorp->green,
+ trans_colorp->blue);
-+ else
++ else
pm_message("No transparent color");
}
}
@@ -346,7 +337,7 @@
} else {
- info_ptr->background =
- xelToPngColor_16(backcolor, maxval, png_maxval);
-+ bkgd = xelToPngColor_16(backcolor, maxval, png_maxval);
++ bkgd = xelToPngColor_16(backcolor, maxval, png_maxval);
if (verbose)
pm_message("Writing bKGD chunk with background color "
" {gray, red, green, blue} = {%d, %d, %d, %d}",
@@ -394,169 +385,217 @@
/* let libpng take care of, e.g., bit-depth conversions */
png_set_packing (png_ptr);
---- netpbm-10.35.83/converter/other/pngtopnm.c.orig 2011-11-25 01:15:46.000000000 +0100
-+++ netpbm-10.35.83/converter/other/pngtopnm.c 2012-01-29 13:39:20.230540563 +0100
-@@ -44,11 +44,6 @@
- #include "nstring.h"
+--- netpbm-10.47.61/converter/other/pngtopnm.c.orig 2016-03-27 03:38:28.000000000 +0200
++++ netpbm-10.47.61/converter/other/pngtopnm.c 2016-06-09 19:08:35.590610275 +0200
+@@ -32,13 +32,6 @@
#include "shhopt.h"
+ #include "pnm.h"
+-/* A hack until we can remove direct access to png_info from the program */
-#if PNG_LIBPNG_VER >= 10400
--#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
--#error You need either an older PNG library (older than 1.4)
--#error newer Netpbm source code (at least 10.48)
+-#define TRANS_ALPHA trans_alpha
+-#else
+-#define TRANS_ALPHA trans
-#endif
+-
- typedef struct _jmpbuf_wrapper {
- jmp_buf jmpbuf;
-@@ -187,7 +182,7 @@
-
+ enum alpha_handling {ALPHA_NONE, ALPHA_ONLY, ALPHA_MIX};
+@@ -263,23 +256,25 @@ verifyFileIsPng(FILE * const ifP,
+ static unsigned int
+ computePngLineSize(struct pngx * const pngxP) {
--#define get_png_val(p) _get_png_val (&(p), info_ptr->bit_depth)
-+#define get_png_val(p) _get_png_val (&(p), bit_depth)
+- unsigned int const bytesPerSample =
+- pngxP->info_ptr->bit_depth == 16 ? 2 : 1;
+-
++ png_uint_32 width;
++ int bit_depth, color_type;
++ unsigned int bytesPerSample;
+ unsigned int samplesPerPixel;
+
+- switch (pngxP->info_ptr->color_type) {
++ png_get_IHDR(pngxP->png_ptr, pngxP->info_ptr, &width, NULL, &bit_depth, &color_type, NULL, NULL, NULL);
++ bytesPerSample = (bit_depth == 16) ? 2 : 1;
++ switch (color_type) {
+ case PNG_COLOR_TYPE_GRAY_ALPHA: samplesPerPixel = 2; break;
+ case PNG_COLOR_TYPE_RGB: samplesPerPixel = 3; break;
+ case PNG_COLOR_TYPE_RGB_ALPHA: samplesPerPixel = 4; break;
+ default: samplesPerPixel = 1;
+ }
- static png_uint_16
- _get_png_val (png_byte ** const pp,
-@@ -266,33 +261,37 @@
+- if (UINT_MAX / bytesPerSample / samplesPerPixel < pngxP->info_ptr->width)
++ if (UINT_MAX / bytesPerSample / samplesPerPixel < width)
+ pm_error("Width %u of PNG is uncomputably large",
+- (unsigned int)pngxP->info_ptr->width);
++ (unsigned int)width);
+
+- return pngxP->info_ptr->width * bytesPerSample * samplesPerPixel;
++ return width * bytesPerSample * samplesPerPixel;
}
- #ifdef __STDC__
--static void save_text (png_info *info_ptr, FILE *tfp)
-+static void save_text (png_struct *png_ptr, png_info *info_ptr, FILE *tfp)
- #else
--static void save_text (info_ptr, tfp)
-+static void save_text (png_ptr, info_ptr, tfp)
-+png_struct *png_ptr;
- png_info *info_ptr;
- FILE *tfp;
- #endif
- {
- int i, j, k;
-+ png_text *text;
-+ int num_text;
-+ png_get_text(png_ptr, info_ptr, &text, &num_text);
-- for (i = 0 ; i < info_ptr->num_text ; i++) {
-+ for (i = 0 ; i < num_text ; i++) {
- j = 0;
-- while (info_ptr->text[i].key[j] != '\0' && info_ptr->text[i].key[j] != ' ')
-+ while (text[i].key[j] != '\0' && text[i].key[j] != ' ')
- j++;
-- if (info_ptr->text[i].key[j] != ' ') {
-- fprintf (tfp, "%s", info_ptr->text[i].key);
-- for (j = strlen (info_ptr->text[i].key) ; j < 15 ; j++)
-+ if (text[i].key[j] != ' ') {
-+ fprintf (tfp, "%s", text[i].key);
-+ for (j = strlen (text[i].key) ; j < 15 ; j++)
- putc (' ', tfp);
- } else {
-- fprintf (tfp, "\"%s\"", info_ptr->text[i].key);
-- for (j = strlen (info_ptr->text[i].key) ; j < 13 ; j++)
-+ fprintf (tfp, "\"%s\"", text[i].key);
-+ for (j = strlen (text[i].key) ; j < 13 ; j++)
- putc (' ', tfp);
- }
- putc (' ', tfp); /* at least one space between key and text */
-
-- for (j = 0 ; j < info_ptr->text[i].text_length ; j++) {
-- putc (info_ptr->text[i].text[j], tfp);
-- if (info_ptr->text[i].text[j] == '\n')
-+ for (j = 0 ; j < text[i].text_length ; j++) {
-+ putc (text[i].text[j], tfp);
-+ if (text[i].text[j] == '\n')
- for (k = 0 ; k < 16 ; k++)
- putc ((int)' ', tfp);
- }
-@@ -301,9 +300,10 @@
- }
+@@ -291,15 +286,16 @@ allocPngRaster(struct pngx * const pngxP
+ unsigned int const lineSize = computePngLineSize(pngxP);
- #ifdef __STDC__
--static void show_time (png_info *info_ptr)
-+static void show_time (png_struct *png_ptr, png_info *info_ptr)
- #else
--static void show_time (info_ptr)
-+static void show_time (ptr_ptr, info_ptr)
-+png_struct *png_ptr;
- png_info *info_ptr;
- #endif
- {
-@@ -312,18 +312,20 @@
- "July", "August", "September", "October", "November", "December"
- };
+ png_byte ** pngImage;
++ png_uint_32 height = png_get_image_height(pngxP->png_ptr, pngxP->info_ptr);
+ unsigned int row;
-- if (info_ptr->valid & PNG_INFO_tIME) {
-- if (info_ptr->mod_time.month < 1 ||
-- info_ptr->mod_time.month >= ARRAY_SIZE(month)) {
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tIME)) {
-+ png_timep mod_timep;
-+ png_get_tIME(png_ptr, info_ptr, &mod_timep);
-+ if (mod_timep->month < 1 ||
-+ mod_timep->month >= ARRAY_SIZE(month)) {
- pm_message("tIME chunk in PNG input is invalid; "
- "modification time of image is unknown. "
- "The month value, which should be in the range "
-- "1-12, is %u", info_ptr->mod_time.month);
-+ "1-12, is %u", mod_timep->month);
- } else
- pm_message ("modification time: %02d %s %d %02d:%02d:%02d",
-- info_ptr->mod_time.day, month[info_ptr->mod_time.month],
-- info_ptr->mod_time.year, info_ptr->mod_time.hour,
-- info_ptr->mod_time.minute, info_ptr->mod_time.second);
-+ mod_timep->day, month[mod_timep->month],
-+ mod_timep->year, mod_timep->hour,
-+ mod_timep->minute, mod_timep->second);
- }
- }
+- MALLOCARRAY(pngImage, pngxP->info_ptr->height);
++ MALLOCARRAY(pngImage, height);
-@@ -360,12 +362,12 @@
+ if (pngImage == NULL)
+ pm_error("couldn't allocate space for %u PNG raster rows",
+- (unsigned int)pngxP->info_ptr->height);
++ (unsigned int)height);
+- for (row = 0; row < pngxP->info_ptr->height; ++row) {
++ for (row = 0; row < height; ++row) {
+ MALLOCARRAY(pngImage[row], lineSize);
+ if (pngImage[row] == NULL)
+ pm_error("couldn't allocate space for %uth row of PNG raster",
+@@ -316,7 +312,7 @@ freePngRaster(png_byte ** const pngRas
- static void
--dump_png_info(png_info *info_ptr) {
-+dump_png_info(png_struct *png_ptr, png_info *info_ptr) {
+ unsigned int row;
+- for (row = 0; row < pngxP->info_ptr->height; ++row)
++ for (row = 0; row < png_get_image_height(pngxP->png_ptr, pngxP->info_ptr); ++row)
+ free(pngRaster[row]);
+
+ free(pngRaster);
+@@ -343,7 +339,7 @@ readPng(struct pngx * const pngxP,
+
+ allocPngRaster(pngxP, &pngRaster);
+
+- if (pngxP->info_ptr->bit_depth < 8)
++ if (png_get_bit_depth(pngxP->png_ptr, pngxP->info_ptr) < 8)
+ png_set_packing(pngxP->png_ptr);
+
+ png_read_image(pngxP->png_ptr, pngRaster);
+@@ -439,31 +435,34 @@ saveText(struct pngx * const pngxP,
+ FILE * const tfP) {
+
+ png_info * const info_ptr = pngxP->info_ptr;
+-
++ png_text *text;
++ int num_text;
+ unsigned int i;
+
+- for (i = 0 ; i < info_ptr->num_text; ++i) {
++ png_get_text(pngxP->png_ptr, info_ptr, &text, &num_text);
++
++ for (i = 0 ; i < num_text; ++i) {
+ unsigned int j;
+ j = 0;
+
+- while (info_ptr->text[i].key[j] != '\0' &&
+- info_ptr->text[i].key[j] != ' ')
++ while (text[i].key[j] != '\0' &&
++ text[i].key[j] != ' ')
+ ++j;
+
+- if (info_ptr->text[i].key[j] != ' ') {
+- fprintf(tfP, "%s", info_ptr->text[i].key);
+- for (j = strlen (info_ptr->text[i].key); j < 15; ++j)
++ if (text[i].key[j] != ' ') {
++ fprintf(tfP, "%s", text[i].key);
++ for (j = strlen (text[i].key); j < 15; ++j)
+ putc(' ', tfP);
+ } else {
+- fprintf(tfP, "\"%s\"", info_ptr->text[i].key);
+- for (j = strlen (info_ptr->text[i].key); j < 13; ++j)
++ fprintf(tfP, "\"%s\"", text[i].key);
++ for (j = strlen (text[i].key); j < 13; ++j)
+ putc(' ', tfP);
+ }
+ putc(' ', tfP); /* at least one space between key and text */
+
+- for (j = 0; j < info_ptr->text[i].text_length; ++j) {
+- putc(info_ptr->text[i].text[j], tfP);
+- if (info_ptr->text[i].text[j] == '\n') {
++ for (j = 0; j < text[i].text_length; ++j) {
++ putc(text[i].text[j], tfP);
++ if (text[i].text[j] == '\n') {
+ unsigned int k;
+ for (k = 0; k < 16; ++k)
+ putc(' ', tfP);
+@@ -483,21 +482,23 @@ showTime(struct pngx * const pngxP) {
+ "July", "August", "September", "October", "November", "December"
+ };
+
+- if (pngxP->info_ptr->valid & PNG_INFO_tIME) {
+- if (pngxP->info_ptr->mod_time.month < 1 ||
+- pngxP->info_ptr->mod_time.month >= ARRAY_SIZE(month)) {
++ if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_tIME)) {
++ png_timep mod_timep;
++ png_get_tIME(pngxP->png_ptr, pngxP->info_ptr, &mod_timep);
++ if (mod_timep->month < 1 ||
++ mod_timep->month >= ARRAY_SIZE(month)) {
+ pm_message("tIME chunk in PNG input is invalid; "
+ "modification time of image is unknown. "
+ "The month value, which should be in the range "
+- "1-12, is %u", pngxP->info_ptr->mod_time.month);
++ "1-12, is %u", mod_timep->month);
+ } else
+ pm_message("modification time: %02d %s %d %02d:%02d:%02d",
+- pngxP->info_ptr->mod_time.day,
+- month[pngxP->info_ptr->mod_time.month],
+- pngxP->info_ptr->mod_time.year,
+- pngxP->info_ptr->mod_time.hour,
+- pngxP->info_ptr->mod_time.minute,
+- pngxP->info_ptr->mod_time.second);
++ mod_timep->day,
++ month[mod_timep->month],
++ mod_timep->year,
++ mod_timep->hour,
++ mod_timep->minute,
++ mod_timep->second);
+ }
+ }
+
+@@ -510,7 +511,7 @@ dumpPngInfo(struct pngx * const pngxP) {
const char *type_string;
const char *filter_string;
- switch (info_ptr->color_type) {
-+ switch (png_get_color_type(png_ptr, info_ptr)) {
++ switch (png_get_color_type(pngxP->png_ptr, info_ptr)) {
case PNG_COLOR_TYPE_GRAY:
type_string = "gray";
break;
-@@ -387,90 +389,106 @@
+@@ -532,90 +533,106 @@ dumpPngInfo(struct pngx * const pngxP) {
break;
}
- switch (info_ptr->filter_type) {
-+ switch (png_get_filter_type(png_ptr, info_ptr)) {
++ switch (png_get_filter_type(pngxP->png_ptr, info_ptr)) {
case PNG_FILTER_TYPE_BASE:
asprintfN(&filter_string, "base filter");
break;
default:
asprintfN(&filter_string, "unknown filter type %d",
- info_ptr->filter_type);
-+ png_get_filter_type(png_ptr, info_ptr));
++ png_get_filter_type(pngxP->png_ptr, info_ptr));
}
+ {
+ png_uint_32 width, height;
-+ int bit_depth, color_type;
-+ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
++ int bit_depth;
++ png_get_IHDR(pngxP->png_ptr, pngxP->info_ptr, &width, &height, &bit_depth, NULL, NULL, NULL, NULL);
pm_message("reading a %ldw x %ldh image, %d bit%s",
- info_ptr->width, info_ptr->height,
- info_ptr->bit_depth, info_ptr->bit_depth > 1 ? "s" : "");
-+ width, height,
++ (long)width, (long)height,
+ bit_depth, bit_depth > 1 ? "s" : "");
+ }
pm_message("%s, %s, %s",
type_string,
- info_ptr->interlace_type ?
-+ png_get_interlace_type(png_ptr, info_ptr) ?
++ png_get_interlace_type(pngxP->png_ptr, info_ptr) ?
"Adam7 interlaced" : "not interlaced",
filter_string);
+ {
+ png_color_16p bkgp;
-+ if(png_get_bKGD(png_ptr, info_ptr, &bkgp) && (bkgp != NULL))
++ if(png_get_bKGD(pngxP->png_ptr, info_ptr, &bkgp) && (bkgp != NULL))
pm_message("background {index, gray, red, green, blue} = "
"{%d, %d, %d, %d, %d}",
- info_ptr->background.index,
@@ -574,9 +613,9 @@
strfree(filter_string);
- if (info_ptr->valid & PNG_INFO_tRNS)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-+ int num_trans;
-+ png_get_tRNS(png_ptr, info_ptr, NULL, &num_trans, NULL);
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_tRNS)) {
++ int num_trans;
++ png_get_tRNS(pngxP->png_ptr, info_ptr, NULL, &num_trans, NULL);
pm_message("tRNS chunk (transparency): %u entries",
- info_ptr->num_trans);
- else
@@ -587,21 +626,21 @@
- if (info_ptr->valid & PNG_INFO_gAMA)
- pm_message("gAMA chunk (image gamma): gamma = %4.2f", info_ptr->gamma);
- else
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
-+ double gamma;
-+ png_get_gAMA(png_ptr, info_ptr, &gamma);
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_gAMA)) {
++ double gamma;
++ png_get_gAMA(pngxP->png_ptr, info_ptr, &gamma);
+ pm_message("gAMA chunk (image gamma): gamma = %4.2f", gamma);
+ } else
pm_message("gAMA chunk (image gamma): not present");
- if (info_ptr->valid & PNG_INFO_sBIT)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_sBIT))
pm_message("sBIT chunk: present");
else
pm_message("sBIT chunk: not present");
- if (info_ptr->valid & PNG_INFO_cHRM)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_cHRM))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_cHRM))
pm_message("cHRM chunk: present");
else
pm_message("cHRM chunk: not present");
@@ -609,101 +648,89 @@
- if (info_ptr->valid & PNG_INFO_PLTE)
- pm_message("PLTE chunk: %d entries", info_ptr->num_palette);
- else
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE)) {
-+ png_colorp palette;
-+ int num_palette;
-+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_PLTE)) {
++ png_colorp palette;
++ int num_palette;
++ png_get_PLTE(pngxP->png_ptr, info_ptr, &palette, &num_palette);
+ pm_message("PLTE chunk: %d entries", num_palette);
+ } else
pm_message("PLTE chunk: not present");
- if (info_ptr->valid & PNG_INFO_bKGD)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_bKGD))
pm_message("bKGD chunk: present");
else
pm_message("bKGD chunk: not present");
-- if (info_ptr->valid & PNG_INFO_hIST)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_hIST))
+- if (info_ptr->valid & PNG_INFO_PLTE)
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_hIST))
pm_message("hIST chunk: present");
else
pm_message("hIST chunk: not present");
- if (info_ptr->valid & PNG_INFO_pHYs)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_pHYs))
pm_message("pHYs chunk: present");
else
pm_message("pHYs chunk: not present");
- if (info_ptr->valid & PNG_INFO_oFFs)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_oFFs))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_oFFs))
pm_message("oFFs chunk: present");
else
pm_message("oFFs chunk: not present");
- if (info_ptr->valid & PNG_INFO_tIME)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tIME))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_tIME))
pm_message("tIME chunk: present");
else
pm_message("tIME chunk: not present");
- if (info_ptr->valid & PNG_INFO_pCAL)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pCAL))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_pCAL))
pm_message("pCAL chunk: present");
else
pm_message("pCAL chunk: not present");
- if (info_ptr->valid & PNG_INFO_sRGB)
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sRGB))
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_sRGB))
pm_message("sRGB chunk: present");
else
pm_message("sRGB chunk: not present");
-@@ -480,6 +498,7 @@
-
- static bool
- isTransparentColor(pngcolor const color,
-+ png_struct * const png_ptr,
- png_info * const info_ptr,
- double const totalgamma) {
- /*----------------------------------------------------------------------------
-@@ -488,9 +507,9 @@
- -----------------------------------------------------------------------------*/
- bool retval;
-
-- if (info_ptr->valid & PNG_INFO_tRNS) {
-- const png_color_16 * const transColorP = &info_ptr->trans_values;
--
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-+ png_color_16p transColorP;
-+ png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &transColorP);
-
- /* There seems to be a problem here: you can't compare real
- numbers for equality. Also, I'm not sure the gamma
-@@ -538,9 +557,11 @@
+@@ -669,7 +685,7 @@ isTransparentColor(pngcolor const c
+ pixels, and just do it ourselves.
+ */
+
+- switch (pngxP->info_ptr->color_type) {
++ switch (png_get_color_type(pngxP->png_ptr, pngxP->info_ptr)) {
+ case PNG_COLOR_TYPE_GRAY:
+ retval = color.r == gamma_correct(transColorP->gray, totalgamma);
+ break;
+@@ -696,9 +712,11 @@ setupGammaCorrection(struct pngx * const
*totalgammaP = -1.0;
else {
float imageGamma;
-- if (info_ptr->valid & PNG_INFO_gAMA)
-- imageGamma = info_ptr->gamma;
+- if (pngxP->info_ptr->valid & PNG_INFO_gAMA)
+- imageGamma = pngxP->info_ptr->gamma;
- else {
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
-+ double gamma;
-+ png_get_gAMA(png_ptr, info_ptr, &gamma);
-+ imageGamma = gamma;
++ if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_gAMA)) {
++ double gamma;
++ png_get_gAMA(pngxP->png_ptr, pngxP->info_ptr, &gamma);
++ imageGamma = gamma;
+ } else {
if (verbose)
pm_message("PNG doesn't specify image gamma. Assuming 1.0");
imageGamma = 1.0;
-@@ -558,7 +579,7 @@
+@@ -716,7 +734,7 @@ setupGammaCorrection(struct pngx * const
/* in case of gamma-corrections, sBIT's as in the
PNG-file are not valid anymore
*/
-- info_ptr->valid &= ~PNG_INFO_sBIT;
-+ png_set_invalid(png_ptr, info_ptr, PNG_INFO_sBIT);
+- pngxP->info_ptr->valid &= ~PNG_INFO_sBIT;
++ png_set_invalid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_sBIT);
if (verbose)
pm_message("image gamma is %4.2f, "
"converted for display gamma of %4.2f",
-@@ -570,20 +591,23 @@
+@@ -728,20 +746,23 @@ setupGammaCorrection(struct pngx * const
static bool
@@ -718,27 +745,27 @@
+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
bool foundGray;
unsigned int i;
-+ int num_trans;
-+ png_bytep trans_alpha;
-+ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
++ int num_trans;
++ png_bytep trans_alpha;
++ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
for (i = 0, foundGray = FALSE;
- i < info_ptr->num_trans && !foundGray;
+ i < num_trans && !foundGray;
++i) {
-- if (info_ptr->trans[i] != 0 &&
-- info_ptr->trans[i] != maxval) {
+- if (info_ptr->TRANS_ALPHA[i] != 0 &&
+- info_ptr->TRANS_ALPHA[i] != maxval) {
+ if (trans_alpha[i] != 0 &&
+ trans_alpha[i] != maxval) {
foundGray = TRUE;
}
}
-@@ -612,13 +636,14 @@
- Return the result as *maxvalP.
- -----------------------------------------------------------------------------*/
+@@ -771,13 +792,14 @@ setupSignificantBits(struct pngx *
+ png_info * const info_ptr = pngxP->info_ptr;
+
/* Initial assumption of maxval */
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
-+ png_byte color_type = png_get_color_type(png_ptr, info_ptr);
++ png_byte color_type = png_get_color_type(pngxP->png_ptr, info_ptr);
+ if (color_type == PNG_COLOR_TYPE_PALETTE) {
if (alpha == ALPHA_ONLY) {
- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
@@ -748,27 +775,27 @@
/* The alpha mask will be all opaque, so maxval 1 is plenty */
*maxvalP = 1;
- else if (paletteHasPartialTransparency(info_ptr))
-+ else if (paletteHasPartialTransparency(png_ptr, info_ptr))
++ else if (paletteHasPartialTransparency(pngxP->png_ptr, info_ptr))
/* Use same maxval as PNG transparency palette for simplicity*/
*maxvalP = 255;
else
-@@ -628,7 +653,7 @@
+@@ -787,7 +809,7 @@ setupSignificantBits(struct pngx *
/* Use same maxval as PNG palette for simplicity */
*maxvalP = 255;
} else {
- *maxvalP = (1l << info_ptr->bit_depth) - 1;
-+ *maxvalP = (1l << png_get_bit_depth(png_ptr, info_ptr)) - 1;
++ *maxvalP = (1l << png_get_bit_depth(pngxP->png_ptr, info_ptr)) - 1;
}
/* sBIT handling is very tricky. If we are extracting only the
-@@ -641,20 +666,25 @@
+@@ -800,20 +822,25 @@ setupSignificantBits(struct pngx *
is used
*/
- if (info_ptr->valid & PNG_INFO_sBIT) {
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) {
-+ png_color_8p sig_bit;
-+ png_get_sBIT(png_ptr, info_ptr, &sig_bit);
++ if (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_sBIT)) {
++ png_color_8p sig_bit;
++ png_get_sBIT(pngxP->png_ptr, info_ptr, &sig_bit);
switch (alpha) {
case ALPHA_MIX:
- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
@@ -779,22 +806,22 @@
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
- (info_ptr->valid & PNG_INFO_tRNS)) {
+ if (color_type == PNG_COLOR_TYPE_PALETTE &&
-+ png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
++ (png_get_valid(pngxP->png_ptr, info_ptr, PNG_INFO_tRNS))) {
+ png_bytep trans_alpha;
-+ int num_trans;
++ int num_trans;
bool trans_mix;
unsigned int i;
trans_mix = TRUE;
- for (i = 0; i < info_ptr->num_trans; ++i)
-- if (info_ptr->trans[i] != 0 && info_ptr->trans[i] != 255) {
-+ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
+- if (info_ptr->TRANS_ALPHA[i] != 0 && info_ptr->TRANS_ALPHA[i] != 255) {
++ png_get_tRNS(pngxP->png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
+ for (i = 0; i < num_trans; ++i)
+ if (trans_alpha[i] != 0 && trans_alpha[i] != 255) {
trans_mix = FALSE;
break;
}
-@@ -665,70 +695,73 @@
+@@ -824,70 +851,73 @@ setupSignificantBits(struct pngx *
/* else fall though to normal case */
case ALPHA_NONE:
@@ -813,13 +840,13 @@
"different bit depths for color channels");
pm_message("writing file with %d bit resolution",
- info_ptr->bit_depth);
-+ png_get_bit_depth(png_ptr, info_ptr));
- *errorlevelP = PNMTOPNG_WARNING_LEVEL;
++ png_get_bit_depth(pngxP->png_ptr, info_ptr));
+ *errorLevelP = PNMTOPNG_WARNING_LEVEL;
} else {
- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) &&
- (info_ptr->sig_bit.red < 255)) {
+ if ((color_type == PNG_COLOR_TYPE_PALETTE) &&
-+ sig_bit->red < 255) {
++ (sig_bit->red < 255)) {
unsigned int i;
- for (i = 0; i < info_ptr->num_palette; ++i) {
- info_ptr->palette[i].red >>=
@@ -828,9 +855,9 @@
- (8 - info_ptr->sig_bit.green);
- info_ptr->palette[i].blue >>=
- (8 - info_ptr->sig_bit.blue);
-+ png_colorp palette;
-+ int num_palette;
-+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
++ png_colorp palette;
++ int num_palette;
++ png_get_PLTE(pngxP->png_ptr, info_ptr, &palette, &num_palette);
+ for (i = 0; i < num_palette; ++i) {
+ palette[i].red >>=
+ (8 - sig_bit->red);
@@ -850,12 +877,12 @@
- if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
- (info_ptr->sig_bit.red < info_ptr->bit_depth)) {
-- png_set_shift (png_ptr, &(info_ptr->sig_bit));
+- png_set_shift(pngxP->png_ptr, &(info_ptr->sig_bit));
- *maxvalP = (1l << info_ptr->sig_bit.red) - 1;
+ if ((color_type == PNG_COLOR_TYPE_RGB ||
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
-+ (sig_bit->red < png_get_bit_depth(png_ptr, info_ptr))) {
-+ png_set_shift (png_ptr, sig_bit);
++ (sig_bit->red < png_get_bit_depth(pngxP->png_ptr, info_ptr))) {
++ png_set_shift(pngxP->png_ptr, sig_bit);
+ *maxvalP = (1l << sig_bit->red) - 1;
if (verbose)
pm_message("image has fewer significant bits, "
@@ -870,10 +897,10 @@
+ color_type ==
PNG_COLOR_TYPE_GRAY_ALPHA) &&
- (info_ptr->sig_bit.gray < info_ptr->bit_depth)) {
-- png_set_shift (png_ptr, &(info_ptr->sig_bit));
+- png_set_shift(pngxP->png_ptr, &info_ptr->sig_bit);
- *maxvalP = (1l << info_ptr->sig_bit.gray) - 1;
-+ (sig_bit->gray < png_get_bit_depth(png_ptr, info_ptr))) {
-+ png_set_shift (png_ptr, sig_bit);
++ (sig_bit->gray < png_get_bit_depth(pngxP->png_ptr, info_ptr))) {
++ png_set_shift(pngxP->png_ptr, sig_bit);
+ *maxvalP = (1l << sig_bit->gray) - 1;
if (verbose)
pm_message("image has fewer significant bits, "
@@ -888,11 +915,11 @@
- if ((info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) &&
- (info_ptr->sig_bit.gray < info_ptr->bit_depth)) {
-- png_set_shift (png_ptr, &(info_ptr->sig_bit));
+- png_set_shift(pngxP->png_ptr, &info_ptr->sig_bit);
+ if ((color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) &&
-+ (sig_bit->gray < png_get_bit_depth(png_ptr, info_ptr))) {
-+ png_set_shift (png_ptr, sig_bit);
++ (sig_bit->gray < png_get_bit_depth(pngxP->png_ptr, info_ptr))) {
++ png_set_shift(pngxP->png_ptr, sig_bit);
if (verbose)
pm_message ("image has fewer significant bits, "
"writing file with %d bits",
@@ -903,359 +930,214 @@
}
break;
-@@ -739,22 +772,26 @@
-
-
- static bool
--imageHasColor(png_info * const info_ptr) {
-+imageHasColor(png_struct * const png_ptr, png_info * const info_ptr) {
+@@ -902,18 +932,23 @@ imageHasColor(struct pngx * const pngxP)
bool retval;
-+ png_byte color_type = png_get_color_type(png_ptr, info_ptr);
-- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
-- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+- if (pngxP->info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
+- pngxP->info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
++ png_byte color_type = png_get_color_type(pngxP->png_ptr, pngxP->info_ptr);
+ if (color_type == PNG_COLOR_TYPE_GRAY ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
retval = FALSE;
-- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+- else if (pngxP->info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+ else if (color_type == PNG_COLOR_TYPE_PALETTE) {
bool foundColor;
unsigned int i;
--
-+ png_colorp palette;
-+ int num_palette;
++ png_colorp palette;
++ int num_palette;
+
-+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
++ png_get_PLTE(pngxP->png_ptr, pngxP->info_ptr, &palette, &num_palette);
+
for (i = 0, foundColor = FALSE;
-- i < info_ptr->num_palette && !foundColor;
+- i < pngxP->info_ptr->num_palette && !foundColor;
+ i < num_palette && !foundColor;
++i) {
-- if (iscolor(info_ptr->palette[i]))
+- if (iscolor(pngxP->info_ptr->palette[i]))
+ if (iscolor(palette[i]))
foundColor = TRUE;
}
retval = foundColor;
-@@ -767,14 +804,15 @@
-
-
- static void
--determineOutputType(png_info * const info_ptr,
-+determineOutputType(png_struct * const png_ptr,
-+ png_info * const info_ptr,
- enum alpha_handling const alphaHandling,
- pngcolor const bgColor,
- xelval const maxval,
- int * const pnmTypeP) {
-
- if (alphaHandling != ALPHA_ONLY &&
-- (imageHasColor(info_ptr) || !isGrayscale(bgColor)))
-+ (imageHasColor(png_ptr, info_ptr) || !isGrayscale(bgColor)))
- *pnmTypeP = PPM_TYPE;
- else {
- if (maxval > 1)
-@@ -787,7 +825,8 @@
-
-
- static void
--getBackgroundColor(png_info * const info_ptr,
-+getBackgroundColor(png_struct * const png_ptr,
-+ png_info * const info_ptr,
- const char * const requestedColor,
- float const totalgamma,
- xelval const maxval,
-@@ -809,19 +848,24 @@
+@@ -968,19 +1003,24 @@ getBackgroundColor(struct pngx * const p
bgColorP->g = PPM_GETG(backcolor);
bgColorP->b = PPM_GETB(backcolor);
-- } else if (info_ptr->valid & PNG_INFO_bKGD) {
-+ } else if (png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD)) {
-+ png_color_16p background;
-+ png_colorp palette;
-+ int num_palette;
-+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
-+ png_get_bKGD(png_ptr, info_ptr, &background);
+- } else if (pngxP->info_ptr->valid & PNG_INFO_bKGD) {
++ } else if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_bKGD)) {
++ png_color_16p background;
++ png_get_bKGD(pngxP->png_ptr, pngxP->info_ptr, &background);
/* didn't manage to get libpng to work (bugs?) concerning background
processing, therefore we do our own.
*/
-- switch (info_ptr->color_type) {
-+ switch (png_get_color_type(png_ptr, info_ptr)) {
+- switch (pngxP->info_ptr->color_type) {
++ switch (png_get_color_type(pngxP->png_ptr, pngxP->info_ptr)) {
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_GRAY_ALPHA:
bgColorP->r = bgColorP->g = bgColorP->b =
-- gamma_correct(info_ptr->background.gray, totalgamma);
+- gamma_correct(pngxP->info_ptr->background.gray, totalgamma);
+ gamma_correct(background->gray, totalgamma);
break;
case PNG_COLOR_TYPE_PALETTE: {
++ png_colorp palette;
++ int num_palette;
++ png_get_PLTE(pngxP->png_ptr, pngxP->info_ptr, &palette, &num_palette);
png_color const rawBgcolor =
-- info_ptr->palette[info_ptr->background.index];
+- pngxP->info_ptr->palette[pngxP->info_ptr->background.index];
+ palette[background->index];
bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma);
-@@ -829,7 +873,7 @@
+@@ -988,7 +1028,7 @@ getBackgroundColor(struct pngx * const p
break;
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_RGB_ALPHA: {
-- png_color_16 const rawBgcolor = info_ptr->background;
+- png_color_16 const rawBgcolor = pngxP->info_ptr->background;
+ png_color_16 const rawBgcolor = *background;
bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
-@@ -842,12 +886,32 @@
- bgColorP->r = bgColorP->g = bgColorP->b = maxval;
+@@ -1007,10 +1047,12 @@ static void
+ warnNonsquarePixels(struct pngx * const pngxP,
+ int * const errorLevelP) {
+
+- if (pngxP->info_ptr->valid & PNG_INFO_pHYs) {
++ if (png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_pHYs)) {
++ png_uint_32 x_pixels_per_unit, y_pixels_per_unit;
++ png_get_pHYs(pngxP->png_ptr, pngxP->info_ptr, &x_pixels_per_unit, &y_pixels_per_unit, NULL);
+ float const r =
+- (float)pngxP->info_ptr->x_pixels_per_unit /
+- pngxP->info_ptr->y_pixels_per_unit;
++ (float)x_pixels_per_unit /
++ y_pixels_per_unit;
+
+ if (r != 1.0) {
+ pm_message ("warning - non-square pixels; "
+@@ -1024,7 +1066,7 @@ warnNonsquarePixels(struct pngx * const
+
+
+
+-#define GET_PNG_VAL(p) get_png_val(&(p), pngxP->info_ptr->bit_depth)
++#define GET_PNG_VAL(p) get_png_val(&(p), png_get_bit_depth(pngxP->png_ptr, pngxP->info_ptr))
+
+
+
+@@ -1042,8 +1084,8 @@ makeXelRow(xel * const xel
+ unsigned int col;
+
+ pngPixelP = &pngRasterRow[0]; /* initial value */
+- for (col = 0; col < pngxP->info_ptr->width; ++col) {
+- switch (pngxP->info_ptr->color_type) {
++ for (col = 0; col < png_get_image_width(pngxP->png_ptr, pngxP->info_ptr); ++col) {
++ switch (png_get_color_type(pngxP->png_ptr, pngxP->info_ptr)) {
+ case PNG_COLOR_TYPE_GRAY: {
+ pngcolor fgColor;
+ fgColor.r = fgColor.g = fgColor.b = GET_PNG_VAL(pngPixelP);
+@@ -1065,7 +1107,15 @@ makeXelRow(xel * const xel
+
+ case PNG_COLOR_TYPE_PALETTE: {
+ png_uint_16 const index = GET_PNG_VAL(pngPixelP);
+- png_color const paletteColor = pngxP->info_ptr->palette[index];
++ png_color paletteColor;
++ png_colorp palette;
++ png_bytep trans_alpha;
++ int num_palette, num_trans;
++ bool trans_valid = png_get_valid(pngxP->png_ptr, pngxP->info_ptr, PNG_INFO_tRNS);
++ png_get_PLTE(pngxP->png_ptr, pngxP->info_ptr, &palette, &num_palette);
++ if (trans_valid)
++ png_get_tRNS(pngxP->png_ptr, pngxP->info_ptr, &trans_alpha, &num_trans, NULL);
++ paletteColor = palette[index];
+
+ pngcolor fgColor;
+
+@@ -1074,9 +1124,9 @@ makeXelRow(xel * const xel
+ fgColor.b = paletteColor.blue;
+
+ setXel(&xelrow[col], fgColor, bgColor, alphaHandling,
+- (pngxP->info_ptr->valid & PNG_INFO_tRNS) &&
+- index < pngxP->info_ptr->num_trans ?
+- pngxP->info_ptr->TRANS_ALPHA[index] : maxval);
++ trans_valid &&
++ index < num_trans ?
++ trans_alpha[index] : maxval);
+ }
+ break;
+
+@@ -1106,13 +1156,20 @@ makeXelRow(xel * const xel
+
+ default:
+ pm_error("unknown PNG color type: %d",
+- pngxP->info_ptr->color_type);
++ png_get_color_type(pngxP->png_ptr, pngxP->info_ptr));
+ }
+ }
}
-+static png_color_16p get_png_trans_colorp(png_struct *png_ptr, png_info *info_ptr)
-+{
-+ png_color_16p trans_color;
-+ png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_color);
-+ return trans_color;
-+}
-+
-+static int get_png_num_trans(png_struct *png_ptr, png_info *info_ptr)
-+{
-+ int num_trans;
-+ png_get_tRNS(png_ptr, info_ptr, NULL, &num_trans, NULL);
-+ return num_trans;
-+}
-+static png_bytep get_png_trans_alpha(png_struct *png_ptr, png_info *info_ptr)
+
++static png_bytep get_png_trans_alpha(struct pngx * const pngxP)
+{
+ png_bytep trans_alpha;
-+ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, NULL, NULL);
++ png_get_tRNS(pngxP->png_ptr, pngxP->info_ptr, &trans_alpha, NULL, NULL);
+ return trans_alpha;
+}
-
++
static void
writePnm(FILE * const ofP,
xelval const maxval,
- int const pnm_type,
-+ png_struct * const png_ptr,
- png_info * const info_ptr,
- png_byte ** const png_image,
- pngcolor const bgColor,
-@@ -865,6 +929,10 @@
- -----------------------------------------------------------------------------*/
+@@ -1136,6 +1193,8 @@ writePnm(FILE * const ofP,
+
xel * xelrow;
unsigned int row;
-+ png_uint_32 width, height;
-+ int bit_depth, color_type;
-+ png_colorp palette;
-+ int num_palette;
++ png_uint_32 width = png_get_image_width(pngxP->png_ptr, pngxP->info_ptr),
++ height = png_get_image_height(pngxP->png_ptr, pngxP->info_ptr);
if (verbose)
- pm_message ("writing a %s file (maxval=%u)",
-@@ -874,25 +942,28 @@
- "UNKNOWN!",
- maxval);
+ pm_message("writing a %s file (maxval=%u)",
+@@ -1145,17 +1204,17 @@ writePnm(FILE * const ofP,
+ "UNKNOWN!",
+ maxval);
-- xelrow = pnm_allocrow(info_ptr->width);
-+ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
-+ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
-
-- pnm_writepnminit(stdout, info_ptr->width, info_ptr->height, maxval,
+- xelrow = pnm_allocrow(pngxP->info_ptr->width);
+ xelrow = pnm_allocrow(width);
-+
-+ pnm_writepnminit(stdout, width, height, maxval,
- pnm_type, FALSE);
-- for (row = 0; row < info_ptr->height; ++row) {
-+ for (row = 0; row < height; ++row) {
- png_byte * png_pixelP;
- int col;
-
- png_pixelP = &png_image[row][0]; /* initial value */
-- for (col = 0; col < info_ptr->width; ++col) {
-- switch (info_ptr->color_type) {
-+ for (col = 0; col < width; ++col) {
-+ switch (color_type) {
- case PNG_COLOR_TYPE_GRAY: {
- pngcolor fgColor;
- fgColor.r = fgColor.g = fgColor.b = get_png_val(png_pixelP);
- setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
-- ((info_ptr->valid & PNG_INFO_tRNS) &&
-+ ((png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) &&
- (fgColor.r ==
-- gamma_correct(info_ptr->trans_values.gray,
-+ gamma_correct(get_png_trans_colorp(png_ptr, info_ptr)->gray,
- totalgamma))) ?
- 0 : maxval);
- }
-@@ -910,7 +981,7 @@
-
- case PNG_COLOR_TYPE_PALETTE: {
- png_uint_16 const index = get_png_val(png_pixelP);
-- png_color const paletteColor = info_ptr->palette[index];
-+ png_color const paletteColor = palette[index];
-
- pngcolor fgColor;
+ pnm_writepnminit(stdout,
+- pngxP->info_ptr->width, pngxP->info_ptr->height, maxval,
++ width, height, maxval,
+ pnmType, plainFalse);
-@@ -919,9 +990,9 @@
- fgColor.b = paletteColor.blue;
-
- setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
-- (info_ptr->valid & PNG_INFO_tRNS) &&
-- index < info_ptr->num_trans ?
-- info_ptr->trans[index] : maxval);
-+ (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) &&
-+ index < get_png_num_trans(png_ptr, info_ptr) ?
-+ get_png_trans_alpha(png_ptr, info_ptr)[index] : maxval);
- }
- break;
-
-@@ -932,7 +1003,7 @@
- fgColor.g = get_png_val(png_pixelP);
- fgColor.b = get_png_val(png_pixelP);
- setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
-- isTransparentColor(fgColor, info_ptr, totalgamma) ?
-+ isTransparentColor(fgColor, png_ptr, info_ptr, totalgamma) ?
- 0 : maxval);
- }
- break;
-@@ -950,10 +1021,10 @@
- break;
+- for (row = 0; row < pngxP->info_ptr->height; ++row) {
++ for (row = 0; row < height; ++row) {
+ makeXelRow(xelrow, maxval, pnmType, pngxP, pngRaster[row], bgColor,
+ alphaHandling, totalgamma);
- default:
-- pm_error ("unknown PNG color type: %d", info_ptr->color_type);
-+ pm_error ("unknown PNG color type: %d", color_type);
- }
- }
-- pnm_writepnmrow(ofP, xelrow, info_ptr->width, maxval, pnm_type, FALSE);
-+ pnm_writepnmrow(ofP, xelrow, width, maxval, pnm_type, FALSE);
+- pnm_writepnmrow(ofP, xelrow, pngxP->info_ptr->width, maxval,
++ pnm_writepnmrow(ofP, xelrow, width, maxval,
+ pnmType, plainFalse);
}
pnm_freerow (xelrow);
- }
-@@ -974,6 +1045,8 @@
- int pnm_type;
- pngcolor bgColor;
- float totalgamma;
-+ png_uint_32 width, height;
-+ int bit_depth, color_type;
+--- netpbm-10.35.83/converter/other/pngtxt.c.orig 2006-08-19 05:12:28.000000000 +0200
++++ netpbm-10.35.83/converter/other/pngtxt.c 2012-01-29 09:59:22.463431985 +0100
+@@ -240,7 +240,8 @@
- *errorlevelP = 0;
-@@ -995,29 +1068,30 @@
- png_init_io (png_ptr, ifp);
- png_set_sig_bytes (png_ptr, SIG_CHECK_SIZE);
- png_read_info (png_ptr, info_ptr);
-+ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
-
-- MALLOCARRAY(png_image, info_ptr->height);
-+ MALLOCARRAY(png_image, height);
- if (png_image == NULL) {
- png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL);
- pm_closer (ifp);
- pm_error ("couldn't allocate space for image");
- }
-
-- if (info_ptr->bit_depth == 16)
-- linesize = 2 * info_ptr->width;
-+ if (bit_depth == 16)
-+ linesize = 2 * width;
- else
-- linesize = info_ptr->width;
-+ linesize = width;
-
-- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
-+ if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
- linesize *= 2;
- else
-- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB)
-+ if (color_type == PNG_COLOR_TYPE_RGB)
- linesize *= 3;
- else
-- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-+ if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
- linesize *= 4;
-
-- for (y = 0 ; y < info_ptr->height ; y++) {
-+ for (y = 0 ; y < height ; y++) {
- png_image[y] = malloc (linesize);
- if (png_image[y] == NULL) {
- for (x = 0 ; x < y ; x++)
-@@ -1029,7 +1103,7 @@
- }
- }
-
-- if (info_ptr->bit_depth < 8)
-+ if (bit_depth < 8)
- png_set_packing (png_ptr);
-
- setupGammaCorrection(png_ptr, info_ptr, cmdline.gamma, &totalgamma);
-@@ -1037,7 +1111,7 @@
- setupSignificantBits(png_ptr, info_ptr, cmdline.alpha,
- &maxval, errorlevelP);
-
-- getBackgroundColor(info_ptr, cmdline.background, totalgamma, maxval,
-+ getBackgroundColor(png_ptr, info_ptr, cmdline.background, totalgamma, maxval,
- &bgColor);
-
- png_read_image (png_ptr, png_image);
-@@ -1048,16 +1122,18 @@
- completes. That's because it comes from chunks that are at the
- end of the stream.
- */
-- dump_png_info(info_ptr);
-+ dump_png_info(png_ptr, info_ptr);
-
- if (mtime)
-- show_time (info_ptr);
-+ show_time (png_ptr, info_ptr);
- if (tfp)
-- save_text (info_ptr, tfp);
-+ save_text (png_ptr, info_ptr, tfp);
-
-- if (info_ptr->valid & PNG_INFO_pHYs) {
-+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs)) {
- float r;
-- r = (float)info_ptr->x_pixels_per_unit / info_ptr->y_pixels_per_unit;
-+ png_uint_32 res_x, res_y;
-+ png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y, NULL);
-+ r = (float)res_x / res_y;
- if (r != 1.0) {
- pm_message ("warning - non-square pixels; "
- "to fix do a 'pamscale -%cscale %g'",
-@@ -1067,13 +1143,13 @@
- }
- }
-
-- determineOutputType(info_ptr, cmdline.alpha, bgColor, maxval, &pnm_type);
-+ determineOutputType(png_ptr, info_ptr, cmdline.alpha, bgColor, maxval, &pnm_type);
-
-- writePnm(stdout, maxval, pnm_type, info_ptr, png_image, bgColor,
-+ writePnm(stdout, maxval, pnm_type, png_ptr, info_ptr, png_image, bgColor,
- cmdline.alpha, totalgamma);
-
- fflush(stdout);
-- for (y = 0 ; y < info_ptr->height ; y++)
-+ for (y = 0 ; y < height ; y++)
- free (png_image[y]);
- free (png_image);
- png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL);
---- netpbm-10.35.83/converter/other/pngtxt.c.orig 2006-08-19 05:12:28.000000000 +0200
-+++ netpbm-10.35.83/converter/other/pngtxt.c 2012-01-29 09:59:22.463431985 +0100
-@@ -240,7 +240,8 @@
-
-
- void
--pnmpng_read_text (png_info * const info_ptr,
-+pnmpng_read_text (png_struct * const png_ptr,
-+ png_info * const info_ptr,
- FILE * const tfp,
- bool const ztxt,
- bool const verbose) {
-@@ -250,15 +251,16 @@
- unsigned int commentIdx;
- bool noCommentsYet;
- bool eof;
-+ png_textp text;
- unsigned int allocatedComments;
-- /* Number of entries currently allocated for the info_ptr->text
-+ /* Number of entries currently allocated for the text
- array
- */
+ void
+-pnmpng_read_text (png_info * const info_ptr,
++pnmpng_read_text (png_struct * const png_ptr,
++ png_info * const info_ptr,
+ FILE * const tfp,
+ bool const ztxt,
+ bool const verbose) {
+@@ -250,15 +251,16 @@
+ unsigned int commentIdx;
+ bool noCommentsYet;
+ bool eof;
++ png_textp text;
+ unsigned int allocatedComments;
+- /* Number of entries currently allocated for the info_ptr->text
++ /* Number of entries currently allocated for the text
+ array
+ */
allocatedComments = 256; /* initial value */
@@ -1391,3 +1273,940 @@
fprintf (stderr, "\n\n");
fprintf (stderr, "Mandatory or optional arguments to long options "
"are mandatory or optional\nfor short options too. "
+--- netpbm-10.47.61/converter/pbm/cmuwmtopbm.c.orig 2016-03-27 03:38:28.000000000 +0200
++++ netpbm-10.47.61/converter/pbm/cmuwmtopbm.c 2016-06-08 20:43:31.277330446 +0200
+@@ -39,20 +39,20 @@
+
+ rc = pm_readbiglong(ifP, &l);
+ if (rc == -1 )
+- pm_error(initReadError);
++ pm_error("%s", initReadError);
+ if ((uint32_t)l != CMUWM_MAGIC)
+ pm_error("bad magic number in CMU window manager file");
+ rc = pm_readbiglong(ifP, &l);
+ if (rc == -1)
+- pm_error(initReadError);
++ pm_error("%s", initReadError);
+ *colsP = l;
+ rc = pm_readbiglong(ifP, &l);
+ if (rc == -1 )
+- pm_error(initReadError);
++ pm_error("%s", initReadError);
+ *rowsP = l;
+ rc = pm_readbigshort(ifP, &s);
+ if (rc == -1)
+- pm_error(initReadError);
++ pm_error("%s", initReadError);
+ *depthP = s;
+ }
+
+--- netpbm-10.47.61/converter/pbm/pbmtocmuwm.c.orig 2016-03-27 03:38:28.000000000 +0200
++++ netpbm-10.47.61/converter/pbm/pbmtocmuwm.c 2016-06-08 20:48:55.797316874 +0200
+@@ -31,16 +31,16 @@
+
+ rc = pm_writebiglong(stdout, CMUWM_MAGIC);
+ if (rc == -1)
+- pm_error(initWriteError);
++ pm_error("%s", initWriteError);
+ rc = pm_writebiglong(stdout, cols);
+ if (rc == -1)
+- pm_error(initWriteError);
++ pm_error("%s", initWriteError);
+ rc = pm_writebiglong(stdout, rows);
+ if (rc == -1)
+- pm_error(initWriteError);
++ pm_error("%s", initWriteError);
+ rc = pm_writebigshort(stdout, (short) 1);
+ if (rc == -1)
+- pm_error(initWriteError);
++ pm_error("%s", initWriteError);
+ }
+
+
+--- netpbm-10.47.61/converter/other/pngtopam.c.orig 2016-03-27 03:38:28.000000000 +0200
++++ netpbm-10.47.61/converter/other/pngtopam.c 2016-06-10 21:50:14.703243717 +0200
+@@ -30,14 +30,6 @@
+ #include "shhopt.h"
+ #include "pam.h"
+
+-/* A hack until we can remove direct access to png_info from the program */
+-#if PNG_LIBPNG_VER >= 10400
+-#define trans_values trans_color
+-#define TRANS_ALPHA trans_alpha
+-#else
+-#define TRANS_ALPHA trans
+-#endif
+-
+ typedef struct _jmpbuf_wrapper {
+ jmp_buf jmpbuf;
+ } jmpbuf_wrapper;
+@@ -268,28 +260,31 @@ static int iscolor (png_color c)
+ return c.red != c.green || c.green != c.blue;
+ }
+
+-static void save_text (png_info *info_ptr, FILE *tfp)
++static void save_text (png_struct *png_ptr, png_info *info_ptr, FILE *tfp)
+ {
+ int i, j, k;
++ png_text *text;
++ int num_text;
+
+- for (i = 0 ; i < info_ptr->num_text ; i++) {
++ png_get_text(png_ptr, info_ptr, &text, &num_text);
++ for (i = 0 ; i < num_text ; i++) {
+ j = 0;
+- while (info_ptr->text[i].key[j] != '\0' && info_ptr->text[i].key[j] != ' ')
++ while (text[i].key[j] != '\0' && text[i].key[j] != ' ')
+ j++;
+- if (info_ptr->text[i].key[j] != ' ') {
+- fprintf (tfp, "%s", info_ptr->text[i].key);
+- for (j = strlen (info_ptr->text[i].key) ; j < 15 ; j++)
++ if (text[i].key[j] != ' ') {
++ fprintf (tfp, "%s", text[i].key);
++ for (j = strlen (text[i].key) ; j < 15 ; j++)
+ putc (' ', tfp);
+ } else {
+- fprintf (tfp, "\"%s\"", info_ptr->text[i].key);
+- for (j = strlen (info_ptr->text[i].key) ; j < 13 ; j++)
++ fprintf (tfp, "\"%s\"", text[i].key);
++ for (j = strlen (text[i].key) ; j < 13 ; j++)
+ putc (' ', tfp);
+ }
+ putc (' ', tfp); /* at least one space between key and text */
+
+- for (j = 0 ; j < info_ptr->text[i].text_length ; j++) {
+- putc (info_ptr->text[i].text[j], tfp);
+- if (info_ptr->text[i].text[j] == '\n')
++ for (j = 0 ; j < text[i].text_length ; j++) {
++ putc (text[i].text[j], tfp);
++ if (text[i].text[j] == '\n')
+ for (k = 0 ; k < 16 ; k++)
+ putc ((int)' ', tfp);
+ }
+@@ -297,25 +292,28 @@ static void save_text (png_info *info_pt
+ }
+ }
+
+-static void show_time (png_info *info_ptr)
++static void show_time (png_struct *png_ptr, png_info *info_ptr)
+ {
+ static const char * const month[] = {
+ "", "January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December"
+ };
+
+- if (info_ptr->valid & PNG_INFO_tIME) {
+- if (info_ptr->mod_time.month < 1 ||
+- info_ptr->mod_time.month >= ARRAY_SIZE(month)) {
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tIME)) {
++ png_timep mod_timep;
++
++ png_get_tIME(png_ptr, info_ptr, &mod_timep);
++ if (mod_timep->month < 1 ||
++ mod_timep->month >= ARRAY_SIZE(month)) {
+ pm_message("tIME chunk in PNG input is invalid; "
+ "modification time of image is unknown. "
+ "The month value, which should be in the range "
+- "1-12, is %u", info_ptr->mod_time.month);
++ "1-12, is %u", mod_timep->month);
+ } else
+ pm_message ("modification time: %02d %s %d %02d:%02d:%02d",
+- info_ptr->mod_time.day, month[info_ptr->mod_time.month],
+- info_ptr->mod_time.year, info_ptr->mod_time.hour,
+- info_ptr->mod_time.minute, info_ptr->mod_time.second);
++ mod_timep->day, month[mod_timep->month],
++ mod_timep->year, mod_timep->hour,
++ mod_timep->minute, mod_timep->second);
+ }
+ }
+
+@@ -346,12 +344,12 @@ static void pngtopnm_error_handler (png_
+
+
+ static void
+-dump_png_info(png_info *info_ptr) {
++dump_png_info(png_struct *png_ptr, png_info *info_ptr) {
+
+ const char *type_string;
+ const char *filter_string;
+
+- switch (info_ptr->color_type) {
++ switch (png_get_color_type(png_ptr, info_ptr)) {
+ case PNG_COLOR_TYPE_GRAY:
+ type_string = "gray";
+ break;
+@@ -373,90 +371,106 @@ dump_png_info(png_info *info_ptr) {
+ break;
+ }
+
+- switch (info_ptr->filter_type) {
++ switch (png_get_filter_type(png_ptr, info_ptr)) {
+ case PNG_FILTER_TYPE_BASE:
+ asprintfN(&filter_string, "base filter");
+ break;
+ default:
+ asprintfN(&filter_string, "unknown filter type %d",
+- info_ptr->filter_type);
++ png_get_filter_type(png_ptr, info_ptr));
+ }
+
++ {
++ png_uint_32 width, height;
++ int bit_depth;
++ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, NULL, NULL, NULL, NULL);
+ pm_message("reading a %ldw x %ldh image, %d bit%s",
+- info_ptr->width, info_ptr->height,
+- info_ptr->bit_depth, info_ptr->bit_depth > 1 ? "s" : "");
++ (long)width, (long)height,
++ bit_depth, bit_depth > 1 ? "s" : "");
++ }
+ pm_message("%s, %s, %s",
+ type_string,
+- info_ptr->interlace_type ?
++ png_get_interlace_type(png_ptr, info_ptr) ?
+ "Adam7 interlaced" : "not interlaced",
+ filter_string);
++ {
++ png_color_16p bkgp;
++ if(png_get_bKGD(png_ptr, info_ptr, &bkgp) && (bkgp != NULL))
+ pm_message("background {index, gray, red, green, blue} = "
+ "{%d, %d, %d, %d, %d}",
+- info_ptr->background.index,
+- info_ptr->background.gray,
+- info_ptr->background.red,
+- info_ptr->background.green,
+- info_ptr->background.blue);
++ bkgp->index,
++ bkgp->gray,
++ bkgp->red,
++ bkgp->green,
++ bkgp->blue);
++ }
+
+ strfree(filter_string);
+
+- if (info_ptr->valid & PNG_INFO_tRNS)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
++ int num_trans;
++ png_get_tRNS(png_ptr, info_ptr, NULL, &num_trans, NULL);
+ pm_message("tRNS chunk (transparency): %u entries",
+- info_ptr->num_trans);
+- else
++ num_trans);
++ } else
+ pm_message("tRNS chunk (transparency): not present");
+
+- if (info_ptr->valid & PNG_INFO_gAMA)
+- pm_message("gAMA chunk (image gamma): gamma = %4.2f", info_ptr->gamma);
+- else
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
++ double gamma;
++ png_get_gAMA(png_ptr, info_ptr, &gamma);
++ pm_message("gAMA chunk (image gamma): gamma = %4.2f", gamma);
++ } else
+ pm_message("gAMA chunk (image gamma): not present");
+
+- if (info_ptr->valid & PNG_INFO_sBIT)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
+ pm_message("sBIT chunk: present");
+ else
+ pm_message("sBIT chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_cHRM)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_cHRM))
+ pm_message("cHRM chunk: present");
+ else
+ pm_message("cHRM chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_PLTE)
+- pm_message("PLTE chunk: %d entries", info_ptr->num_palette);
+- else
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE)) {
++ png_colorp palette;
++ int num_palette;
++ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
++ pm_message("PLTE chunk: %d entries", num_palette);
++ } else
+ pm_message("PLTE chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_bKGD)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
+ pm_message("bKGD chunk: present");
+ else
+ pm_message("bKGD chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_hIST)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_hIST))
+ pm_message("hIST chunk: present");
+ else
+ pm_message("hIST chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_pHYs)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs))
+ pm_message("pHYs chunk: present");
+ else
+ pm_message("pHYs chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_oFFs)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_oFFs))
+ pm_message("oFFs chunk: present");
+ else
+ pm_message("oFFs chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_tIME)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tIME))
+ pm_message("tIME chunk: present");
+ else
+ pm_message("tIME chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_pCAL)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pCAL))
+ pm_message("pCAL chunk: present");
+ else
+ pm_message("pCAL chunk: not present");
+
+- if (info_ptr->valid & PNG_INFO_sRGB)
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sRGB))
+ pm_message("sRGB chunk: present");
+ else
+ pm_message("sRGB chunk: not present");
+@@ -465,44 +479,50 @@ dump_png_info(png_info *info_ptr) {
+
+
+ static unsigned int
+-computePngLineSize(png_info * const pngInfoP) {
+-
+- unsigned int const bytesPerSample = pngInfoP->bit_depth == 16 ? 2 : 1;
++computePngLineSize(png_struct * const pngP, png_info * const pngInfoP) {
+
++ png_uint_32 width;
++ int bit_depth, color_type;
++ unsigned int bytesPerSample;
+ unsigned int samplesPerPixel;
+
+- switch (pngInfoP->color_type) {
++ png_get_IHDR(pngP, pngInfoP, &width, NULL, &bit_depth, &color_type, NULL, NULL, NULL);
++ bytesPerSample = (bit_depth == 16) ? 2 : 1;
++
++ switch (color_type) {
+ case PNG_COLOR_TYPE_GRAY_ALPHA: samplesPerPixel = 2; break;
+ case PNG_COLOR_TYPE_RGB: samplesPerPixel = 3; break;
+ case PNG_COLOR_TYPE_RGB_ALPHA: samplesPerPixel = 4; break;
+ default: samplesPerPixel = 1;
+ }
+
+- if (UINT_MAX / bytesPerSample / samplesPerPixel < pngInfoP->width)
++ if (UINT_MAX / bytesPerSample / samplesPerPixel < width)
+ pm_error("Width %u of PNG is uncomputably large",
+- (unsigned int)pngInfoP->width);
++ (unsigned int)width);
+
+- return pngInfoP->width * bytesPerSample * samplesPerPixel;
++ return width * bytesPerSample * samplesPerPixel;
+ }
+
+
+
+ static void
+-allocPngRaster(png_info * const pngInfoP,
++allocPngRaster(png_struct * const pngP,
++ png_info * const pngInfoP,
+ png_byte *** const pngImageP) {
+
+- unsigned int const lineSize = computePngLineSize(pngInfoP);
++ unsigned int const lineSize = computePngLineSize(pngP, pngInfoP);
+
+ png_byte ** pngImage;
++ png_uint_32 height = png_get_image_height(pngP, pngInfoP);
+ unsigned int row;
+
+- MALLOCARRAY(pngImage, pngInfoP->height);
++ MALLOCARRAY(pngImage, height);
+
+ if (pngImage == NULL)
+ pm_error("couldn't allocate space for %u PNG raster rows",
+- (unsigned int)pngInfoP->height);
++ (unsigned int)height);
+
+- for (row = 0; row < pngInfoP->height; ++row) {
++ for (row = 0; row < height; ++row) {
+ MALLOCARRAY(pngImage[row], lineSize);
+ if (pngImage[row] == NULL)
+ pm_error("couldn't allocate space for %uth row of PNG raster",
+@@ -515,11 +535,12 @@ allocPngRaster(png_info * const pngInf
+
+ static void
+ freePngRaster(png_byte ** const pngRaster,
++ png_struct* const pngP,
+ png_info * const pngInfoP) {
+
+ unsigned int row;
+
+- for (row = 0; row < pngInfoP->height; ++row)
++ for (row = 0; row < png_get_image_height(pngP, pngInfoP); ++row)
+ free(pngRaster[row]);
+
+ free(pngRaster);
+@@ -529,6 +550,7 @@ freePngRaster(png_byte ** const pngRaste
+
+ static bool
+ isTransparentColor(pngcolor const color,
++ png_struct * const pngP,
+ png_info * const pngInfoP,
+ double const totalgamma) {
+ /*----------------------------------------------------------------------------
+@@ -539,8 +561,9 @@ isTransparentColor(pngcolor const colo
+ -----------------------------------------------------------------------------*/
+ bool retval;
+
+- if (pngInfoP->valid & PNG_INFO_tRNS) {
+- const png_color_16 * const transColorP = &pngInfoP->trans_values;
++ if (png_get_valid(pngP, pngInfoP, PNG_INFO_tRNS)) {
++ png_color_16 * transColorP;
++ png_get_tRNS(pngP, pngInfoP, NULL, NULL, &transColorP);
+
+ /* It seems odd that libpng lets you get gamma-corrected pixel
+ values, but not gamma-corrected transparency or background
+@@ -556,7 +579,7 @@ isTransparentColor(pngcolor const colo
+ pixels, and just do it ourselves.
+ */
+
+- switch (pngInfoP->color_type) {
++ switch (png_get_color_type(pngP, pngInfoP)) {
+ case PNG_COLOR_TYPE_GRAY:
+ retval = color.r == gamma_correct(transColorP->gray, totalgamma);
+ break;
+@@ -603,9 +626,11 @@ setupGammaCorrection(png_struct * const
+ *totalgammaP = -1.0;
+ else {
+ float imageGamma;
+- if (info_ptr->valid & PNG_INFO_gAMA)
+- imageGamma = info_ptr->gamma;
+- else {
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
++ double gamma;
++ png_get_gAMA(png_ptr, info_ptr, &gamma);
++ imageGamma = gamma;
++ } else {
+ if (verbose)
+ pm_message("PNG doesn't specify image gamma. Assuming 1.0");
+ imageGamma = 1.0;
+@@ -623,7 +648,7 @@ setupGammaCorrection(png_struct * const
+ /* in case of gamma-corrections, sBIT's as in the
+ PNG-file are not valid anymore
+ */
+- info_ptr->valid &= ~PNG_INFO_sBIT;
++ png_set_invalid(png_ptr, info_ptr, PNG_INFO_sBIT);
+ if (verbose)
+ pm_message("image gamma is %4.2f, "
+ "converted for display gamma of %4.2f",
+@@ -635,20 +660,23 @@ setupGammaCorrection(png_struct * const
+
+
+ static bool
+-paletteHasPartialTransparency(png_info * const info_ptr) {
++paletteHasPartialTransparency(png_struct * const png_ptr, png_info * const info_ptr) {
+
+ bool retval;
+
+- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+- if (info_ptr->valid & PNG_INFO_tRNS) {
++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+ bool foundGray;
+ unsigned int i;
++ int num_trans;
++ png_bytep trans_alpha;
++ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, NULL);
+
+ for (i = 0, foundGray = FALSE;
+- i < info_ptr->num_trans && !foundGray;
++ i < num_trans && !foundGray;
+ ++i) {
+- if (info_ptr->TRANS_ALPHA[i] != 0 &&
+- info_ptr->TRANS_ALPHA[i] != maxval) {
++ if (trans_alpha[i] != 0 &&
++ trans_alpha[i] != maxval) {
+ foundGray = TRUE;
+ }
+ }
+@@ -664,34 +692,44 @@ paletteHasPartialTransparency(png_info *
+
+
+ static void
+-getComponentSbitFg(png_info * const pngInfoP,
++getComponentSbitFg(png_struct * const pngP,
++ png_info * const pngInfoP,
+ png_byte * const fgSbitP,
+ bool * const notUniformP) {
+
+- if (pngInfoP->color_type == PNG_COLOR_TYPE_RGB ||
+- pngInfoP->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+- pngInfoP->color_type == PNG_COLOR_TYPE_PALETTE) {
+- if (pngInfoP->sig_bit.red == pngInfoP->sig_bit.blue &&
+- pngInfoP->sig_bit.red == pngInfoP->sig_bit.green) {
++ int color_type = png_get_color_type(pngP, pngInfoP);
++ png_color_8p sig_bit;
++ png_get_sBIT(pngP, pngInfoP, &sig_bit);
++
++ if (color_type == PNG_COLOR_TYPE_RGB ||
++ color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ color_type == PNG_COLOR_TYPE_PALETTE) {
++
++ if (sig_bit->red == sig_bit->blue &&
++ sig_bit->red == sig_bit->green) {
+ *notUniformP = false;
+- *fgSbitP = pngInfoP->sig_bit.red;
++ *fgSbitP = sig_bit->red;
+ } else
+ *notUniformP = true;
+ } else {
+ /* It has only a gray channel so it's obviously uniform */
+ *notUniformP = false;
+- *fgSbitP = pngInfoP->sig_bit.gray;
++ *fgSbitP = sig_bit->gray;
+ }
+ }
+
+
+
+ static void
+-getComponentSbit(png_info * const pngInfoP,
++getComponentSbit(png_struct * const pngP,
++ png_info * const pngInfoP,
+ enum alpha_handling const alphaHandling,
+ png_byte * const componentSbitP,
+ bool * const notUniformP) {
+
++ png_color_8p sig_bit;
++ png_get_sBIT(pngP, pngInfoP, &sig_bit);
++
+ switch (alphaHandling) {
+
+ case ALPHA_ONLY:
+@@ -699,26 +737,26 @@ getComponentSbit(png_info * con
+ the alpha Sbit
+ */
+ *notUniformP = false;
+- *componentSbitP = pngInfoP->sig_bit.alpha;
++ *componentSbitP = sig_bit->alpha;
+ break;
+ case ALPHA_NONE:
+ case ALPHA_MIX:
+ /* We aren't going to produce an alpha channel, so we care only
+ about the uniformity of the foreground channels.
+ */
+- getComponentSbitFg(pngInfoP, componentSbitP, notUniformP);
++ getComponentSbitFg(pngP, pngInfoP, componentSbitP, notUniformP);
+ break;
+ case ALPHA_IN: {
+ /* We care about both the foreground and the alpha */
+ bool fgNotUniform;
+ png_byte fgSbit;
+
+- getComponentSbitFg(pngInfoP, &fgSbit, &fgNotUniform);
++ getComponentSbitFg(pngP, pngInfoP, &fgSbit, &fgNotUniform);
+
+ if (fgNotUniform)
+ *notUniformP = true;
+ else {
+- if (fgSbit == pngInfoP->sig_bit.alpha) {
++ if (fgSbit == sig_bit->alpha) {
+ *notUniformP = false;
+ *componentSbitP = fgSbit;
+ } else
+@@ -731,7 +769,8 @@ getComponentSbit(png_info * con
+
+
+ static void
+-shiftPalette(png_info * const pngInfoP,
++shiftPalette(png_struct * const pngP,
++ png_info * const pngInfoP,
+ unsigned int const shift) {
+ /*----------------------------------------------------------------------------
+ Shift every component of every color in the PNG palette right by
+@@ -744,11 +783,14 @@ shiftPalette(png_info * const pngInfoP
+ shift);
+ else {
+ unsigned int i;
+-
+- for (i = 0; i < pngInfoP->num_palette; ++i) {
+- pngInfoP->palette[i].red >>= (8 - shift);
+- pngInfoP->palette[i].green >>= (8 - shift);
+- pngInfoP->palette[i].blue >>= (8 - shift);
++ int num_palette;
++ png_colorp palette;
++ png_get_PLTE(pngP, pngInfoP, &palette, &num_palette);
++
++ for (i = 0; i < num_palette; ++i) {
++ palette[i].red >>= (8 - shift);
++ palette[i].green >>= (8 - shift);
++ palette[i].blue >>= (8 - shift);
+ }
+ }
+ }
+@@ -782,12 +824,12 @@ computeMaxvalFromSbit(png_struct *
+ Meaningless if they aren't all the same (i.e. 'notUniform')
+ */
+
+- getComponentSbit(pngInfoP, alphaHandling, &componentSigBit, ¬Uniform);
++ getComponentSbit(pngP, pngInfoP, alphaHandling, &componentSigBit, ¬Uniform);
+
+ if (notUniform) {
+ pm_message("This program cannot handle "
+ "different bit depths for color channels");
+- pm_message("writing file with %u bit resolution", pngInfoP->bit_depth);
++ pm_message("writing file with %u bit resolution", png_get_bit_depth(pngP, pngInfoP));
+ *succeededP = false;
+ *errorlevelP = PNMTOPNG_WARNING_LEVEL;
+ } else if (componentSigBit > 15) {
+@@ -797,22 +839,26 @@ computeMaxvalFromSbit(png_struct *
+ *succeededP = false;
+ *errorlevelP = PNMTOPNG_WARNING_LEVEL;
+ } else {
++ int color_type = png_get_color_type(pngP, pngInfoP);
+ if (alphaHandling == ALPHA_MIX &&
+- (pngInfoP->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
+- pngInfoP->color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
+- paletteHasPartialTransparency(pngInfoP)))
++ (color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
++ color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
++ paletteHasPartialTransparency(pngP, pngInfoP)))
+ *succeededP = false;
+ else {
+- if (componentSigBit < pngInfoP->bit_depth) {
++ if (componentSigBit < png_get_bit_depth(pngP, pngInfoP)) {
+ pm_message("Image has fewer significant bits, "
+ "writing file with %u bits", componentSigBit);
+ *maxvalP = (1l << componentSigBit) - 1;
+ *succeededP = true;
+
+- if (pngInfoP->color_type == PNG_COLOR_TYPE_PALETTE)
+- shiftPalette(pngInfoP, componentSigBit);
+- else
+- png_set_shift(pngP, &pngInfoP->sig_bit);
++ if (color_type == PNG_COLOR_TYPE_PALETTE)
++ shiftPalette(pngP, pngInfoP, componentSigBit);
++ else {
++ png_color_8p sig_bit;
++ png_get_sBIT(pngP, pngInfoP, &sig_bit);
++ png_set_shift(pngP, sig_bit);
++ }
+ } else
+ *succeededP = false;
+ }
+@@ -838,22 +884,23 @@ setupSignificantBits(png_struct *
+ -----------------------------------------------------------------------------*/
+ bool gotItFromSbit;
+
+- if (pngInfoP->valid & PNG_INFO_sBIT)
++ if (png_get_valid(pngP, pngInfoP, PNG_INFO_sBIT))
+ computeMaxvalFromSbit(pngP, pngInfoP, alphaHandling,
+ maxvalP, &gotItFromSbit, errorlevelP);
+ else
+ gotItFromSbit = false;
+
+ if (!gotItFromSbit) {
+- if (pngInfoP->color_type == PNG_COLOR_TYPE_PALETTE) {
++ int color_type = png_get_color_type(pngP, pngInfoP);
++ if (color_type == PNG_COLOR_TYPE_PALETTE) {
+ if (alphaHandling == ALPHA_ONLY) {
+- if (pngInfoP->color_type == PNG_COLOR_TYPE_GRAY ||
+- pngInfoP->color_type == PNG_COLOR_TYPE_RGB)
++ if (color_type == PNG_COLOR_TYPE_GRAY ||
++ color_type == PNG_COLOR_TYPE_RGB)
+ /* The alpha mask will be all opaque, so maxval 1
+ is plenty
+ */
+ *maxvalP = 1;
+- else if (paletteHasPartialTransparency(pngInfoP))
++ else if (paletteHasPartialTransparency(pngP, pngInfoP))
+ /* Use same maxval as PNG transparency palette for
+ simplicity
+ */
+@@ -865,7 +912,7 @@ setupSignificantBits(png_struct *
+ /* Use same maxval as PNG palette for simplicity */
+ *maxvalP = 255;
+ } else {
+- *maxvalP = (1l << pngInfoP->bit_depth) - 1;
++ *maxvalP = (1l << png_get_bit_depth(pngP, pngInfoP)) - 1;
+ }
+ }
+ }
+@@ -873,22 +920,27 @@ setupSignificantBits(png_struct *
+
+
+ static bool
+-imageHasColor(png_info * const info_ptr) {
++imageHasColor(png_struct * const png_ptr, png_info * const info_ptr) {
+
+ bool retval;
++ int color_type = png_get_color_type(png_ptr, info_ptr);
+
+- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
+- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
++ if (color_type == PNG_COLOR_TYPE_GRAY ||
++ color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+
+ retval = FALSE;
+- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
++ else if (color_type == PNG_COLOR_TYPE_PALETTE) {
+ bool foundColor;
+ unsigned int i;
++ int num_palette;
++ png_colorp palette;
++
++ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
+
+ for (i = 0, foundColor = FALSE;
+- i < info_ptr->num_palette && !foundColor;
++ i < num_palette && !foundColor;
+ ++i) {
+- if (iscolor(info_ptr->palette[i]))
++ if (iscolor(palette[i]))
+ foundColor = TRUE;
+ }
+ retval = foundColor;
+@@ -901,7 +953,8 @@ imageHasColor(png_info * const info_ptr)
+
+
+ static void
+-determineOutputType(png_info * const pngInfoP,
++determineOutputType(png_struct * const pngP,
++ png_info * const pngInfoP,
+ enum alpha_handling const alphaHandling,
+ pngcolor const bgColor,
+ xelval const maxval,
+@@ -916,7 +969,7 @@ determineOutputType(png_info *
+ } else {
+ /* The output is a normal Netpbm image */
+ bool const outputIsColor =
+- imageHasColor(pngInfoP) || !isGrayscale(bgColor);
++ imageHasColor(pngP, pngInfoP) || !isGrayscale(bgColor);
+
+ if (alphaHandling == ALPHA_IN) {
+ *formatP = PAM_FORMAT;
+@@ -942,7 +995,8 @@ determineOutputType(png_info *
+
+
+ static void
+-getBackgroundColor(png_info * const info_ptr,
++getBackgroundColor(png_struct * const png_ptr,
++ png_info * const info_ptr,
+ const char * const requestedColor,
+ float const totalgamma,
+ xelval const maxval,
+@@ -964,19 +1018,26 @@ getBackgroundColor(png_info * const in
+ bgColorP->g = PPM_GETG(backcolor);
+ bgColorP->b = PPM_GETB(backcolor);
+
+- } else if (info_ptr->valid & PNG_INFO_bKGD) {
++ } else if (png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD)) {
++ png_color_16p background;
++ png_get_bKGD(png_ptr, info_ptr, &background);
+ /* didn't manage to get libpng to work (bugs?) concerning background
+ processing, therefore we do our own.
+ */
+- switch (info_ptr->color_type) {
++ switch (png_get_color_type(png_ptr, info_ptr)) {
+ case PNG_COLOR_TYPE_GRAY:
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ bgColorP->r = bgColorP->g = bgColorP->b =
+- gamma_correct(info_ptr->background.gray, totalgamma);
++ gamma_correct(background->gray, totalgamma);
+ break;
+ case PNG_COLOR_TYPE_PALETTE: {
+- png_color const rawBgcolor =
+- info_ptr->palette[info_ptr->background.index];
++ png_color rawBgcolor;
++ png_colorp palette;
++ int num_palette;
++
++ png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
++ rawBgcolor =
++ palette[background->index];
+ bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
+ bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
+ bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma);
+@@ -984,7 +1045,7 @@ getBackgroundColor(png_info * const in
+ break;
+ case PNG_COLOR_TYPE_RGB:
+ case PNG_COLOR_TYPE_RGB_ALPHA: {
+- png_color_16 const rawBgcolor = info_ptr->background;
++ png_color_16 const rawBgcolor = *background;
+
+ bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma);
+ bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma);
+@@ -999,13 +1060,14 @@ getBackgroundColor(png_info * const in
+
+
+
+-#define GET_PNG_VAL(p) get_png_val(&(p), pngInfoP->bit_depth)
++#define GET_PNG_VAL(p) get_png_val(&(p), png_get_bit_depth(pngP, pngInfoP))
+
+
+
+ static void
+ makeTupleRow(const struct pam * const pamP,
+ const tuple * const tuplerow,
++ png_struct * const pngP,
+ png_info * const pngInfoP,
+ const png_byte * const pngRasterRow,
+ pngcolor const bgColor,
+@@ -1016,13 +1078,13 @@ makeTupleRow(const struct pam * const p
+ unsigned int col;
+
+ pngPixelP = &pngRasterRow[0]; /* initial value */
+- for (col = 0; col < pngInfoP->width; ++col) {
+- switch (pngInfoP->color_type) {
++ for (col = 0; col < png_get_image_width(pngP, pngInfoP); ++col) {
++ switch (png_get_color_type(pngP, pngInfoP)) {
+ case PNG_COLOR_TYPE_GRAY: {
+ pngcolor fgColor;
+ fgColor.r = fgColor.g = fgColor.b = GET_PNG_VAL(pngPixelP);
+ setTuple(pamP, tuplerow[col], fgColor, bgColor, alphaHandling,
+- isTransparentColor(fgColor, pngInfoP, totalgamma) ?
++ isTransparentColor(fgColor, pngP, pngInfoP, totalgamma) ?
+ 0 : maxval);
+ }
+ break;
+@@ -1040,18 +1102,26 @@ makeTupleRow(const struct pam * const p
+
+ case PNG_COLOR_TYPE_PALETTE: {
+ png_uint_16 const index = GET_PNG_VAL(pngPixelP);
+- png_color const paletteColor = pngInfoP->palette[index];
+-
++ png_color paletteColor;
++ bool transValid = png_get_valid(pngP, pngInfoP, PNG_INFO_tRNS);
++ png_bytep trans_alpha;
++ int num_trans, num_palette;
++ png_colorp palette;
+ pngcolor fgColor;
+
++ png_get_PLTE(pngP, pngInfoP, &palette, &num_palette);
++ paletteColor = palette[index];
++
+ fgColor.r = paletteColor.red;
+ fgColor.g = paletteColor.green;
+ fgColor.b = paletteColor.blue;
+
++ if (transValid)
++ png_get_tRNS(pngP, pngInfoP, &trans_alpha, &num_trans, NULL);
+ setTuple(pamP, tuplerow[col], fgColor, bgColor, alphaHandling,
+- (pngInfoP->valid & PNG_INFO_tRNS) &&
+- index < pngInfoP->num_trans ?
+- pngInfoP->TRANS_ALPHA[index] : maxval);
++ transValid &&
++ index < num_trans ?
++ trans_alpha[index] : maxval);
+ }
+ break;
+
+@@ -1062,7 +1132,7 @@ makeTupleRow(const struct pam * const p
+ fgColor.g = GET_PNG_VAL(pngPixelP);
+ fgColor.b = GET_PNG_VAL(pngPixelP);
+ setTuple(pamP, tuplerow[col], fgColor, bgColor, alphaHandling,
+- isTransparentColor(fgColor, pngInfoP, totalgamma) ?
++ isTransparentColor(fgColor, pngP, pngInfoP, totalgamma) ?
+ 0 : maxval);
+ }
+ break;
+@@ -1081,7 +1151,7 @@ makeTupleRow(const struct pam * const p
+ break;
+
+ default:
+- pm_error("unknown PNG color type: %d", pngInfoP->color_type);
++ pm_error("unknown PNG color type: %d", png_get_color_type(pngP, pngInfoP));
+ }
+ }
+ }
+@@ -1115,6 +1185,7 @@ reportOutputFormat(const struct pam * co
+
+ static void
+ writeNetpbm(struct pam * const pamP,
++ png_struct * const pngP,
+ png_info * const pngInfoP,
+ png_byte ** const pngRaster,
+ pngcolor const bgColor,
+@@ -1141,8 +1212,8 @@ writeNetpbm(struct pam * const pa
+
+ tuplerow = pnm_allocpamrow(pamP);
+
+- for (row = 0; row < pngInfoP->height; ++row) {
+- makeTupleRow(pamP, tuplerow, pngInfoP, pngRaster[row], bgColor,
++ for (row = 0; row < png_get_image_height(pngP, pngInfoP); ++row) {
++ makeTupleRow(pamP, tuplerow, pngP, pngInfoP, pngRaster[row], bgColor,
+ alphaHandling, totalgamma);
+
+ pnm_writepamrow(pamP, tuplerow);
+@@ -1186,9 +1257,9 @@ convertpng(FILE * const ifp,
+ png_set_sig_bytes (png_ptr, SIG_CHECK_SIZE);
+ png_read_info (png_ptr, info_ptr);
+
+- allocPngRaster(info_ptr, &png_image);
++ allocPngRaster(png_ptr, info_ptr, &png_image);
+
+- if (info_ptr->bit_depth < 8)
++ if (png_get_bit_depth(png_ptr, info_ptr) < 8)
+ png_set_packing (png_ptr);
+
+ setupGammaCorrection(png_ptr, info_ptr, cmdline.gamma, &totalgamma);
+@@ -1196,7 +1267,7 @@ convertpng(FILE * const ifp,
+ setupSignificantBits(png_ptr, info_ptr, cmdline.alpha,
+ &maxval, errorlevelP);
+
+- getBackgroundColor(info_ptr, cmdline.background, totalgamma, maxval,
++ getBackgroundColor(png_ptr, info_ptr, cmdline.background, totalgamma, maxval,
+ &bgColor);
+
+ png_read_image(png_ptr, png_image);
+@@ -1207,16 +1278,19 @@ convertpng(FILE * const ifp,
+ completes. That's because it comes from chunks that are at the
+ end of the stream.
+ */
+- dump_png_info(info_ptr);
++ dump_png_info(png_ptr, info_ptr);
+
+ if (cmdline.time)
+- show_time(info_ptr);
++ show_time(png_ptr, info_ptr);
+ if (tfp)
+- save_text(info_ptr, tfp);
++ save_text(png_ptr, info_ptr, tfp);
++
++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs)) {
++ float r;
++ png_uint_32 x_pixels_per_unit, y_pixels_per_unit;
+
+- if (info_ptr->valid & PNG_INFO_pHYs) {
+- float const r =
+- (float)info_ptr->x_pixels_per_unit / info_ptr->y_pixels_per_unit;
++ png_get_pHYs(png_ptr, info_ptr, &x_pixels_per_unit, &y_pixels_per_unit, NULL);
++ r = (float)x_pixels_per_unit / y_pixels_per_unit;
+ if (r != 1.0) {
+ pm_message ("warning - non-square pixels; "
+ "to fix do a 'pamscale -%cscale %g'",
+@@ -1230,18 +1304,18 @@ convertpng(FILE * const ifp,
+ pam.len = PAM_STRUCT_SIZE(tuple_type);
+ pam.file = stdout;
+ pam.plainformat = 0;
+- pam.height = info_ptr->height;
+- pam.width = info_ptr->width;
++ pam.height = png_get_image_height(png_ptr, info_ptr);
++ pam.width = png_get_image_width(png_ptr, info_ptr);
+ pam.maxval = maxval;
+
+- determineOutputType(info_ptr, cmdline.alpha, bgColor, maxval,
++ determineOutputType(png_ptr, info_ptr, cmdline.alpha, bgColor, maxval,
+ &pam.format, &pam.depth, pam.tuple_type);
+
+- writeNetpbm(&pam, info_ptr, png_image, bgColor, cmdline.alpha, totalgamma);
++ writeNetpbm(&pam, png_ptr, info_ptr, png_image, bgColor, cmdline.alpha, totalgamma);
+
+ fflush(stdout);
+
+- freePngRaster(png_image, info_ptr);
++ freePngRaster(png_image, png_ptr, info_ptr);
+
+ png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+ }
================================================================
---- gitweb:
http://git.pld-linux.org/gitweb.cgi/packages/netpbm.git/commitdiff/0418bf0c78c2eacf8688ab7272ef1f0765b290bf
More information about the pld-cvs-commit
mailing list