Properly support png15

Obtained from:	OpenBSD ports

6 files changed, 1357 insertions, 85 deletions

diff --git a/graphics/netpbm/Makefile b/graphics/netpbm/Makefile
index d52d16fac678..973d56d5fba9 100644
--- a/graphics/netpbm/Makefile
+++ b/graphics/netpbm/Makefile
@@ -13,7 +13,7 @@ COMMENT=	Toolkit for conversion of images between different formats
 
 LIB_DEPENDS=	libtiff.so:${PORTSDIR}/graphics/tiff \
 		libjpeg.so:${PORTSDIR}/graphics/jpeg \
-		libpng15.so:${PORTSDIR}/graphics/png \
+		libpng.so:${PORTSDIR}/graphics/png \
 		libjbig.so:${PORTSDIR}/graphics/jbigkit \
 		libjasper.so:${PORTSDIR}/graphics/jasper \
 		libxml2.so:${PORTSDIR}/textproc/libxml2
diff --git a/graphics/netpbm/files/patch-pamrgbatopng.c b/graphics/netpbm/files/patch-pamrgbatopng.c
index 92e7590cf59b..5fc5e102ba82 100644
--- a/graphics/netpbm/files/patch-pamrgbatopng.c
+++ b/graphics/netpbm/files/patch-pamrgbatopng.c
@@ -1,8 +1,19 @@
---- converter/other/pamrgbatopng.c.orig	2006-08-19 05:12:28.000000000 +0200
-+++ converter/other/pamrgbatopng.c	2012-04-24 22:20:00.000000000 +0200
-@@ -1,4 +1,5 @@
- #include <png.h>
-+#include <pngpriv.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <setjmp.h>
+$OpenBSD: patch-converter_other_pamrgbatopng_c,v 1.1 2011/07/08 20:36:09 naddy Exp $
+
+Fix build with png-1.5.
+
+--- converter/other/pamrgbatopng.c.orig	Fri Aug 18 21:12:28 2006
++++ converter/other/pamrgbatopng.c	Mon Jul  4 14:21:23 2011
+@@ -101,10 +101,8 @@ writePng(const struct pam * const pamP,
+     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);
+ 
diff --git a/graphics/netpbm/files/patch-pngtopnm.c b/graphics/netpbm/files/patch-pngtopnm.c
index 8c4615530bbe..7ada8b3f972e 100644
--- a/graphics/netpbm/files/patch-pngtopnm.c
+++ b/graphics/netpbm/files/patch-pngtopnm.c
@@ -1,66 +1,894 @@
---- converter/other/pngtopnm.c.orig	2011-11-25 01:15:46.000000000 +0100
-+++ converter/other/pngtopnm.c	2012-04-24 22:15:14.000000000 +0200
-@@ -37,6 +37,7 @@
- #include <math.h>
- #include <float.h>
- #include <png.h>    /* includes zlib.h and setjmp.h */
-+#include <pngpriv.h>
- #define VERSION "2.37.4 (5 December 1999) +netpbm"
- 
- #include "pnm.h"
-@@ -44,7 +45,7 @@
+$OpenBSD: patch-converter_other_pngtopnm_c,v 1.2 2011/12/13 21:39:17 naddy Exp $
+
+Fix build with png-1.5.
+
+--- converter/other/pngtopnm.c.orig	Fri Nov 25 01:15:46 2011
++++ converter/other/pngtopnm.c	Tue Dec 13 22:25:03 2011
+@@ -44,12 +44,6 @@
  #include "nstring.h"
  #include "shhopt.h"
  
 -#if PNG_LIBPNG_VER >= 10400
-+#if 0
- #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)
-@@ -489,7 +490,7 @@
-     bool retval;
+-#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)
+-#endif
+-
+ typedef struct _jmpbuf_wrapper {
+   jmp_buf jmpbuf;
+ } jmpbuf_wrapper;
+@@ -187,7 +181,7 @@ parseCommandLine(int                 argc, 
  
-     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 @@ png_color c;
+ }
+ 
+ #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;
+ 
+-  for (i = 0 ; i < info_ptr->num_text ; i++) {
++  if (png_get_text(png_ptr, info_ptr, &text_ptr, &num_text) == 0)
++    return;
++
++  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 @@ FILE *tfp;
+ }
+ 
+ #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,19 +312,20 @@ png_info *info_ptr;
+         "", "January", "February", "March", "April", "May", "June",
+         "July", "August", "September", "October", "November", "December"
+     };
++  png_timep mod_time;
+ 
+-  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_tIME(png_ptr, info_ptr, &mod_time) & PNG_INFO_tIME) {
++    if (mod_time->month < 1 ||
++      mod_time->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_time->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_time->day, month[mod_time->month],
++                mod_time->year, mod_time->hour,
++                mod_time->minute, mod_time->second);
+   }
+ }
+ 
+@@ -360,12 +362,28 @@ png_const_charp msg;
+ 
+ 
+ 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;
+@@ -387,90 +405,101 @@ 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));
+     }
+ 
+-    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_hIST)
++    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, &params) & 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");
+@@ -479,19 +508,19 @@ dump_png_info(png_info *info_ptr) {
+ 
+ 
+ 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
-@@ -582,8 +583,8 @@
+            numbers for equality.  Also, I'm not sure the gamma
+            corrected/uncorrected color spaces are right here.  
+@@ -537,9 +566,11 @@ setupGammaCorrection(png_struct * const png_ptr,
+     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");
+@@ -555,10 +586,14 @@ setupGammaCorrection(png_struct * const png_ptr,
+         } 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",
+@@ -570,20 +605,24 @@ setupGammaCorrection(png_struct * const png_ptr,
+ 
+ 
+ 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;
                  }
              }
-@@ -654,7 +655,7 @@
+@@ -611,14 +650,16 @@ setupSignificantBits(png_struct *        const png_ptr
+ 
+   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
+@@ -628,7 +669,7 @@ setupSignificantBits(png_struct *        const png_ptr
+             /* 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
+@@ -641,20 +682,26 @@ setupSignificantBits(png_struct *        const png_ptr
+        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;
                      }
-@@ -892,7 +893,7 @@
-                 setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
-                        ((info_ptr->valid & PNG_INFO_tRNS) &&
-                         (fgColor.r == 
+@@ -665,70 +712,76 @@ setupSignificantBits(png_struct *        const png_ptr
+             /* 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;
+ 
+@@ -739,22 +792,28 @@ setupSignificantBits(png_struct *        const png_ptr
+ 
+ 
+ static bool
+-imageHasColor(png_info * const info_ptr) {
++imageHasColor(png_structp const png_ptr, png_info * const info_ptr) {
+ 
+     bool retval;
++    png_byte color_type;
++    png_colorp palette;
++    int num_palette;
+ 
+-    if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
+-        info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
++    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;
+@@ -767,14 +826,15 @@ imageHasColor(png_info * const info_ptr) {
+ 
+ 
+ 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)
+@@ -787,7 +847,8 @@ determineOutputType(png_info *          const info_ptr
+ 
+ 
+ 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,
+@@ -798,6 +859,8 @@ getBackgroundColor(png_info *        const info_ptr,
+    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;
+@@ -809,27 +872,32 @@ getBackgroundColor(png_info *        const info_ptr,
+         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);
+@@ -848,6 +916,7 @@ static void
+ 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,
+@@ -865,6 +934,7 @@ writePnm(FILE *              const ofP,
+ -----------------------------------------------------------------------------*/
+     xel * xelrow;
+     unsigned int row;
++    png_uint_32 width, height;
+ 
+     if (verbose)
+         pm_message ("writing a %s file (maxval=%u)",
+@@ -874,27 +944,35 @@ writePnm(FILE *              const ofP,
+                     "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);
++                }
              }
-@@ -921,7 +922,7 @@
-                 setXel(&xelrow[col], fgColor, bgColor, alpha_handling,
-                        (info_ptr->valid & PNG_INFO_tRNS) &&
-                        index < info_ptr->num_trans ?
+             break;
+ 
+@@ -909,19 +987,31 @@ writePnm(FILE *              const ofP,
+             break;
+ 
+             case PNG_COLOR_TYPE_PALETTE: {
+-                png_uint_16 const index        = get_png_val(png_pixelP);
+-                png_color   const paletteColor = info_ptr->palette[index];
++                png_uint_16 const index = get_png_val(png_pixelP);
++                png_colorp palette;
++                int num_palette;
+ 
+-                pngcolor fgColor;
++                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;
++                    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);
++                    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;
                  
+@@ -932,8 +1022,8 @@ writePnm(FILE *              const ofP,
+                 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;
+ 
+@@ -950,10 +1040,10 @@ writePnm(FILE *              const ofP,
+             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);
+ }
+@@ -974,6 +1064,7 @@ convertpng(FILE *             const ifp, 
+     int pnm_type;
+     pngcolor bgColor;
+     float totalgamma;
++    int res_x, res_y, unit_type;
+ 
+     *errorlevelP = 0;
+ 
+@@ -996,28 +1087,28 @@ convertpng(FILE *             const ifp, 
+     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++)
+@@ -1029,7 +1120,7 @@ convertpng(FILE *             const ifp, 
+         }
+     }
+ 
+-    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);
+@@ -1037,8 +1128,8 @@ convertpng(FILE *             const ifp, 
+     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);
+@@ -1048,16 +1139,17 @@ 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 (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'",
+@@ -1067,13 +1159,13 @@ convertpng(FILE *             const ifp, 
+         }
+     }
+ 
+-    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/files/patch-pngtxt.c b/graphics/netpbm/files/patch-pngtxt.c
index b3ae8ad5a51f..9c4cfe07e6c5 100644
--- a/graphics/netpbm/files/patch-pngtxt.c
+++ b/graphics/netpbm/files/patch-pngtxt.c
@@ -1,10 +1,80 @@
---- converter/other/pngtxt.c.orig	2006-08-19 05:12:28.000000000 +0200
-+++ converter/other/pngtxt.c	2012-04-24 22:12:39.000000000 +0200
-@@ -2,6 +2,7 @@
- #include <string.h>
- #include <stdio.h>
- #include <png.h>
-+#include <pngpriv.h>
- 
- #include "nstring.h"
- #include "pngtxt.h"
+$OpenBSD: patch-converter_other_pngtxt_c,v 1.1 2011/07/08 20:36:09 naddy Exp $
+
+Fix build with png-1.5.
+
+--- converter/other/pngtxt.c.orig	Fri Aug 18 21:12:28 2006
++++ converter/other/pngtxt.c	Mon Jul  4 14:21:23 2011
+@@ -240,7 +240,8 @@ handleArrayAllocation(png_text **    const arrayP,
+ 
+ 
+ void 
+-pnmpng_read_text (png_info * const info_ptr, 
++pnmpng_read_text (png_struct * png_ptr,
++                  png_info * info_ptr, 
+                   FILE *     const tfp, 
+                   bool       const ztxt,
+                   bool       const verbose) {
+@@ -250,6 +251,7 @@ pnmpng_read_text (png_info * const info_ptr, 
+     unsigned int commentIdx;
+     bool noCommentsYet;
+     bool eof;
++    png_textp text_ptr;
+     unsigned int allocatedComments;
+         /* Number of entries currently allocated for the info_ptr->text
+            array 
+@@ -257,8 +259,8 @@ pnmpng_read_text (png_info * const info_ptr, 
+ 
+     allocatedComments = 256;  /* initial value */
+ 
+-    MALLOCARRAY(info_ptr->text, allocatedComments);
+-    if (info_ptr->text == NULL) 
++    MALLOCARRAY(text_ptr, allocatedComments);
++    if (text_ptr == NULL) 
+         pm_error("unable to allocate memory for comment array");
+ 
+     commentIdx = 0;
+@@ -273,7 +275,7 @@ pnmpng_read_text (png_info * const info_ptr, 
+             if (lineLength == 0) {
+                 /* skip this empty line */
+             } else {
+-                handleArrayAllocation(&info_ptr->text, &allocatedComments,
++                handleArrayAllocation(&text_ptr, &allocatedComments,
+                                       commentIdx);
+                 if ((textline[0] != ' ') && (textline[0] != '\t')) {
+                     /* Line doesn't start with white space, which
+@@ -285,7 +287,7 @@ pnmpng_read_text (png_info * const info_ptr, 
+                         ++commentIdx;
+                     noCommentsYet = FALSE;
+ 
+-                    startComment(&info_ptr->text[commentIdx], 
++                    startComment(&text_ptr[commentIdx], 
+                                  textline, lineLength, ztxt);
+                 } else {
+                     /* Line starts with whitespace, which means it is
+@@ -295,20 +297,20 @@ pnmpng_read_text (png_info * const info_ptr, 
+                         pm_error("Invalid comment file format: "
+                                  "first line is a continuation line! "
+                                  "(It starts with whitespace)");
+-                    continueComment(&info_ptr->text[commentIdx], 
++                    continueComment(&text_ptr[commentIdx], 
+                                     textline, lineLength);
+                 }
+             }
+             strfree(textline);
+         }
+     } 
+-    if (noCommentsYet)
+-        info_ptr->num_text = 0;
+-    else
+-        info_ptr->num_text = commentIdx + 1;
++    if (!noCommentsYet)
++        png_set_text(png_ptr, info_ptr, text_ptr, commentIdx + 1);
+ 
+     if (verbose)
+-        pm_message("%d comments placed in text chunk", info_ptr->num_text);
++        pm_message("%d comments placed in text chunk", commentIdx + 1);
++
++    free(text_ptr);
+ }
+ 
+ 
diff --git a/graphics/netpbm/files/patch-pngtxt.h b/graphics/netpbm/files/patch-pngtxt.h
new file mode 100644
index 000000000000..efdb6d1d81b0
--- /dev/null
+++ b/graphics/netpbm/files/patch-pngtxt.h
@@ -0,0 +1,16 @@
+$OpenBSD: patch-converter_other_pngtxt_h,v 1.1 2011/07/08 20:36:09 naddy Exp $
+
+Fix build with png-1.5.
+
+--- converter/other/pngtxt.h.orig	Fri Aug 18 21:12:28 2006
++++ converter/other/pngtxt.h	Mon Jul  4 14:21:23 2011
+@@ -5,7 +5,8 @@
+ #include <png.h>
+ 
+ void 
+-pnmpng_read_text (png_info * const info_ptr, 
++pnmpng_read_text (png_struct * png_ptr,
++                  png_info * const info_ptr, 
+                   FILE *     const tfp, 
+                   bool const ztxt,
+                   bool const verbose);
diff --git a/graphics/netpbm/files/patch-pnmtopng.c b/graphics/netpbm/files/patch-pnmtopng.c
index 48a40c0e0e66..22a0f6297aa9 100644
--- a/graphics/netpbm/files/patch-pnmtopng.c
+++ b/graphics/netpbm/files/patch-pnmtopng.c
@@ -1,55 +1,402 @@
---- converter/other/pnmtopng.c.orig	2011-09-25 20:51:44.000000000 +0200
-+++ converter/other/pnmtopng.c	2012-04-23 20:23:10.000000000 +0200
-@@ -61,7 +61,9 @@
+$OpenBSD: patch-converter_other_pnmtopng_c,v 1.2 2011/12/13 21:39:17 naddy Exp $
+
+Fix build with png-1.5.
+
+--- converter/other/pnmtopng.c.orig	Sun Sep 25 20:51:44 2011
++++ converter/other/pnmtopng.c	Tue Dec 13 22:22:04 2011
+@@ -61,7 +61,8 @@
  #include <assert.h>
  #include <string.h> /* strcat() */
  #include <limits.h>
 -#include <png.h>    /* includes zlib.h and setjmp.h */
-+#include <png.h>
++#include <png.h>    /* includes setjmp.h */
 +#include <zlib.h>
-+#include <pngpriv.h>
  #include "pnm.h"
  #include "pngtxt.h"
  #include "shhopt.h"
-@@ -69,7 +71,7 @@
+@@ -69,13 +70,6 @@
  #include "nstring.h"
  #include "version.h"
  
 -#if PNG_LIBPNG_VER >= 10400
-+#if 0
- #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)
-@@ -2630,7 +2632,7 @@
-     info_ptr->num_palette = palette_size;
+-#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)
+-#endif
+-
+-
+ struct zlibCompression {
+     /* These are parameters that describe a form of zlib compression.
+        Values have the same meaning as the similarly named arguments to
+@@ -2098,6 +2092,7 @@ makePngLine(png_byte *           const line,
+             gray *               const alpha_mask,
+             colorhash_table      const cht,
+             coloralphahash_table const caht,
++            png_struct *         const png_ptr,
+             png_info *           const info_ptr,
+             xelval               const png_maxval,
+             unsigned int         const depth) {
+@@ -2110,20 +2105,20 @@ makePngLine(png_byte *           const line,
+         xel p_png;
+         xel const p = xelrow[col];
+         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) {
++        if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY ||
++            png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY_ALPHA) {
+             if (depth == 16)
+                 *pp++ = PNM_GET1(p_png) >> 8;
+             *pp++ = PNM_GET1(p_png) & 0xff;
+-        } else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
++        } else if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
+             unsigned int paletteIndex;
+             if (alpha)
+                 paletteIndex = lookupColorAlpha(caht, &p, &alpha_mask[col]);
+             else
+                 paletteIndex = ppm_lookupcolor(cht, &p);
+             *pp++ = paletteIndex;
+-        } else if (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
+-                   info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
++        } else if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB ||
++                   png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_RGB_ALPHA) {
+             if (depth == 16)
+                 *pp++ = PPM_GETR(p_png) >> 8;
+             *pp++ = PPM_GETR(p_png) & 0xff;
+@@ -2136,7 +2131,7 @@ makePngLine(png_byte *           const line,
+         } else
+             pm_error("INTERNAL ERROR: undefined color_type");
+                 
+-        if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) {
++        if (png_get_color_type(png_ptr, info_ptr) & PNG_COLOR_MASK_ALPHA) {
+             int const png_alphaval = (int)
+                 alpha_mask[col] * (float) png_maxval / maxval + 0.5;
+             if (depth == 16)
+@@ -2193,7 +2188,7 @@ writeRaster(png_struct *         const png_ptr,
+             
+             makePngLine(line, xelrow, cols, maxval,
+                         alpha, alpha ? alpha_mask[row] : NULL,
+-                        cht, caht, info_ptr, png_maxval, depth);
++                        cht, caht, png_ptr, info_ptr, png_maxval, depth);
+ 
+             png_write_row(png_ptr, line);
+         }
+@@ -2205,12 +2200,12 @@ writeRaster(png_struct *         const png_ptr,
+ 
+ static void
+ doGamaChunk(struct cmdlineInfo const cmdline,
++            png_struct *       const png_ptr,
+             png_info *         const info_ptr) {
+             
+     if (cmdline.gammaSpec) {
+         /* gAMA chunk */
+-        info_ptr->valid |= PNG_INFO_gAMA;
+-        info_ptr->gamma = cmdline.gamma;
++        png_set_gAMA(png_ptr, info_ptr, cmdline.gamma);
+     }
+ }
+ 
+@@ -2218,20 +2213,15 @@ doGamaChunk(struct cmdlineInfo const cmdline,
+ 
+ static void
+ doChrmChunk(struct cmdlineInfo const cmdline,
++            png_struct *       const png_ptr,
+             png_info *         const info_ptr) {
+ 
+     if (cmdline.rgbSpec) {
+         /* cHRM chunk */
+-        info_ptr->valid |= PNG_INFO_cHRM;
+-
+-        info_ptr->x_white = cmdline.rgb.wx;
+-        info_ptr->y_white = cmdline.rgb.wy;
+-        info_ptr->x_red   = cmdline.rgb.rx;
+-        info_ptr->y_red   = cmdline.rgb.ry;
+-        info_ptr->x_green = cmdline.rgb.gx;
+-        info_ptr->y_green = cmdline.rgb.gy;
+-        info_ptr->x_blue  = cmdline.rgb.bx;
+-        info_ptr->y_blue  = cmdline.rgb.by;
++	
++        png_set_cHRM (png_ptr, info_ptr, cmdline.rgb.wx, cmdline.rgb.wy,
++                      cmdline.rgb.rx, cmdline.rgb.ry, cmdline.rgb.gx,
++                      cmdline.rgb.gy, cmdline.rgb.bx, cmdline.rgb.by);
+     }
+ }
+ 
+@@ -2239,15 +2229,12 @@ doChrmChunk(struct cmdlineInfo const cmdline,
+ 
+ static void
+ doPhysChunk(struct cmdlineInfo const cmdline,
++            png_struct *       const png_ptr,
+             png_info *         const info_ptr) {
+ 
+     if (cmdline.sizeSpec) {
+         /* pHYS chunk */
+-        info_ptr->valid |= PNG_INFO_pHYs;
+-
+-        info_ptr->x_pixels_per_unit = cmdline.size.x;
+-        info_ptr->y_pixels_per_unit = cmdline.size.y;
+-        info_ptr->phys_unit_type    = cmdline.size.unit;
++        png_set_pHYs(png_ptr, info_ptr, cmdline.size.x, cmdline.size.y, cmdline.size.unit);
+     }
+ }
+ 
+@@ -2256,26 +2243,28 @@ doPhysChunk(struct cmdlineInfo const cmdline,
+ 
+ static void
+ doTimeChunk(struct cmdlineInfo const cmdline,
++            png_struct *       const png_ptr,
+             png_info *         const info_ptr) {
+ 
+     if (cmdline.modtimeSpec) {
+         /* tIME chunk */
+-        info_ptr->valid |= PNG_INFO_tIME;
+-
+-        png_convert_from_time_t(&info_ptr->mod_time, cmdline.modtime);
++        png_timep ptime;
++        png_convert_from_time_t(ptime, cmdline.modtime);
++        png_set_tIME(png_ptr, info_ptr, ptime);
+     }
+ }
+ 
+ 
+ 
+ static void
+-doSbitChunk(png_info * const pngInfoP,
++doSbitChunk(png_struct * const pngP,
++            png_info * const pngInfoP,
+             xelval     const pngMaxval,
+             xelval     const maxval,
+             bool       const alpha,
+             xelval     const alphaMaxval) {
+ 
+-    if (pngInfoP->color_type != PNG_COLOR_TYPE_PALETTE &&
++    if (png_get_color_type(pngP, pngInfoP) != PNG_COLOR_TYPE_PALETTE &&
+         (pngMaxval > maxval || (alpha && pngMaxval > alphaMaxval))) {
+ 
+         /* We're writing in a bit depth that doesn't match the maxval
+@@ -2294,27 +2283,29 @@ doSbitChunk(png_info * const pngInfoP,
+            sBIT chunk.
+         */
+ 
+-        pngInfoP->valid |= PNG_INFO_sBIT;
+-
+         {
+             int const sbitval = pm_maxvaltobits(MIN(maxval, pngMaxval));
++            png_color_8 sbit;
+ 
+-            if (pngInfoP->color_type & PNG_COLOR_MASK_COLOR) {
+-                pngInfoP->sig_bit.red   = sbitval;
+-                pngInfoP->sig_bit.green = sbitval;
+-                pngInfoP->sig_bit.blue  = sbitval;
++            (void)memset(&sbit, 0, sizeof(sbit));
++            if (png_get_color_type(pngP, pngInfoP) & PNG_COLOR_MASK_COLOR) {
++                sbit.red   = sbitval;
++                sbit.green = sbitval;
++                sbit.blue  = sbitval;
+             } else
+-                pngInfoP->sig_bit.gray = sbitval;
++                sbit.gray = sbitval;
+             
+             if (verbose)
+                 pm_message("Writing sBIT chunk with bits = %d", sbitval);
++
++            if (png_get_color_type(pngP, pngInfoP) & PNG_COLOR_MASK_ALPHA) {
++                sbit.alpha =
++                    pm_maxvaltobits(MIN(alphaMaxval, pngMaxval));
++                if (verbose)
++                    pm_message("  alpha bits = %d", sbit.alpha);
++            }
++            png_set_sBIT(pngP, pngInfoP, &sbit);
+         }
+-        if (pngInfoP->color_type & PNG_COLOR_MASK_ALPHA) {
+-            pngInfoP->sig_bit.alpha =
+-                pm_maxvaltobits(MIN(alphaMaxval, pngMaxval));
+-            if (verbose)
+-                pm_message("  alpha bits = %d", pngInfoP->sig_bit.alpha);
+-        }
+     }
+ }
+ 
+@@ -2410,6 +2401,8 @@ convertpnm(struct cmdlineInfo const cmdline,
+   xelval maxmaxval;
+   gray ** alpha_mask;
+ 
++  int color_type;
++
+   /* these guys are initialized to quiet compiler warnings: */
+   maxmaxval = 255;
+   alpha_mask = NULL;
+@@ -2595,43 +2588,42 @@ convertpnm(struct cmdlineInfo const cmdline,
+     pm_error ("setjmp returns error condition (2)");
+   }
+ 
+-  png_init_io (png_ptr, stdout);
+-  info_ptr->width = cols;
+-  info_ptr->height = rows;
+-  info_ptr->bit_depth = depth;
+-
+   if (colorMapped)
+-    info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
+-  else if (pnm_type == PPM_TYPE)
+-    info_ptr->color_type = PNG_COLOR_TYPE_RGB;
+-  else
+-    info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
++    color_type = PNG_COLOR_TYPE_PALETTE;
++  else if (pnm_type == PPM_TYPE) {
++    if (alpha)
++      color_type = PNG_COLOR_TYPE_RGB_ALPHA;
++    else
++      color_type = PNG_COLOR_TYPE_RGB;
++  } else {
++    if (alpha)
++      color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
++    else
++      color_type = PNG_COLOR_TYPE_GRAY;
++  }
+ 
+-  if (alpha && info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
+-    info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
++  png_set_IHDR(png_ptr, info_ptr, cols, rows, depth, color_type, 0, 0, 0);
++  png_init_io (png_ptr, stdout);
+ 
+-  info_ptr->interlace_type = cmdline.interlace;
++  if (cmdline.interlace)
++    png_set_interlace_handling(png_ptr);
+ 
+-  doGamaChunk(cmdline, info_ptr);
++  doGamaChunk(cmdline, png_ptr, info_ptr);
+ 
+-  doChrmChunk(cmdline, info_ptr);
++  doChrmChunk(cmdline, png_ptr, info_ptr);
+ 
+-  doPhysChunk(cmdline, info_ptr);
++  doPhysChunk(cmdline, png_ptr, info_ptr);
+ 
+-  if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
++  if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
+ 
+     /* creating PNG palette  (PLTE and tRNS chunks) */
+ 
+     createPngPalette(palette_pnm, palette_size, maxval,
+                      trans_pnm, trans_size, alpha_maxval, 
+                      palette, trans);
+-    info_ptr->valid |= PNG_INFO_PLTE;
+-    info_ptr->palette = palette;
+-    info_ptr->num_palette = palette_size;
++    png_set_PLTE(png_ptr, info_ptr, palette, palette_size);
      if (trans_size > 0) {
-         info_ptr->valid |= PNG_INFO_tRNS;
+-        info_ptr->valid |= PNG_INFO_tRNS;
 -        info_ptr->trans = trans;
-+        info_ptr->trans_alpha = trans;
-         info_ptr->num_trans = trans_size;   /* omit opaque values */
+-        info_ptr->num_trans = trans_size;   /* omit opaque values */
++        png_set_tRNS(png_ptr, info_ptr, trans, trans_size, NULL);
      }
      /* creating hIST chunk */
-@@ -2667,7 +2669,7 @@
-         info_ptr->color_type == PNG_COLOR_TYPE_RGB) {
+     if (cmdline.hist) {
+@@ -2657,18 +2649,17 @@ convertpnm(struct cmdlineInfo const cmdline,
+ 
+         ppm_freecolorhash(cht);
+ 
+-        info_ptr->valid |= PNG_INFO_hIST;
+-        info_ptr->hist = histogram;
++        png_set_hIST(png_ptr, info_ptr, histogram);
+         if (verbose)
+             pm_message("histogram created");
+     }
+   } else { /* color_type != PNG_COLOR_TYPE_PALETTE */
+-    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) {
          if (transparent > 0) {
-             info_ptr->valid |= PNG_INFO_tRNS;
+-            info_ptr->valid |= PNG_INFO_tRNS;
 -            info_ptr->trans_values = 
-+            info_ptr->trans_color = 
-                 xelToPngColor_16(transcolor, maxval, png_maxval);
+-                xelToPngColor_16(transcolor, maxval, png_maxval);
++            png_color_16 trans_color = xelToPngColor_16(transcolor, maxval, png_maxval);
++            png_set_tRNS(png_ptr, info_ptr, NULL, 0, &trans_color);
++                
          }
      } else {
-@@ -2679,10 +2681,10 @@
-         if (info_ptr->valid && PNG_INFO_tRNS) 
+         /* This is PNG_COLOR_MASK_ALPHA.  Transparency will be handled
+@@ -2676,43 +2667,49 @@ convertpnm(struct cmdlineInfo const cmdline,
+         */
+     }
+     if (verbose) {
+-        if (info_ptr->valid && PNG_INFO_tRNS) 
++        if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
++            png_color_16p trans_color;
++
++            png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_color);
              pm_message("Transparent color {gray, red, green, blue} = "
                         "{%d, %d, %d, %d}",
 -                       info_ptr->trans_values.gray,
 -                       info_ptr->trans_values.red,
 -                       info_ptr->trans_values.green,
 -                       info_ptr->trans_values.blue);
-+                       info_ptr->trans_color.gray,
-+                       info_ptr->trans_color.red,
-+                       info_ptr->trans_color.green,
-+                       info_ptr->trans_color.blue);
-         else
+-        else
++                       trans_color->gray,
++                       trans_color->red,
++                       trans_color->green,
++                       trans_color->blue);
++        } else
              pm_message("No transparent color");
      }
+   }
+ 
+   /* bKGD chunk */
+   if (cmdline.background) {
+-      info_ptr->valid |= PNG_INFO_bKGD;
+-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) {
+-          info_ptr->background.index = background_index;
++      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);
++          png_color_16 background = xelToPngColor_16(backcolor, maxval, png_maxval);
++          png_set_bKGD(png_ptr, info_ptr, &background);
+           if (verbose)
+               pm_message("Writing bKGD chunk with background color "
+                          " {gray, red, green, blue} = {%d, %d, %d, %d}",
+-                         info_ptr->background.gray, 
+-                         info_ptr->background.red, 
+-                         info_ptr->background.green, 
+-                         info_ptr->background.blue ); 
++                         background.gray, 
++                         background.red, 
++                         background.green, 
++                         background.blue ); 
+       }
+   }
+ 
+-  doSbitChunk(info_ptr, png_maxval, maxval, alpha, alpha_maxval);
++  doSbitChunk(png_ptr, info_ptr, png_maxval, maxval, alpha, alpha_maxval);
+ 
+   /* tEXT and zTXT chunks */
+   if (cmdline.text || cmdline.ztxt)
+-      pnmpng_read_text(info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose);
++      pnmpng_read_text(png_ptr, info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose);
+ 
+-  doTimeChunk(cmdline, info_ptr);
++  doTimeChunk(cmdline, png_ptr, info_ptr);
+ 
+   if (cmdline.filterSet != 0)
+       png_set_filter(png_ptr, 0, cmdline.filterSet);
+@@ -2722,6 +2719,7 @@ convertpnm(struct cmdlineInfo const cmdline,
+   /* write the png-info struct */
+   png_write_info(png_ptr, info_ptr);
+ 
++#if 0
+   if (cmdline.text || cmdline.ztxt)
+       /* prevent from being written twice with png_write_end */
+       info_ptr->num_text = 0;
+@@ -2729,6 +2727,7 @@ convertpnm(struct cmdlineInfo const cmdline,
+   if (cmdline.modtime)
+       /* prevent from being written twice with png_write_end */
+       info_ptr->valid &= ~PNG_INFO_tIME;
++#endif
+ 
+   /* let libpng take care of, e.g., bit-depth conversions */
+   png_set_packing (png_ptr);