From d8caad385f7b3ba755278e55526940fe0f708daf Mon Sep 17 00:00:00 2001 From: tron Date: Sat, 15 Jan 2011 18:37:46 +0000 Subject: Update "netpbm" package to version 10.35.78. Changes since 10.35.77: - bmptopnm: Don't crash on invalid zero value of image height in the BMP header of a compressed file. Always broken. - bmptopnm: don't crash on large invalid value of 'colorsused' in the BMP header. - ilbmtoppm: Don't crash on image that has a transparent color index, but no color map. "pkgsrc" changes: - Add a lot of patches written by Thomas Klausner and me to make this compile with PNG 1.5. --- graphics/netpbm/Makefile | 5 +- graphics/netpbm/distinfo | 13 +- graphics/netpbm/patches/patch-ac | 55 +-- graphics/netpbm/patches/patch-af | 878 +++++++++++++++++++++++++++++++++++++-- graphics/netpbm/patches/patch-al | 19 + 5 files changed, 910 insertions(+), 60 deletions(-) create mode 100644 graphics/netpbm/patches/patch-al (limited to 'graphics/netpbm') diff --git a/graphics/netpbm/Makefile b/graphics/netpbm/Makefile index 178957fadb5..38526cc6395 100644 --- a/graphics/netpbm/Makefile +++ b/graphics/netpbm/Makefile @@ -1,7 +1,6 @@ -# $NetBSD: Makefile,v 1.171 2011/01/13 13:36:07 wiz Exp $ +# $NetBSD: Makefile,v 1.172 2011/01/15 18:37:46 tron Exp $ -DISTNAME= netpbm-10.35.77 -PKGREVISION= 1 +DISTNAME= netpbm-10.35.78 CATEGORIES= graphics MASTER_SITES= ${MASTER_SITE_SOURCEFORGE:=netpbm/} EXTRACT_SUFX= .tgz diff --git a/graphics/netpbm/distinfo b/graphics/netpbm/distinfo index 5df786146f1..7874726aaee 100644 --- a/graphics/netpbm/distinfo +++ b/graphics/netpbm/distinfo @@ -1,19 +1,20 @@ -$NetBSD: distinfo,v 1.81 2011/01/15 08:15:47 tron Exp $ +$NetBSD: distinfo,v 1.82 2011/01/15 18:37:46 tron Exp $ -SHA1 (netpbm-10.35.77.tgz) = 81a2b02db339e2bae8cc38db9b987b1cb0b228e2 -RMD160 (netpbm-10.35.77.tgz) = e7d7fa5a696ef962fd8d61eaed803548716e510c -Size (netpbm-10.35.77.tgz) = 2547233 bytes +SHA1 (netpbm-10.35.78.tgz) = 5749b108fb2c1b3369c43b70245197fec3a751e5 +RMD160 (netpbm-10.35.78.tgz) = 40e193485857114f5989cc1a6af166d6b841b273 +Size (netpbm-10.35.78.tgz) = 2547337 bytes SHA1 (patch-aa) = fb94fb43c4c63113e9c720ea399a5cecb2c79977 SHA1 (patch-ab) = 4d6508ad837d455ea3f8ebaa704f33f9e089f6e0 -SHA1 (patch-ac) = fa9750f4c243350edfb3dfafc8d7a7c49ce2ecdf +SHA1 (patch-ac) = 11c029673a53e9344a477db6cfcb46f32e9f6a93 SHA1 (patch-ad) = b4a5833e18afd5a991aad897674386a3f00c3ee1 SHA1 (patch-ae) = 33a5be2843dd85b530f5e6ba496cd0380cd5edd1 -SHA1 (patch-af) = 7ac8b5a431cd007ccc23ea337194a5c542ff0a54 +SHA1 (patch-af) = 5f01bb5bcbdd5b290955b9ad3a9ebc36be84b0ec SHA1 (patch-ag) = 093fe392a3e6156cc55f225a6f139842c0d00570 SHA1 (patch-ah) = 10d7e7f59a0d7c857531db872cd35dc02a048ba1 SHA1 (patch-ai) = 083ddf8b36a74ca39508b6a3b0c35956ac19fbb7 SHA1 (patch-aj) = 44521e88f446a9a4eea6d9ffeb20ceba4653faca SHA1 (patch-ak) = f1e06e236442c96670b1f1829d4e67d051ecb776 +SHA1 (patch-al) = 3a7c804f608dd3e24070a76b8ad8e9b5e1ab958e SHA1 (patch-ao) = b4307205f605d4c9c8f11c00e1a633960b33b2d3 SHA1 (patch-aw) = bd890324e95fa7bb893d9d5cdab9d5a33dcff777 SHA1 (patch-ax) = d50e56191192b4caf423ed081581868bb1a63de8 diff --git a/graphics/netpbm/patches/patch-ac b/graphics/netpbm/patches/patch-ac index e46b422c901..a6ef9cbc656 100644 --- a/graphics/netpbm/patches/patch-ac +++ b/graphics/netpbm/patches/patch-ac @@ -1,9 +1,9 @@ -$NetBSD: patch-ac,v 1.21 2011/01/15 08:15:47 tron Exp $ +$NetBSD: patch-ac,v 1.22 2011/01/15 18:37:46 tron Exp $ Fix build with png-1.5. ---- converter/other/pnmtopng.c.orig 2010-07-10 02:38:01.000000000 +0100 -+++ converter/other/pnmtopng.c 2011-01-14 21:49:17.000000000 +0000 +--- converter/other/pnmtopng.c.orig 2010-12-10 18:19:40.000000000 +0000 ++++ converter/other/pnmtopng.c 2011-01-15 11:15:25.000000000 +0000 @@ -61,7 +61,8 @@ #include #include /* strcat() */ @@ -14,19 +14,21 @@ Fix build with png-1.5. #include "pnm.h" #include "pngtxt.h" #include "shhopt.h" -@@ -69,11 +70,6 @@ +@@ -69,13 +70,6 @@ #include "nstring.h" #include "version.h" -#if PNG_LIBPNG_VER >= 10400 -#error Your PNG library () 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) +-#error newer Netpbm source code (at least 10.47.04) -#endif - - +- +- struct zlibCompression { -@@ -2079,6 +2075,7 @@ + /* These are parameters that describe a form of zlib compression. + Values have the same meaning as the similarly named arguments to +@@ -2079,6 +2073,7 @@ gray * const alpha_mask, colorhash_table const cht, coloralphahash_table const caht, @@ -34,7 +36,7 @@ Fix build with png-1.5. png_info * const info_ptr, xelval const png_maxval, unsigned int const depth) { -@@ -2091,20 +2088,20 @@ +@@ -2091,20 +2086,20 @@ xel p_png; xel const p = xelrow[col]; PPM_DEPTH(p_png, p, maxval, png_maxval); @@ -60,7 +62,7 @@ Fix build with png-1.5. if (depth == 16) *pp++ = PPM_GETR(p_png) >> 8; *pp++ = PPM_GETR(p_png) & 0xff; -@@ -2117,7 +2114,7 @@ +@@ -2117,7 +2112,7 @@ } else pm_error("INTERNAL ERROR: undefined color_type"); @@ -69,7 +71,7 @@ Fix build with png-1.5. int const png_alphaval = (int) alpha_mask[col] * (float) png_maxval / maxval + 0.5; if (depth == 16) -@@ -2174,7 +2171,7 @@ +@@ -2174,7 +2169,7 @@ makePngLine(line, xelrow, cols, maxval, alpha, alpha ? alpha_mask[row] : NULL, @@ -78,7 +80,7 @@ Fix build with png-1.5. png_write_row(png_ptr, line); } -@@ -2186,12 +2183,12 @@ +@@ -2186,12 +2181,12 @@ static void doGamaChunk(struct cmdlineInfo const cmdline, @@ -93,7 +95,7 @@ Fix build with png-1.5. } } -@@ -2199,20 +2196,15 @@ +@@ -2199,20 +2194,15 @@ static void doChrmChunk(struct cmdlineInfo const cmdline, @@ -119,7 +121,7 @@ Fix build with png-1.5. } } -@@ -2220,15 +2212,12 @@ +@@ -2220,15 +2210,12 @@ static void doPhysChunk(struct cmdlineInfo const cmdline, @@ -137,7 +139,7 @@ Fix build with png-1.5. } } -@@ -2237,26 +2226,28 @@ +@@ -2237,26 +2224,28 @@ static void doTimeChunk(struct cmdlineInfo const cmdline, @@ -171,7 +173,7 @@ Fix build with png-1.5. (pngMaxval > maxval || (alpha && pngMaxval > alphaMaxval))) { /* We're writing in a bit depth that doesn't match the maxval -@@ -2275,26 +2266,28 @@ +@@ -2275,26 +2264,28 @@ sBIT chunk. */ @@ -213,7 +215,7 @@ Fix build with png-1.5. } } } -@@ -2391,6 +2384,8 @@ +@@ -2391,6 +2382,8 @@ xelval maxmaxval; gray ** alpha_mask; @@ -222,7 +224,7 @@ Fix build with png-1.5. /* these guys are initialized to quiet compiler warnings: */ maxmaxval = 255; alpha_mask = NULL; -@@ -2576,43 +2571,42 @@ +@@ -2576,43 +2569,42 @@ pm_error ("setjmp returns error condition (2)"); } @@ -288,7 +290,7 @@ Fix build with png-1.5. } /* creating hIST chunk */ if (cmdline.hist) { -@@ -2638,18 +2632,17 @@ +@@ -2638,18 +2630,17 @@ ppm_freecolorhash(cht); @@ -313,7 +315,7 @@ Fix build with png-1.5. } } else { /* This is PNG_COLOR_MASK_ALPHA. Transparency will be handled -@@ -2657,43 +2650,43 @@ +@@ -2657,43 +2648,49 @@ */ } if (verbose) { @@ -343,10 +345,15 @@ Fix build with png-1.5. - info_ptr->valid |= PNG_INFO_bKGD; - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { - info_ptr->background.index = background_index; -- } else { ++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { ++ png_color_16 background; ++ ++ (void)memset(&background, 0, sizeof(background)); ++ background.index = background_index; ++ png_set_bKGD(png_ptr, info_ptr, &background); + } else { - info_ptr->background = - xelToPngColor_16(backcolor, maxval, png_maxval); -+ if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE) { + png_color_16 background = xelToPngColor_16(backcolor, maxval, png_maxval); + png_set_bKGD(png_ptr, info_ptr, &background); if (verbose) @@ -376,7 +383,7 @@ Fix build with png-1.5. if (cmdline.filterSet != 0) png_set_filter(png_ptr, 0, cmdline.filterSet); -@@ -2703,6 +2696,7 @@ +@@ -2703,6 +2700,7 @@ /* write the png-info struct */ png_write_info(png_ptr, info_ptr); @@ -384,7 +391,7 @@ Fix build with png-1.5. if (cmdline.text || cmdline.ztxt) /* prevent from being written twice with png_write_end */ info_ptr->num_text = 0; -@@ -2710,6 +2704,7 @@ +@@ -2710,6 +2708,7 @@ if (cmdline.modtime) /* prevent from being written twice with png_write_end */ info_ptr->valid &= ~PNG_INFO_tIME; diff --git a/graphics/netpbm/patches/patch-af b/graphics/netpbm/patches/patch-af index 0e9969ce69a..98f119c66bc 100644 --- a/graphics/netpbm/patches/patch-af +++ b/graphics/netpbm/patches/patch-af @@ -1,7 +1,9 @@ -$NetBSD: patch-af,v 1.14 2010/06/13 22:44:39 wiz Exp $ +$NetBSD: patch-af,v 1.15 2011/01/15 18:37:46 tron Exp $ ---- converter/other/pngtopnm.c.orig 2009-09-03 15:34:36.000000000 +0000 -+++ converter/other/pngtopnm.c +Fix build with png-1.5. + +--- converter/other/pngtopnm.c.orig 2009-09-03 16:34:36.000000000 +0100 ++++ converter/other/pngtopnm.c 2011-01-15 18:19:09.000000000 +0000 @@ -44,12 +44,6 @@ #include "nstring.h" #include "shhopt.h" @@ -15,50 +17,872 @@ $NetBSD: patch-af,v 1.14 2010/06/13 22:44:39 wiz Exp $ typedef struct _jmpbuf_wrapper { jmp_buf jmpbuf; } jmpbuf_wrapper; -@@ -482,7 +476,7 @@ isTransparentColor(pngcolor const colo - bool retval; +@@ -187,7 +181,7 @@ - if (info_ptr->valid & PNG_INFO_tRNS) { -- const png_color_16 * const transColorP = &info_ptr->trans_values; -+ const png_color_16 * const transColorP = &info_ptr->trans_color; + + +-#define get_png_val(p) _get_png_val (&(p), info_ptr->bit_depth) ++#define get_png_val(p) _get_png_val (&(p), png_get_bit_depth(png_ptr, info_ptr)) + + static png_uint_16 + _get_png_val (png_byte ** const pp, +@@ -266,33 +260,39 @@ + } + + #ifdef __STDC__ +-static void save_text (png_info *info_ptr, FILE *tfp) ++static void save_text (png_structp 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_structp png_ptr; + png_info *info_ptr; + FILE *tfp; + #endif + { + int i, j, k; ++ png_textp text_ptr; ++ int num_text; ++ ++ if (png_get_text(png_ptr, info_ptr, &text_ptr, &num_text) == 0) ++ return; + +- 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_ptr[i].key[j] != '\0' && text_ptr[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_ptr[i].key[j] != ' ') { ++ fprintf (tfp, "%s", text_ptr[i].key); ++ for (j = strlen (text_ptr[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_ptr[i].key); ++ for (j = strlen (text_ptr[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_ptr[i].text_length ; j++) { ++ putc (text_ptr[i].text[j], tfp); ++ if (text_ptr[i].text[j] == '\n') + for (k = 0 ; k < 16 ; k++) + putc ((int)' ', tfp); + } +@@ -301,9 +301,10 @@ + } + + #ifdef __STDC__ +-static void show_time (png_info *info_ptr) ++static void show_time (png_structp png_ptr, png_info *info_ptr) + #else +-static void show_time (info_ptr) ++static void show_time (png_ptr, info_ptr) ++png_structp png_ptr; + png_info *info_ptr; + #endif + { +@@ -311,12 +312,13 @@ + "", "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December" + }; ++ png_timep mod_time; + +- if (info_ptr->valid & PNG_INFO_tIME) { ++ if (png_get_tIME(png_ptr, info_ptr, &mod_time) & PNG_INFO_tIME) { + 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_time->day, month[mod_time->month], ++ mod_time->year, mod_time->hour, ++ mod_time->minute, mod_time->second); + } + } + +@@ -353,12 +355,28 @@ + + + static void +-dump_png_info(png_info *info_ptr) { ++dump_png_info(png_structp png_ptr, png_info *info_ptr) { + + const char *type_string; + const char *filter_string; ++ png_color_16p background; ++ int num_trans; ++ double gamma; ++ png_color_8p sig_bit; ++ png_colorp palette; ++ int num_palette; ++ png_uint_16p hist; ++ int res_x, res_y, unit_type; ++ png_int_32 offset_x, offset_y; ++ png_timep mod_time; ++ png_charp purpose; ++ png_int_32 X0, X1; ++ int type, nparams; ++ png_charp units; ++ png_charpp params; ++ int file_srgb_intent; + +- switch (info_ptr->color_type) { ++ switch (png_get_color_type(png_ptr, info_ptr)) { + case PNG_COLOR_TYPE_GRAY: + type_string = "gray"; + break; +@@ -380,90 +398,101 @@ + 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)); + } + +- 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" : ""); ++ pm_message("reading a %uw x %uh image, %d bit%s", ++ png_get_image_width(png_ptr, info_ptr), ++ png_get_image_height(png_ptr, info_ptr), ++ png_get_bit_depth(png_ptr, info_ptr), ++ png_get_bit_depth(png_ptr, info_ptr) > 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); +- 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); ++ ++ if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) { ++ pm_message("background {index, gray, red, green, blue} = " ++ "{%d, %d, %d, %d, %d}", ++ background->index, ++ background->gray, ++ background->red, ++ background->green, ++ background->blue); ++ } + + strfree(filter_string); + +- if (info_ptr->valid & PNG_INFO_tRNS) ++ if (png_get_tRNS(png_ptr, info_ptr, ++ NULL, &num_trans, NULL) & PNG_INFO_tRNS) + pm_message("tRNS chunk (transparency): %u entries", +- info_ptr->num_trans); ++ 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); ++ if (png_get_gAMA(png_ptr, info_ptr, &gamma) & PNG_INFO_gAMA) ++ 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_sBIT(png_ptr, info_ptr, &sig_bit) & 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_cHRM(png_ptr, info_ptr, ++ NULL, NULL, NULL, NULL, ++ NULL, NULL, NULL, NULL) & 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); ++ if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) & PNG_INFO_PLTE) ++ 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_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) + pm_message("bKGD chunk: present"); + else + pm_message("bKGD chunk: not present"); + +- if (info_ptr->valid & PNG_INFO_PLTE) ++ if (png_get_hIST(png_ptr, info_ptr, &hist) & 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_pHYs(png_ptr, info_ptr, ++ &res_x, &res_y, &unit_type) & 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_oFFs(png_ptr, info_ptr, ++ &offset_x, &offset_y, &unit_type) & 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_tIME(png_ptr, info_ptr, &mod_time) & 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_pCAL(png_ptr, info_ptr, &purpose, &X0, &X1, ++ &type, &nparams, &units, ¶ms) & 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_sRGB(png_ptr, info_ptr, &file_srgb_intent) & PNG_INFO_sRGB) + pm_message("sRGB chunk: present"); + else + pm_message("sRGB chunk: not present"); +@@ -472,19 +501,19 @@ + + + static bool +-isTransparentColor(pngcolor const color, +- png_info * const info_ptr, +- double const totalgamma) { ++isTransparentColor(pngcolor const color, ++ png_structp const png_ptr, ++ png_info * const info_ptr, ++ double const totalgamma) { + /*---------------------------------------------------------------------------- + Return TRUE iff pixels of color 'color' are supposed to be transparent + everywhere they occur. Assume it's an RGB image. + -----------------------------------------------------------------------------*/ + bool retval; ++ png_color_16p transColorP; + +- if (info_ptr->valid & PNG_INFO_tRNS) { +- const png_color_16 * const transColorP = &info_ptr->trans_values; +- +- ++ if (png_get_tRNS(png_ptr, info_ptr, ++ NULL, NULL, &transColorP) & PNG_INFO_tRNS) { /* There seems to be a problem here: you can't compare real -@@ -575,8 +569,8 @@ paletteHasPartialTransparency(png_info * + numbers for equality. Also, I'm not sure the gamma + corrected/uncorrected color spaces are right here. +@@ -530,9 +559,11 @@ + if (displaygamma == -1.0) + *totalgammaP = -1.0; + else { ++ double fileGamma; + float imageGamma; +- if (info_ptr->valid & PNG_INFO_gAMA) +- imageGamma = info_ptr->gamma; ++ ++ if (png_get_gAMA(png_ptr, info_ptr, &fileGamma) & PNG_INFO_gAMA) ++ imageGamma = fileGamma; + else { + if (verbose) + pm_message("PNG doesn't specify image gamma. Assuming 1.0"); +@@ -548,10 +579,14 @@ + } else { + png_set_gamma(png_ptr, displaygamma, imageGamma); + *totalgammaP = imageGamma * displaygamma; ++#ifdef NOT_SUPPORTED_ANYMORE ++ /* The API doesn't clearing PNG_INFO_sBIT. */ ++ + /* in case of gamma-corrections, sBIT's as in the + PNG-file are not valid anymore + */ + info_ptr->valid &= ~PNG_INFO_sBIT; ++#endif + if (verbose) + pm_message("image gamma is %4.2f, " + "converted for display gamma of %4.2f", +@@ -563,20 +598,24 @@ + + + static bool +-paletteHasPartialTransparency(png_info * const info_ptr) { ++paletteHasPartialTransparency(png_structp 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) { ++ png_bytep trans_alpha; ++ int num_trans; ++ ++ if (png_get_tRNS(png_ptr, info_ptr, ++ &trans_alpha, &num_trans, NULL) & PNG_INFO_tRNS) { + bool foundGray; + unsigned int i; + for (i = 0, foundGray = FALSE; - i < info_ptr->num_trans && !foundGray; +- 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; } } -@@ -647,7 +641,7 @@ setupSignificantBits(png_struct * +@@ -604,14 +643,16 @@ + + Return the result as *maxvalP. + -----------------------------------------------------------------------------*/ ++ png_color_8p sig_bit; ++ + /* Initial assumption of maxval */ +- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) { ++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) { + if (alpha == ALPHA_ONLY) { +- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY || +- info_ptr->color_type == PNG_COLOR_TYPE_RGB) ++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY || ++ png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB) + /* 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)) + /* Use same maxval as PNG transparency palette for simplicity*/ + *maxvalP = 255; + else +@@ -621,7 +662,7 @@ + /* 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; + } + + /* sBIT handling is very tricky. If we are extracting only the +@@ -634,20 +675,26 @@ + is used + */ + +- if (info_ptr->valid & PNG_INFO_sBIT) { ++ if (png_get_sBIT(png_ptr, info_ptr, &sig_bit) & PNG_INFO_sBIT) { ++ png_byte color_type; ++ png_bytep trans_alpha; ++ int num_trans; ++ ++ color_type = png_get_color_type(png_ptr, info_ptr); + switch (alpha) { + case ALPHA_MIX: +- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || +- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || ++ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + break; +- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- (info_ptr->valid & PNG_INFO_tRNS)) { ++ if (color_type == PNG_COLOR_TYPE_PALETTE && ++ png_get_tRNS(png_ptr, info_ptr, ++ &trans_alpha, &num_trans, NULL) & PNG_INFO_tRNS) { + + bool trans_mix; unsigned int i; trans_mix = TRUE; - for (i = 0; i < info_ptr->num_trans; ++i) +- for (i = 0; i < info_ptr->num_trans; ++i) - if (info_ptr->trans[i] != 0 && info_ptr->trans[i] != 255) { -+ if (info_ptr->trans_alpha[i] != 0 && info_ptr->trans_alpha[i] != 255) { ++ for (i = 0; i < num_trans; ++i) ++ if (trans_alpha[i] != 0 && trans_alpha[i] != 255) { trans_mix = FALSE; break; } -@@ -885,7 +879,7 @@ writePnm(FILE * const ofP, - setXel(&xelrow[col], fgColor, bgColor, alpha_handling, - ((info_ptr->valid & PNG_INFO_tRNS) && - (fgColor.r == +@@ -658,70 +705,76 @@ + /* else fall though to normal case */ + + case ALPHA_NONE: +- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE || +- info_ptr->color_type == PNG_COLOR_TYPE_RGB || +- info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) && +- (info_ptr->sig_bit.red != info_ptr->sig_bit.green || +- info_ptr->sig_bit.red != info_ptr->sig_bit.blue) && ++ if ((color_type == PNG_COLOR_TYPE_PALETTE || ++ color_type == PNG_COLOR_TYPE_RGB || ++ color_type == PNG_COLOR_TYPE_RGB_ALPHA) && ++ (sig_bit->red != sig_bit->green || ++ sig_bit->red != sig_bit->blue) && + alpha == ALPHA_NONE) { + pm_message("This program cannot handle " + "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; + } else { +- if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) && +- (info_ptr->sig_bit.red < 255)) { ++ png_colorp palette; ++ int num_palette; ++ ++ if ((color_type == PNG_COLOR_TYPE_PALETTE) && ++ (sig_bit->red < 255) && ++ png_get_PLTE(png_ptr, info_ptr, ++ &palette, &num_palette) & PNG_INFO_PLTE) { + unsigned int i; +- for (i = 0; i < info_ptr->num_palette; ++i) { +- info_ptr->palette[i].red >>= +- (8 - info_ptr->sig_bit.red); +- info_ptr->palette[i].green >>= +- (8 - info_ptr->sig_bit.green); +- info_ptr->palette[i].blue >>= +- (8 - info_ptr->sig_bit.blue); ++ ++ for (i = 0; i < num_palette; ++i) { ++ palette[i].red >>= ++ (8 - sig_bit->red); ++ palette[i].green >>= ++ (8 - sig_bit->green); ++ palette[i].blue >>= ++ (8 - sig_bit->blue); + } +- *maxvalP = (1l << info_ptr->sig_bit.red) - 1; ++ *maxvalP = (1l << sig_bit->red) - 1; + if (verbose) + pm_message ("image has fewer significant bits, " + "writing file with %d bits per channel", +- info_ptr->sig_bit.red); ++ sig_bit->red); + } else +- 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)); +- *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); ++ *maxvalP = (1l << sig_bit->red) - 1; + if (verbose) + pm_message("image has fewer significant bits, " + "writing file with %d " + "bits per channel", +- info_ptr->sig_bit.red); ++ sig_bit->red); + } else +- if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY || +- info_ptr->color_type == ++ if ((color_type == PNG_COLOR_TYPE_GRAY || ++ 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)); +- *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); ++ *maxvalP = (1l << sig_bit->gray) - 1; + if (verbose) + pm_message("image has fewer significant bits, " + "writing file with %d bits", +- info_ptr->sig_bit.gray); ++ sig_bit->gray); + } + } + break; + + case ALPHA_ONLY: +- 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)); ++ 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); + if (verbose) + pm_message ("image has fewer significant bits, " + "writing file with %d bits", +- info_ptr->sig_bit.alpha); +- *maxvalP = (1l << info_ptr->sig_bit.alpha) - 1; ++ sig_bit->alpha); ++ *maxvalP = (1l << sig_bit->alpha) - 1; + } + break; + +@@ -732,22 +785,28 @@ + + + static bool +-imageHasColor(png_info * const info_ptr) { ++imageHasColor(png_structp const png_ptr, png_info * const info_ptr) { + + bool retval; +- +- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY || +- info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ png_byte color_type; ++ png_colorp palette; ++ int num_palette; ++ ++ color_type = png_get_color_type(png_ptr, 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 (color_type == PNG_COLOR_TYPE_PALETTE && ++ png_get_PLTE(png_ptr, info_ptr, ++ &palette, &num_palette) & PNG_INFO_PLTE) { + bool foundColor; + unsigned int i; + + 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; +@@ -760,14 +819,15 @@ + + + static void +-determineOutputType(png_info * const info_ptr, ++determineOutputType(png_structp 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) +@@ -780,7 +840,8 @@ + + + static void +-getBackgroundColor(png_info * const info_ptr, ++getBackgroundColor(png_structp const png_ptr, ++ png_info * const info_ptr, + const char * const requestedColor, + float const totalgamma, + xelval const maxval, +@@ -791,6 +852,8 @@ + Otherwise, if the PNG specifies a background color, that's the one. + And otherwise, it's white. + -----------------------------------------------------------------------------*/ ++ png_color_16p background; ++ + if (requestedColor) { + /* Background was specified from the command-line; we always + use that. I chose to do no gamma-correction in this case; +@@ -802,27 +865,32 @@ + bgColorP->g = PPM_GETG(backcolor); + bgColorP->b = PPM_GETB(backcolor); + +- } else if (info_ptr->valid & PNG_INFO_bKGD) { ++ } else if (png_get_bKGD(png_ptr, info_ptr, &background) & PNG_INFO_bKGD) { + /* 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]; +- bgColorP->r = gamma_correct(rawBgcolor.red, totalgamma); +- bgColorP->g = gamma_correct(rawBgcolor.green, totalgamma); +- bgColorP->b = gamma_correct(rawBgcolor.blue, totalgamma); ++ png_colorp palette; ++ int num_palette; ++ ++ if (png_get_PLTE(png_ptr, info_ptr, ++ &palette, &num_palette) & PNG_INFO_PLTE) { ++ png_color const 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); ++ } + } + 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); +@@ -841,6 +909,7 @@ + writePnm(FILE * const ofP, + xelval const maxval, + int const pnm_type, ++ png_structp const png_ptr, + png_info * const info_ptr, + png_byte ** const png_image, + pngcolor const bgColor, +@@ -858,6 +927,7 @@ + -----------------------------------------------------------------------------*/ + xel * xelrow; + unsigned int row; ++ png_uint_32 width, height; + + if (verbose) + pm_message ("writing a %s file (maxval=%u)", +@@ -867,27 +937,35 @@ + "UNKNOWN!", + maxval); + +- xelrow = pnm_allocrow(info_ptr->width); ++ xelrow = pnm_allocrow(png_get_image_width(png_ptr, info_ptr)); + +- pnm_writepnminit(stdout, info_ptr->width, info_ptr->height, maxval, +- pnm_type, FALSE); ++ width = png_get_image_width(png_ptr, info_ptr); ++ height = png_get_image_height(png_ptr, info_ptr); + +- for (row = 0; row < info_ptr->height; ++row) { ++ pnm_writepnminit(stdout, width, height, maxval, pnm_type, FALSE); ++ ++ 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 (png_get_color_type(png_ptr, info_ptr)) { + case PNG_COLOR_TYPE_GRAY: { + pngcolor fgColor; ++ png_color_16p trans_color; ++ + fgColor.r = fgColor.g = fgColor.b = get_png_val(png_pixelP); +- setXel(&xelrow[col], fgColor, bgColor, alpha_handling, +- ((info_ptr->valid & PNG_INFO_tRNS) && +- (fgColor.r == - gamma_correct(info_ptr->trans_values.gray, -+ gamma_correct(info_ptr->trans_color.gray, - totalgamma))) ? - 0 : maxval); +- totalgamma))) ? +- 0 : maxval); ++ ++ if (png_get_tRNS(png_ptr, info_ptr, ++ NULL, NULL, &trans_color) & PNG_INFO_tRNS && ++ (fgColor.r == gamma_correct(trans_color->gray, ++ totalgamma))) { ++ setXel(&xelrow[col], fgColor, bgColor, alpha_handling, 0); ++ } else { ++ setXel(&xelrow[col], fgColor, bgColor, alpha_handling, ++ maxval); ++ } } -@@ -914,7 +908,7 @@ writePnm(FILE * const ofP, - setXel(&xelrow[col], fgColor, bgColor, alpha_handling, - (info_ptr->valid & PNG_INFO_tRNS) && - index < info_ptr->num_trans ? + break; + +@@ -902,19 +980,31 @@ + break; + + case PNG_COLOR_TYPE_PALETTE: { +- png_uint_16 const index = get_png_val(png_pixelP); +- png_color const paletteColor = info_ptr->palette[index]; +- +- pngcolor fgColor; +- +- fgColor.r = paletteColor.red; +- fgColor.g = paletteColor.green; +- 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); -+ info_ptr->trans_alpha[index] : maxval); ++ png_uint_16 const index = get_png_val(png_pixelP); ++ png_colorp palette; ++ int num_palette; ++ ++ if (png_get_PLTE(png_ptr, info_ptr, ++ &palette, &num_palette) & PNG_INFO_PLTE) { ++ png_color const paletteColor = palette[index]; ++ pngcolor fgColor; ++ png_bytep trans_alpha; ++ int num_trans; ++ ++ fgColor.r = paletteColor.red; ++ fgColor.g = paletteColor.green; ++ fgColor.b = paletteColor.blue; ++ ++ if (png_get_tRNS(png_ptr, info_ptr, ++ &trans_alpha, ++ &num_trans, NULL) & PNG_INFO_tRNS) { ++ setXel(&xelrow[col], fgColor, bgColor, alpha_handling, ++ index < num_trans ? trans_alpha[index] : maxval); ++ } else { ++ setXel(&xelrow[col], fgColor, bgColor, alpha_handling, ++ maxval); ++ } ++ } } break; +@@ -925,8 +1015,8 @@ + 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) ? +- 0 : maxval); ++ isTransparentColor(fgColor, png_ptr, info_ptr, ++ totalgamma) ? 0 : maxval); + } + break; + +@@ -943,10 +1033,10 @@ + break; + + default: +- pm_error ("unknown PNG color type: %d", info_ptr->color_type); ++ pm_error ("unknown PNG color type: %d", png_get_color_type(png_ptr, info_ptr)); + } + } +- pnm_writepnmrow(ofP, xelrow, info_ptr->width, maxval, pnm_type, FALSE); ++ pnm_writepnmrow(ofP, xelrow, width, maxval, pnm_type, FALSE); + } + pnm_freerow (xelrow); + } +@@ -967,6 +1057,7 @@ + int pnm_type; + pngcolor bgColor; + float totalgamma; ++ int res_x, res_y, unit_type; + + *errorlevelP = 0; + +@@ -989,28 +1080,28 @@ + png_set_sig_bytes (png_ptr, SIG_CHECK_SIZE); + png_read_info (png_ptr, info_ptr); + +- MALLOCARRAY(png_image, info_ptr->height); ++ MALLOCARRAY(png_image, png_get_image_height(png_ptr, info_ptr)); + 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 (png_get_bit_depth(png_ptr, info_ptr) == 16) ++ linesize = 2 * png_get_image_width(png_ptr, info_ptr); + else +- linesize = info_ptr->width; ++ linesize = png_get_image_width(png_ptr, info_ptr); + +- if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY_ALPHA) + linesize *= 2; + else +- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB) ++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB) + linesize *= 3; + else +- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ++ if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB_ALPHA) + linesize *= 4; + +- for (y = 0 ; y < info_ptr->height ; y++) { ++ for (y = 0 ; y < png_get_image_height(png_ptr, info_ptr) ; y++) { + png_image[y] = malloc (linesize); + if (png_image[y] == NULL) { + for (x = 0 ; x < y ; x++) +@@ -1022,7 +1113,7 @@ + } + } + +- 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); +@@ -1030,8 +1121,8 @@ + setupSignificantBits(png_ptr, info_ptr, cmdline.alpha, + &maxval, errorlevelP); + +- getBackgroundColor(info_ptr, cmdline.background, totalgamma, maxval, +- &bgColor); ++ getBackgroundColor(png_ptr, info_ptr, cmdline.background, totalgamma, ++ maxval, &bgColor); + + png_read_image (png_ptr, png_image); + png_read_end (png_ptr, info_ptr); +@@ -1041,16 +1132,17 @@ + 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_pHYs(png_ptr, info_ptr, ++ &res_x, &res_y, &unit_type) & PNG_INFO_pHYs) { + float r; +- r = (float)info_ptr->x_pixels_per_unit / info_ptr->y_pixels_per_unit; ++ r = (float)res_x / res_y; + if (r != 1.0) { + pm_message ("warning - non-square pixels; " + "to fix do a 'pamscale -%cscale %g'", +@@ -1060,13 +1152,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 < png_get_image_height(png_ptr, info_ptr) ; y++) + free (png_image[y]); + free (png_image); + png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL); diff --git a/graphics/netpbm/patches/patch-al b/graphics/netpbm/patches/patch-al new file mode 100644 index 00000000000..44e2bec9c1c --- /dev/null +++ b/graphics/netpbm/patches/patch-al @@ -0,0 +1,19 @@ +$NetBSD: patch-al,v 1.5 2011/01/15 18:37:46 tron Exp $ + +Fix build with png-1.5. + +--- converter/other/pamrgbatopng.c.orig 2006-08-19 04:12:28.000000000 +0100 ++++ converter/other/pamrgbatopng.c 2011-01-15 18:24:36.000000000 +0000 +@@ -101,10 +101,8 @@ + if (!infoP) + pm_error("Could not allocate PNG info structure"); + else { +- infoP->width = pamP->width; +- infoP->height = pamP->height; +- infoP->bit_depth = 8; +- infoP->color_type = PNG_COLOR_TYPE_RGB_ALPHA; ++ png_set_IHDR(pngP, infoP, pamP->width, pamP->height, ++ 8, PNG_COLOR_TYPE_RGB_ALPHA, 0, 0, 0); + + png_init_io(pngP, ofP); + -- cgit v1.2.3