Get "pnmtopng" to build with new "png" package. "pngtopnm" still fails.

4 files changed, 466 insertions, 23 deletions

diff --git a/graphics/netpbm/distinfo b/graphics/netpbm/distinfo
index c880af0fb30..37e0e44ffae 100644
--- a/graphics/netpbm/distinfo
+++ b/graphics/netpbm/distinfo
@@ -1,17 +1,19 @@
-$NetBSD: distinfo,v 1.79 2010/11/04 10:57:50 adam Exp $
+$NetBSD: distinfo,v 1.80 2011/01/14 21:51:58 tron Exp $
 
 SHA1 (netpbm-10.35.77.tgz) = 81a2b02db339e2bae8cc38db9b987b1cb0b228e2
 RMD160 (netpbm-10.35.77.tgz) = e7d7fa5a696ef962fd8d61eaed803548716e510c
 Size (netpbm-10.35.77.tgz) = 2547233 bytes
 SHA1 (patch-aa) = fb94fb43c4c63113e9c720ea399a5cecb2c79977
 SHA1 (patch-ab) = 4d6508ad837d455ea3f8ebaa704f33f9e089f6e0
-SHA1 (patch-ac) = d7e23b2b905c6f9c6114e17b16fcce3eadb29b56
+SHA1 (patch-ac) = 3cf3a660e0ed769d5c5784fce27bf7db09994ffa
 SHA1 (patch-ad) = b4a5833e18afd5a991aad897674386a3f00c3ee1
 SHA1 (patch-ae) = 33a5be2843dd85b530f5e6ba496cd0380cd5edd1
 SHA1 (patch-af) = 7ac8b5a431cd007ccc23ea337194a5c542ff0a54
 SHA1 (patch-ag) = 093fe392a3e6156cc55f225a6f139842c0d00570
 SHA1 (patch-ah) = 10d7e7f59a0d7c857531db872cd35dc02a048ba1
 SHA1 (patch-ai) = 083ddf8b36a74ca39508b6a3b0c35956ac19fbb7
+SHA1 (patch-aj) = 44521e88f446a9a4eea6d9ffeb20ceba4653faca
+SHA1 (patch-ak) = f1e06e236442c96670b1f1829d4e67d051ecb776
 SHA1 (patch-ao) = b4307205f605d4c9c8f11c00e1a633960b33b2d3
 SHA1 (patch-aw) = bd890324e95fa7bb893d9d5cdab9d5a33dcff777
 SHA1 (patch-ax) = d50e56191192b4caf423ed081581868bb1a63de8
diff --git a/graphics/netpbm/patches/patch-ac b/graphics/netpbm/patches/patch-ac
index 1946546c99a..18aa0f883f0 100644
--- a/graphics/netpbm/patches/patch-ac
+++ b/graphics/netpbm/patches/patch-ac
@@ -1,8 +1,20 @@
-$NetBSD: patch-ac,v 1.19 2010/06/13 22:44:39 wiz Exp $
+$NetBSD: patch-ac,v 1.20 2011/01/14 21:51:59 tron Exp $
 
---- converter/other/pnmtopng.c.orig	2009-09-03 15:34:36.000000000 +0000
-+++ converter/other/pnmtopng.c
-@@ -69,11 +69,6 @@
+Fix build with png-1.5.
+
+--- converter/other/pnmtopng.c.orig	2010-07-10 02:38:01.000000000 +0100
++++ converter/other/pnmtopng.c	2011-01-14 21:49:17.000000000 +0000
+@@ -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,11 +70,6 @@
  #include "nstring.h"
  #include "version.h"
  
@@ -14,36 +26,369 @@ $NetBSD: patch-ac,v 1.19 2010/06/13 22:44:39 wiz Exp $
  
  
  struct zlibCompression {
-@@ -2611,7 +2606,7 @@ convertpnm(struct cmdlineInfo const cmdl
-     info_ptr->num_palette = palette_size;
+@@ -2079,6 +2075,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 +2088,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 +2114,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 +2171,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 +2183,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 +2196,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 +2212,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 +2226,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 +2266,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 +2384,8 @@
+   xelval maxmaxval;
+   gray ** alpha_mask;
+ 
++  int color_type;
++
+   /* these guys are initialized to quiet compiler warnings: */
+   maxmaxval = 255;
+   alpha_mask = NULL;
+@@ -2576,43 +2571,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, PNG_COLOR_TYPE_PALETTE, 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 */
-@@ -2648,7 +2643,7 @@ convertpnm(struct cmdlineInfo const cmdl
-         info_ptr->color_type == PNG_COLOR_TYPE_RGB) {
+     if (cmdline.hist) {
+@@ -2638,18 +2632,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->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 {
-@@ -2660,10 +2655,10 @@ convertpnm(struct cmdlineInfo const cmdl
-         if (info_ptr->valid && PNG_INFO_tRNS) 
+         /* This is PNG_COLOR_MASK_ALPHA.  Transparency will be handled
+@@ -2657,43 +2650,43 @@
+         */
+     }
+     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;
+-      } else {
+-          info_ptr->background = 
+-              xelToPngColor_16(backcolor, maxval, png_maxval);
++      if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE) {
++          png_color_16 background = xelToPngColor_16(backcolor, maxval, png_maxval);
++          png_set_bKGD(png_ptr, info_ptr, &background);
+           if (verbose)
+               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 +2696,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 +2704,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);
diff --git a/graphics/netpbm/patches/patch-aj b/graphics/netpbm/patches/patch-aj
new file mode 100644
index 00000000000..dd233908dd1
--- /dev/null
+++ b/graphics/netpbm/patches/patch-aj
@@ -0,0 +1,16 @@
+$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);
diff --git a/graphics/netpbm/patches/patch-ak b/graphics/netpbm/patches/patch-ak
new file mode 100644
index 00000000000..2041e5e51ff
--- /dev/null
+++ b/graphics/netpbm/patches/patch-ak
@@ -0,0 +1,80 @@
+$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);
+ }
+ 
+