$NetBSD: patch-ad,v 1.4.8.1 2011/04/06 22:17:43 tron Exp $

Fix build with png-1.5.

--- image/png.c.orig	1999-03-29 02:23:46.000000000 +0000
+++ image/png.c
@@ -60,33 +60,33 @@ lf_info_callback(png_struct *state, png_
     int orig_depth = 0;
     pngState *png = (pngState *) png_get_progressive_ptr(state);
 
-    if (info->bit_depth < 8 && (PNG_COLOR_TYPE_RGB == info->color_type ||
-            PNG_COLOR_TYPE_RGB_ALPHA == info->color_type))
+    if (png_get_bit_depth(state, info) < 8 && (PNG_COLOR_TYPE_RGB == png_get_color_type(state, info) ||
+            PNG_COLOR_TYPE_RGB_ALPHA == png_get_color_type(state, info)))
         png_set_expand(state);
 
     /* I wish the frame's background colour was available here */
-    if (info->color_type & PNG_COLOR_MASK_ALPHA) {
+    if (png_get_color_type(state, info) & PNG_COLOR_MASK_ALPHA) {
         png_color_16 bg;
         int gflag = PNG_BACKGROUND_GAMMA_SCREEN;
         double gval = 1.0;
         int expand = 0;
 
         bg.red = bg.green = bg.blue = bg.gray = 0;
-        if (PNG_COLOR_TYPE_PALETTE == info->color_type)
+        if (PNG_COLOR_TYPE_PALETTE == png_get_color_type(state, info))
             png_set_expand(state);
 
         png_set_background(state, &bg, gflag, expand, gval);
     }
 
-    if (info->bit_depth < 8 && (info->bit_depth > 1 ||
-            PNG_COLOR_TYPE_GRAY != info->color_type)) {
-        if (PNG_COLOR_TYPE_GRAY == info->color_type)
-            orig_depth = info->bit_depth;
+    if (png_get_bit_depth(state, info) < 8 && (png_get_bit_depth(state, info) > 1 ||
+            PNG_COLOR_TYPE_GRAY != png_get_color_type(state, info))) {
+        if (PNG_COLOR_TYPE_GRAY == png_get_color_type(state, info))
+            orig_depth = png_get_bit_depth(state, info);
         png_set_packing(state);
     }
  
     /* tell libpng to strip 16 bit depth files down to 8 bits */
-    if (info->bit_depth > 8)
+    if (png_get_bit_depth(state, info) > 8)
         png_set_strip_16(state);
 
     png_set_interlace_handling(state);
@@ -95,18 +95,21 @@ lf_info_callback(png_struct *state, png_
     png_read_update_info(state, info);
 
     /* allocate the memory to hold the image using the fields of png_info. */
-    if (PNG_COLOR_TYPE_GRAY == info->color_type && 1 == info->bit_depth) {
-        png->image = newBitImage(info->width, info->height);
+    if (PNG_COLOR_TYPE_GRAY == png_get_color_type(state, info) && 1 == png_get_bit_depth(state, info)) {
+        png->image = newBitImage(png_get_image_width(state, info), png_get_image_height(state, info));
        if (!png->image) {
            png->done = image_error;
            return;
        }
 
         png_set_invert_mono(state);
-    } else if (PNG_COLOR_TYPE_PALETTE == info->color_type) {
+    } else if (PNG_COLOR_TYPE_PALETTE == png_get_color_type(state, info)) {
         int i;
+	png_colorp palette;
+	int num_palette;
 
-        png->image = newRGBImage(info->width, info->height, info->bit_depth);
+	png_get_PLTE(state, info, &palette, &num_palette);
+        png->image = newRGBImage(png_get_image_width(state, info), png_get_image_height(state, info), png_get_bit_depth(state, info));
        if (!png->image) {
            png->done = image_error;
            return;
@@ -115,28 +118,32 @@ lf_info_callback(png_struct *state, png_
         png->image->rgb.red = png->cmap[0];
         png->image->rgb.green = png->cmap[1];
         png->image->rgb.blue = png->cmap[2];
-        for (i = 0; i < info->num_palette; ++i) {
-            png->image->rgb.red[i] = info->palette[i].red << 8;
-            png->image->rgb.green[i] = info->palette[i].green << 8;
-            png->image->rgb.blue[i] = info->palette[i].blue << 8;
+        for (i = 0; i < num_palette; ++i) {
+            png->image->rgb.red[i] = palette[i].red << 8;
+            png->image->rgb.green[i] = palette[i].green << 8;
+            png->image->rgb.blue[i] = palette[i].blue << 8;
         }
-        png->image->rgb.used = info->num_palette;
-        if (info->valid & PNG_INFO_tRNS) {
+        png->image->rgb.used = num_palette;
+        if (png_get_valid(state, info, PNG_INFO_tRNS)) {
             int val, i;
+	    png_bytep trans_alpha;
+	    int num_trans;
+	    png_color_16p trans_color;
 
+	    png_get_tRNS(state, info, &trans_alpha, &num_trans, &trans_color);
             val = 0;
-            for (i = 0; i < info->num_trans; ++i) {
-                if (info->trans[i] < info->trans[val])
+            for (i = 0; i < num_trans; ++i) {
+                if (trans_alpha[i] < trans_alpha[val])
                     val = i;
             }
             png->image->transparent = val;
         }
-    } else if (PNG_COLOR_TYPE_GRAY == info->color_type) {
+    } else if (PNG_COLOR_TYPE_GRAY == png_get_color_type(state, info)) {
         int i;
-        int depth = orig_depth ? orig_depth : info->bit_depth;
+        int depth = orig_depth ? orig_depth : png_get_bit_depth(state, info);
         int maxval = (1 << depth) - 1;
 
-        png->image = newRGBImage(info->width, info->height, depth);
+        png->image = newRGBImage(png_get_image_width(state, info), png_get_image_height(state, info), depth);
        if (!png->image) {
            png->done = image_error;
            return;
@@ -153,10 +160,16 @@ lf_info_callback(png_struct *state, png_
         }
         png->image->rgb.used = maxval + 1;
 
-        if (info->valid & PNG_INFO_tRNS)
-            png->image->transparent = info->trans_values.gray;
+        if (png_get_valid(state, info, PNG_INFO_tRNS)) {
+	    png_bytep trans_alpha;
+	    int num_trans;
+	    png_color_16p trans_color;
+
+	    png_get_tRNS(state, info, &trans_alpha, &num_trans, &trans_color);
+            png->image->transparent = trans_color->gray;
+	}
     } else {
-        png->image = newTrueImage(info->width, info->height);
+        png->image = newTrueImage(png_get_image_width(state, info), png_get_image_height(state, info));
        if (!png->image) {
            png->done = image_error;
            return;
@@ -164,10 +177,13 @@ lf_info_callback(png_struct *state, png_
 
     }
 
-    if (info->valid & PNG_INFO_gAMA && png->image->type != IBITMAP)
-        png->image->gamma = 1.0 / info->gamma;
+    if (png_get_valid(state, info, PNG_INFO_gAMA) && png->image->type != IBITMAP) {
+	double gamma;
+	png_get_gAMA(state, info, &gamma);
+        png->image->gamma = 1.0 / gamma;
+    }
 
-    assert((png->image->width * png->image->pixlen + 7) / 8 == info->rowbytes);
+    assert((png->image->width * png->image->pixlen + 7) / 8 == png_get_rowbytes(state, info));
 }
 
 
@@ -192,12 +208,12 @@ lf_row_callback(png_struct *state, png_b
         /* I can't say I'm too fond of this endian business. */
 #ifdef CHIMERA_LITTLE_ENDIAN
         if (IBITMAP == png->image->type)
-           lc_reverse_byte(old_row, png->info->rowbytes);
+           lc_reverse_byte(old_row, png_get_rowbytes(png->state, png->info));
 #endif
         (png->lineProc)(png->closure, row_num, row_num);
 #ifdef CHIMERA_LITTLE_ENDIAN
         if (IBITMAP == png->image->type)
-           lc_reverse_byte(old_row,png->info->rowbytes);
+           lc_reverse_byte(old_row,png_get_rowbytes(png->state, png->info));
 #endif
     }
 }
@@ -219,20 +235,14 @@ pngDestroy(void *pointer)
     if (!png)
         return;
 
-    if (setjmp(png->state->jmpbuf))
+    if (setjmp(png_jmpbuf(png->state)))
         return;
 
-    if (png->state) {
-        png_read_destroy(png->state, png->info, (png_info *) 0);
-        free_mem(png->state);
+    if ((png->state) && (png->info)) {
+        png_destroy_read_struct(&png->state, &png->info, (png_info **)NULL);
         png->state = 0;
     }
 
-    if (png->info) {
-        free_mem(png->info);
-        png->info = 0;
-    }
-
     if (png->image) {
         freeImage(png->image);
         png->image = 0;
@@ -246,7 +256,7 @@ pngAddData(void *pointer, byte *data, in
 {
     pngState *png = (pngState *) pointer;
 
-    if (setjmp(png->state->jmpbuf))
+    if (setjmp(png_jmpbuf(png->state)))
         return image_error;
 
     if (len > png->lenSoFar) {
@@ -275,28 +285,22 @@ pngInit(void (*lineProc)(void *, int, in
     memset(png, 0, sizeof(pngState));
     png->lineProc = lineProc;
     png->closure = closure;
-    png->state = (png_struct *) alloc_mem(sizeof(png_struct));
+    png->state = (png_struct *) png_create_read_struct(PNG_LIBPNG_VER_STRING,
+        NULL, NULL, NULL);
     if (!png->state)
         return;
 
-    png->info = (png_info *) alloc_mem(sizeof(png_info));
+    png->info = (png_info *) png_create_info_struct(png->state);
     if (!png->info) {
-        free_mem(png->state);
+        png_destroy_read_struct(&png->state, NULL, (png_info **)NULL);
         return;
     }
 
-    if (setjmp(png->state->jmpbuf)) {
-        png_read_destroy(png->state, png->info, (png_info *) 0);
-        free_mem(png->state);
-        free_mem(png->info);
-        png->state = 0;
-        png->info = 0;
+    if (setjmp(png_jmpbuf(png->state))) {
+        png_destroy_read_struct(&png->state, &png->info, (png_info **)NULL);
         return;
     }
 
-    png_info_init(png->info);
-    png_read_init(png->state);
-
     png_set_progressive_read_fn(png->state, (void *) png, lf_info_callback,
         lf_row_callback, lf_end_callback);
     png->done = image_need_data;
