netpbm/patches/netpbm-10.35.81-libpng15.patch

consolidated patches ac,af,aj,ak,al from netbsd

##

$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-12-10 18:19:40.000000000 +0000
+++ converter/other/pnmtopng.c	2011-01-15 11:15:25.000000000 +0000
@@ -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>    /* includes setjmp.h */
+#include <zlib.h>
 #include "pnm.h"
 #include "pngtxt.h"
 #include "shhopt.h"
@@ -69,13 +70,6 @@
 #include "nstring.h"
 #include "version.h"
 
-#if PNG_LIBPNG_VER >= 10400
-#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
-#error You need either an older PNG library (older than 1.4)
-#error newer Netpbm source code (at least 10.47.04)
-#endif
-
-
 struct zlibCompression {
     /* 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,
+            png_struct *         const png_ptr,
             png_info *           const info_ptr,
             xelval               const png_maxval,
             unsigned int         const depth) {
@@ -2091,20 +2086,20 @@
         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;
@@ -2117,7 +2112,7 @@
         } 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)
@@ -2174,7 +2169,7 @@
             
             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);
         }
@@ -2186,12 +2181,12 @@
 
 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);
     }
 }
 
@@ -2199,20 +2194,15 @@
 
 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);
     }
 }
 
@@ -2220,15 +2210,12 @@
 
 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);
     }
 }
 
@@ -2237,26 +2224,28 @@
 
 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
@@ -2275,26 +2264,28 @@
            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 (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);
+
+            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);
         }
     }
 }
@@ -2391,6 +2382,8 @@
   xelval maxmaxval;
   gray ** alpha_mask;
 
+  int color_type;
+
   /* these guys are initialized to quiet compiler warnings: */
   maxmaxval = 255;
   alpha_mask = NULL;
@@ -2576,43 +2569,42 @@
     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->trans = trans;
-        info_ptr->num_trans = trans_size;   /* omit opaque values */
+        png_set_tRNS(png_ptr, info_ptr, trans, trans_size, NULL);
     }
     /* creating hIST chunk */
     if (cmdline.hist) {
@@ -2638,18 +2630,17 @@
 
         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->trans_values = 
-                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 {
         /* This is PNG_COLOR_MASK_ALPHA.  Transparency will be handled
@@ -2657,43 +2648,49 @@
         */
     }
     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);
-        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);
@@ -2703,6 +2700,7 @@
   /* 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;
@@ -2710,6 +2708,7 @@
   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);
$NetBSD: patch-af,v 1.16 2011/04/04 09:17:24 adam Exp $

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"
 
-#if PNG_LIBPNG_VER >= 10400
-#error Your PNG library (<png.h>) is incompatible with this Netpbm source code.
-#error You need either an older PNG library (older than 1.4)
-#error newer Netpbm source code (at least 10.48)
-#endif
-
 typedef struct _jmpbuf_wrapper {
   jmp_buf jmpbuf;
 } jmpbuf_wrapper;
@@ -187,7 +181,7 @@
 
 
 
-#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_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");
@@ -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
            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 < num_trans && !foundGray;
                  ++i) {
-                if (info_ptr->trans[i] != 0 &&
-                    info_ptr->trans[i] != maxval) {
+                if (trans_alpha[i] != 0 &&
+                    trans_alpha[i] != maxval) {
                     foundGray = TRUE;
                 }
             }
@@ -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)
-                    if (info_ptr->trans[i] != 0 && info_ptr->trans[i] != 255) {
+                for (i = 0; i < num_trans; ++i)
+                    if (trans_alpha[i] != 0 && trans_alpha[i] != 255) {
                         trans_mix = FALSE;
                         break;
                     }
@@ -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,
-                                       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);
+                }
             }
             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);
+                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);
$NetBSD: patch-aj,v 1.13 2011/01/14 21:51:59 tron Exp $

Fix build with png-1.5.

--- converter/other/pngtxt.h.orig	2006-08-19 04:12:28.000000000 +0100
+++ converter/other/pngtxt.h	2011-01-14 21:39:26.000000000 +0000
@@ -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);
$NetBSD: patch-ak,v 1.9 2011/01/14 21:51:59 tron Exp $

Fix build with png-1.5.

--- converter/other/pngtxt.c.orig	2006-08-19 04:12:28.000000000 +0100
+++ converter/other/pngtxt.c	2011-01-14 21:28:09.000000000 +0000
@@ -240,7 +240,8 @@
 
 
 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 @@
     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 @@
 
     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 @@
             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 @@
                         ++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 @@
                         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);
 }
 
 
$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);
 