[arch-commits] Commit in gimp/trunk (PKGBUILD libpng_compile.patch)
Eric Bélanger
eric at archlinux.org
Sat Jan 21 08:26:49 UTC 2012
Date: Saturday, January 21, 2012 @ 03:26:49
Author: eric
Revision: 147054
upgpkg: gimp 2.6.11-8
Rebuild against libpng 1.5 and libtiff 4.0
Added:
gimp/trunk/libpng_compile.patch
Modified:
gimp/trunk/PKGBUILD
----------------------+
PKGBUILD | 18
libpng_compile.patch | 984 +++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 992 insertions(+), 10 deletions(-)
Modified: PKGBUILD
===================================================================
--- PKGBUILD 2012-01-21 05:38:18 UTC (rev 147053)
+++ PKGBUILD 2012-01-21 08:26:49 UTC (rev 147054)
@@ -3,7 +3,7 @@
pkgname=gimp
pkgver=2.6.11
-pkgrel=7
+pkgrel=8
pkgdesc="GNU Image Manipulation Program"
arch=('i686' 'x86_64')
url="http://www.gimp.org/"
@@ -19,23 +19,21 @@
options=('!libtool' '!makeflags')
conflicts=('gimp-devel')
install=gimp.install
-#source=(ftp://ftp.gimp.org/pub/gimp/v${pkgver%.*}/${pkgname}-${pkgver}.tar.bz2 linux.gpl
-source=(http://mirror.umoss.org/gimp/gimp/v${pkgver%.*}/${pkgname}-${pkgver}.tar.bz2 linux.gpl
- uri-backend-libcurl.patch gimp-poppler-0.18.patch)
-md5sums=('bb2939fe13e54fc7255cef5d097bb5dd'
- 'bb27bc214261d36484093e857f015f38'
- 'e894f4b2ffa92c71448fdd350e9b78c6'
- 'bfc73f80e911ed7a7d500d80973469f1')
+source=(ftp://ftp.gimp.org/pub/gimp/v${pkgver%.*}/${pkgname}-${pkgver}.tar.bz2 linux.gpl
+ uri-backend-libcurl.patch gimp-poppler-0.18.patch libpng_compile.patch)
sha1sums=('2f9d596e727bdbf304fa78257c1731d9faf3934c'
'110ce9798173b19a662d086ed7b882b4729f06cf'
'a65b0ee6cd1b4345065b7b98c07f2fed15f844f4'
- '1479a6d80be7adf74f66a3b88057a5029fe892e8')
+ '1479a6d80be7adf74f66a3b88057a5029fe892e8'
+ '5ce329d2e2cb136e93f16117fa79ab6e31866f68')
build() {
cd "${srcdir}/${pkgname}-${pkgver}"
patch -p1 < ../uri-backend-libcurl.patch
patch -p1 < ../gimp-poppler-0.18.patch
- PYTHON=/usr/bin/python2 ./configure --prefix=/usr --sysconfdir=/etc \
+ patch -p1 < ../libpng_compile.patch
+ PYTHON=/usr/bin/python2 LIBS+="-lgobject-2.0 -lglib-2.0 -lm" \
+ ./configure --prefix=/usr --sysconfdir=/etc \
--enable-mp --enable-gimp-console --enable-gimp-remote \
--enable-python --with-gif-compression=lzw --with-libcurl \
--without-aa --without-hal --without-gvfs --without-gnomevfs
Added: libpng_compile.patch
===================================================================
--- libpng_compile.patch (rev 0)
+++ libpng_compile.patch 2012-01-21 08:26:49 UTC (rev 147054)
@@ -0,0 +1,984 @@
+Description: fix compilation against libpng 1.5
+Origin: upstream, 2.6 branch, diff of 2917a0e..e7469007
+Bug-Debian: http://bugs.debian.org/649972
+
+diff --git a/plug-ins/common/file-mng.c b/plug-ins/common/file-mng.c
+index 29dd155..8054504 100644
+--- a/plug-ins/common/file-mng.c
++++ b/plug-ins/common/file-mng.c
+@@ -136,7 +136,6 @@ struct mng_data_t
+ gint32 default_dispose;
+ };
+
+-
+ /* Values of the instance of the above struct when the plug-in is
+ * first invoked. */
+
+@@ -160,6 +159,21 @@ static struct mng_data_t mng_data =
+ };
+
+
++/* These are not saved or restored. */
++
++struct mng_globals_t
++{
++ gboolean has_trns;
++ png_bytep trans;
++ int num_trans;
++ gboolean has_plte;
++ png_colorp palette;
++ int num_palette;
++};
++
++static struct mng_globals_t mngg;
++
++
+ /* The output FILE pointer which is used by libmng;
+ * passed around as user data. */
+ struct mnglib_userdata_t
+@@ -196,7 +210,8 @@ static gboolean respin_cmap (png_structp png_ptr,
+ png_infop png_info_ptr,
+ guchar *remap,
+ gint32 image_id,
+- GimpDrawable *drawable);
++ GimpDrawable *drawable,
++ int *bit_depth);
+
+ static gboolean mng_save_image (const gchar *filename,
+ gint32 image_id,
+@@ -414,6 +429,18 @@ ia_has_transparent_pixels (guchar *pixels,
+ return FALSE;
+ }
+
++static int
++get_bit_depth_for_palette (int num_palette)
++{
++ if (num_palette <= 2)
++ return 1;
++ else if (num_palette <= 4)
++ return 2;
++ else if (num_palette <= 16)
++ return 4;
++ else
++ return 8;
++}
+
+ /* Spins the color map (palette) putting the transparent color at
+ * index 0 if there is space. If there isn't any space, warn the user
+@@ -422,11 +449,12 @@ ia_has_transparent_pixels (guchar *pixels,
+ */
+
+ static gboolean
+-respin_cmap (png_structp png_ptr,
+- png_infop png_info_ptr,
++respin_cmap (png_structp pp,
++ png_infop info,
+ guchar *remap,
+ gint32 image_id,
+- GimpDrawable *drawable)
++ GimpDrawable *drawable,
++ int *bit_depth)
+ {
+ static guchar trans[] = { 0 };
+ guchar *before;
+@@ -464,10 +492,13 @@ respin_cmap (png_structp png_ptr,
+
+ if (transparent != -1)
+ {
+- png_color palette[256] = { {0, 0, 0} };
++ static png_color palette[256] = { {0, 0, 0} };
+ gint i;
+
+- png_set_tRNS (png_ptr, png_info_ptr, (png_bytep) trans, 1, NULL);
++ /* Set tRNS chunk values for writing later. */
++ mngg.has_trns = TRUE;
++ mngg.trans = trans;
++ mngg.num_trans = 1;
+
+ /* Transform all pixels with a value = transparent to
+ * 0 and vice versa to compensate for re-ordering in palette
+@@ -489,7 +520,12 @@ respin_cmap (png_structp png_ptr,
+ palette[i].blue = before[3 * remap[i] + 2];
+ }
+
+- png_set_PLTE (png_ptr, png_info_ptr, (png_colorp) palette, colors);
++ /* Set PLTE chunk values for writing later. */
++ mngg.has_plte = TRUE;
++ mngg.palette = palette;
++ mngg.num_palette = colors;
++
++ *bit_depth = get_bit_depth_for_palette (colors);
+
+ return TRUE;
+ }
+@@ -500,7 +536,10 @@ respin_cmap (png_structp png_ptr,
+ }
+ }
+
+- png_set_PLTE (png_ptr, png_info_ptr, (png_colorp) before, colors);
++ mngg.has_plte = TRUE;
++ mngg.palette = (png_colorp) before;
++ mngg.num_palette = colors;
++ *bit_depth = get_bit_depth_for_palette (colors);
+
+ return FALSE;
+ }
+@@ -777,7 +816,6 @@ mng_save_image (const gchar *filename,
+
+ for (i = (num_layers - 1); i >= 0; i--)
+ {
+- gint num_colors;
+ GimpImageType layer_drawable_type;
+ GimpDrawable *layer_drawable;
+ gint layer_offset_x, layer_offset_y;
+@@ -795,8 +833,8 @@ mng_save_image (const gchar *filename,
+ gchar frame_mode;
+ int frame_delay;
+ gchar *temp_file_name;
+- png_structp png_ptr;
+- png_infop png_info_ptr;
++ png_structp pp;
++ png_infop info;
+ FILE *infile, *outfile;
+ int num_passes;
+ int tile_height;
+@@ -804,6 +842,8 @@ mng_save_image (const gchar *filename,
+ int pass, j, k, begin, end, num;
+ guchar *fixed;
+ guchar layer_remap[256];
++ int color_type;
++ int bit_depth;
+
+ layer_name = gimp_drawable_get_name (layers[i]);
+ layer_chunks_type = parse_chunks_type_from_layer_name (layer_name);
+@@ -948,9 +988,9 @@ mng_save_image (const gchar *filename,
+ goto err3;
+ }
+
+- png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING,
++ pp = png_create_write_struct (PNG_LIBPNG_VER_STRING,
+ NULL, NULL, NULL);
+- if (NULL == png_ptr)
++ if (NULL == pp)
+ {
+ g_warning ("Unable to png_create_write_struct() in mng_save_image()");
+ fclose (outfile);
+@@ -958,89 +998,97 @@ mng_save_image (const gchar *filename,
+ goto err3;
+ }
+
+- png_info_ptr = png_create_info_struct (png_ptr);
+- if (NULL == png_info_ptr)
++ info = png_create_info_struct (pp);
++ if (NULL == info)
+ {
+ g_warning
+ ("Unable to png_create_info_struct() in mng_save_image()");
+- png_destroy_write_struct (&png_ptr, NULL);
++ png_destroy_write_struct (&pp, NULL);
+ fclose (outfile);
+ g_unlink (temp_file_name);
+ goto err3;
+ }
+
+- if (setjmp (png_ptr->jmpbuf) != 0)
++ if (setjmp (png_jmpbuf (pp)) != 0)
+ {
+ g_warning ("HRM saving PNG in mng_save_image()");
+- png_destroy_write_struct (&png_ptr, &png_info_ptr);
++ png_destroy_write_struct (&pp, &info);
+ fclose (outfile);
+ g_unlink (temp_file_name);
+ goto err3;
+ }
+
+- png_init_io (png_ptr, outfile);
+- png_set_compression_level (png_ptr, mng_data.compression_level);
++ png_init_io (pp, outfile);
+
+- png_info_ptr->width = layer_cols;
+- png_info_ptr->height = layer_rows;
+- png_info_ptr->interlace_type = (mng_data.interlaced == 0 ? 0 : 1);
+- png_info_ptr->bit_depth = 8;
++ bit_depth = 8;
+
+ switch (layer_drawable_type)
+ {
+ case GIMP_RGB_IMAGE:
+- png_info_ptr->color_type = PNG_COLOR_TYPE_RGB;
++ color_type = PNG_COLOR_TYPE_RGB;
+ break;
+ case GIMP_RGBA_IMAGE:
+- png_info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
++ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ break;
+ case GIMP_GRAY_IMAGE:
+- png_info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
++ color_type = PNG_COLOR_TYPE_GRAY;
+ break;
+ case GIMP_GRAYA_IMAGE:
+- png_info_ptr->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
++ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ break;
+ case GIMP_INDEXED_IMAGE:
+- png_info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
+- png_info_ptr->valid |= PNG_INFO_PLTE;
+- png_info_ptr->palette =
+- (png_colorp) gimp_image_get_colormap (image_id, &num_colors);
+- png_info_ptr->num_palette = num_colors;
++ color_type = PNG_COLOR_TYPE_PALETTE;
++ mngg.has_plte = TRUE;
++ mngg.palette = (png_colorp)
++ gimp_image_get_colormap (image_id, &mngg.num_palette);
++ bit_depth = get_bit_depth_for_palette (mngg.num_palette);
+ break;
+ case GIMP_INDEXEDA_IMAGE:
+- png_info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
++ color_type = PNG_COLOR_TYPE_PALETTE;
+ layer_has_unique_palette =
+- respin_cmap (png_ptr, png_info_ptr, layer_remap,
+- image_id, layer_drawable);
++ respin_cmap (pp, info, layer_remap,
++ image_id, layer_drawable,
++ &bit_depth);
+ break;
+ default:
+ g_warning ("This can't be!\n");
+- png_destroy_write_struct (&png_ptr, &png_info_ptr);
++ png_destroy_write_struct (&pp, &info);
+ fclose (outfile);
+ g_unlink (temp_file_name);
+ goto err3;
+ }
+
+- if ((png_info_ptr->valid & PNG_INFO_PLTE) == PNG_INFO_PLTE)
++ /* Note: png_set_IHDR() must be called before any other
++ png_set_*() functions. */
++ png_set_IHDR (pp, info, layer_cols, layer_rows,
++ bit_depth,
++ color_type,
++ mng_data.interlaced ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE,
++ PNG_COMPRESSION_TYPE_BASE,
++ PNG_FILTER_TYPE_BASE);
++
++ if (mngg.has_trns)
++ {
++ png_set_tRNS (pp, info, mngg.trans, mngg.num_trans, NULL);
++ }
++
++ if (mngg.has_plte)
+ {
+- if (png_info_ptr->num_palette <= 2)
+- png_info_ptr->bit_depth = 1;
+- else if (png_info_ptr->num_palette <= 4)
+- png_info_ptr->bit_depth = 2;
+- else if (png_info_ptr->num_palette <= 16)
+- png_info_ptr->bit_depth = 4;
++ png_set_PLTE (pp, info, mngg.palette, mngg.num_palette);
+ }
+
+- png_write_info (png_ptr, png_info_ptr);
++ png_set_compression_level (pp, mng_data.compression_level);
++
++ png_write_info (pp, info);
+
+ if (mng_data.interlaced != 0)
+- num_passes = png_set_interlace_handling (png_ptr);
++ num_passes = png_set_interlace_handling (pp);
+ else
+ num_passes = 1;
+
+- if ((png_info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) &&
+- (png_info_ptr->bit_depth < 8))
+- png_set_packing (png_ptr);
++ if ((color_type == PNG_COLOR_TYPE_PALETTE) &&
++ (bit_depth < 8))
++ png_set_packing (pp);
+
+ tile_height = gimp_tile_height ();
+ layer_pixel = g_new (guchar, tile_height * layer_cols * layer_bpp);
+@@ -1065,7 +1113,7 @@ mng_save_image (const gchar *filename,
+ gimp_pixel_rgn_get_rect (&layer_pixel_rgn, layer_pixel, 0,
+ begin, layer_cols, num);
+
+- if ((png_info_ptr->valid & PNG_INFO_tRNS) == PNG_INFO_tRNS)
++ if (png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ for (j = 0; j < num; j++)
+ {
+@@ -1077,7 +1125,7 @@ mng_save_image (const gchar *filename,
+ }
+ }
+ else
+- if (((png_info_ptr->valid & PNG_INFO_PLTE) == PNG_INFO_PLTE)
++ if (png_get_valid (pp, info, PNG_INFO_PLTE)
+ && (layer_bpp == 2))
+ {
+ for (j = 0; j < num; j++)
+@@ -1089,12 +1137,12 @@ mng_save_image (const gchar *filename,
+ }
+ }
+
+- png_write_rows (png_ptr, layer_pixels, num);
++ png_write_rows (pp, layer_pixels, num);
+ }
+ }
+
+- png_write_end (png_ptr, png_info_ptr);
+- png_destroy_write_struct (&png_ptr, &png_info_ptr);
++ png_write_end (pp, info);
++ png_destroy_write_struct (&pp, &info);
+
+ g_free (layer_pixels);
+ g_free (layer_pixel);
+diff --git a/plug-ins/common/file-png.c b/plug-ins/common/file-png.c
+index d42afff..8fa8983 100644
+--- a/plug-ins/common/file-png.c
++++ b/plug-ins/common/file-png.c
+@@ -106,6 +106,17 @@ typedef struct
+ }
+ PngSaveGui;
+
++/* These are not saved or restored. */
++typedef struct
++{
++ gboolean has_trns;
++ png_bytep trans;
++ int num_trans;
++ gboolean has_plte;
++ png_colorp palette;
++ int num_palette;
++}
++PngGlobals;
+
+ /*
+ * Local functions...
+@@ -127,7 +138,7 @@ static gboolean save_image (const gchar *filename,
+ gint32 orig_image_ID,
+ GError **error);
+
+-static void respin_cmap (png_structp pp,
++static int respin_cmap (png_structp pp,
+ png_infop info,
+ guchar *remap,
+ gint32 image_ID,
+@@ -175,6 +186,7 @@ static const PngSaveVals defaults =
+ };
+
+ static PngSaveVals pngvals;
++static PngGlobals pngg;
+
+
+ /*
+@@ -653,13 +665,25 @@ on_read_error (png_structp png_ptr, png_const_charp error_msg)
+ error_data->drawable->width, num);
+ }
+
+- longjmp (png_ptr->jmpbuf, 1);
++ longjmp (png_jmpbuf (png_ptr), 1);
++}
++
++static int
++get_bit_depth_for_palette (int num_palette)
++{
++ if (num_palette <= 2)
++ return 1;
++ else if (num_palette <= 4)
++ return 2;
++ else if (num_palette <= 16)
++ return 4;
++ else
++ return 8;
+ }
+
+ /*
+ * 'load_image()' - Load a PNG image into a new image window.
+ */
+-
+ static gint32
+ load_image (const gchar *filename,
+ gboolean interactive,
+@@ -695,9 +719,20 @@ load_image (const gchar *filename,
+ gint num_texts;
+
+ pp = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
++ if (!pp)
++ {
++ /* this could happen if the compile time and run-time libpng
++ versions do not match. */
++
++ g_set_error (error, 0, 0,
++ _("Error creating PNG read struct while saving '%s'."),
++ gimp_filename_to_utf8 (filename));
++ return -1;
++ }
++
+ info = png_create_info_struct (pp);
+
+- if (setjmp (pp->jmpbuf))
++ if (setjmp (png_jmpbuf (pp)))
+ {
+ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+ _("Error while reading '%s'. File corrupted?"),
+@@ -705,10 +740,6 @@ load_image (const gchar *filename,
+ return image;
+ }
+
+- /* initialise image here, thus avoiding compiler warnings */
+-
+- image = -1;
+-
+ /*
+ * Open the file and initialize the PNG read "engine"...
+ */
+@@ -738,17 +769,19 @@ load_image (const gchar *filename,
+ * Latest attempt, this should be my best yet :)
+ */
+
+- if (info->bit_depth == 16)
++ if (png_get_bit_depth (pp, info) == 16)
+ {
+ png_set_strip_16 (pp);
+ }
+
+- if (info->color_type == PNG_COLOR_TYPE_GRAY && info->bit_depth < 8)
++ if (png_get_color_type (pp, info) == PNG_COLOR_TYPE_GRAY &&
++ png_get_bit_depth (pp, info) < 8)
+ {
+ png_set_expand (pp);
+ }
+
+- if (info->color_type == PNG_COLOR_TYPE_PALETTE && info->bit_depth < 8)
++ if (png_get_color_type (pp, info) == PNG_COLOR_TYPE_PALETTE &&
++ png_get_bit_depth (pp, info) < 8)
+ {
+ png_set_packing (pp);
+ }
+@@ -757,8 +790,8 @@ load_image (const gchar *filename,
+ * Expand G+tRNS to GA, RGB+tRNS to RGBA
+ */
+
+- if (info->color_type != PNG_COLOR_TYPE_PALETTE &&
+- (info->valid & PNG_INFO_tRNS))
++ if (png_get_color_type (pp, info) != PNG_COLOR_TYPE_PALETTE &&
++ png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ png_set_expand (pp);
+ }
+@@ -775,7 +808,7 @@ load_image (const gchar *filename,
+ */
+
+ if (png_get_valid (pp, info, PNG_INFO_tRNS) &&
+- info->color_type == PNG_COLOR_TYPE_PALETTE)
++ png_get_color_type (pp, info) == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_get_tRNS (pp, info, &alpha_ptr, &num, NULL);
+ /* Copy the existing alpha values from the tRNS chunk */
+@@ -797,7 +830,7 @@ load_image (const gchar *filename,
+
+ png_read_update_info (pp, info);
+
+- switch (info->color_type)
++ switch (png_get_color_type (pp, info))
+ {
+ case PNG_COLOR_TYPE_RGB: /* RGB */
+ bpp = 3;
+@@ -836,7 +869,9 @@ load_image (const gchar *filename,
+ return -1;
+ }
+
+- image = gimp_image_new (info->width, info->height, image_type);
++ image = gimp_image_new (png_get_image_width (pp, info),
++ png_get_image_height (pp, info),
++ image_type);
+ if (image == -1)
+ {
+ g_set_error (error, 0, 0,
+@@ -849,7 +884,9 @@ load_image (const gchar *filename,
+ * Create the "background" layer to hold the image...
+ */
+
+- layer = gimp_layer_new (image, _("Background"), info->width, info->height,
++ layer = gimp_layer_new (image, _("Background"),
++ png_get_image_width (pp, info),
++ png_get_image_height (pp, info),
+ layer_type, 100, GIMP_NORMAL_MODE);
+ gimp_image_add_layer (image, layer, 0);
+
+@@ -883,7 +920,8 @@ load_image (const gchar *filename,
+
+ gimp_layer_set_offsets (layer, offset_x, offset_y);
+
+- if ((abs (offset_x) > info->width) || (abs (offset_y) > info->height))
++ if ((abs (offset_x) > png_get_image_width (pp, info)) ||
++ (abs (offset_y) > png_get_image_height (pp, info)))
+ {
+ if (interactive)
+ g_message (_("The PNG file specifies an offset that caused "
+@@ -938,23 +976,27 @@ load_image (const gchar *filename,
+
+ empty = 0; /* by default assume no full transparent palette entries */
+
+- if (info->color_type & PNG_COLOR_MASK_PALETTE)
++ if (png_get_color_type (pp, info) & PNG_COLOR_MASK_PALETTE)
+ {
++ png_colorp palette;
++ int num_palette;
++
++ png_get_PLTE (pp, info, &palette, &num_palette);
+ if (png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ for (empty = 0; empty < 256 && alpha[empty] == 0; ++empty)
+ /* Calculates number of fully transparent "empty" entries */;
+
+ /* keep at least one entry */
+- empty = MIN (empty, info->num_palette - 1);
++ empty = MIN (empty, num_palette - 1);
+
+- gimp_image_set_colormap (image, (guchar *) (info->palette + empty),
+- info->num_palette - empty);
++ gimp_image_set_colormap (image, (guchar *) (palette + empty),
++ num_palette - empty);
+ }
+ else
+ {
+- gimp_image_set_colormap (image, (guchar *) info->palette,
+- info->num_palette);
++ gimp_image_set_colormap (image, (guchar *) palette,
++ num_palette);
+ }
+ }
+
+@@ -972,18 +1014,19 @@ load_image (const gchar *filename,
+ */
+
+ tile_height = gimp_tile_height ();
+- pixel = g_new0 (guchar, tile_height * info->width * bpp);
++ pixel = g_new0 (guchar, tile_height * png_get_image_width (pp, info) * bpp);
+ pixels = g_new (guchar *, tile_height);
+
+ for (i = 0; i < tile_height; i++)
+- pixels[i] = pixel + info->width * info->channels * i;
++ pixels[i] = pixel + png_get_image_width (pp, info) *
++ png_get_channels (pp, info) * i;
+
+ /* Install our own error handler to handle incomplete PNG files better */
+ error_data.drawable = drawable;
+ error_data.pixel = pixel;
+ error_data.tile_height = tile_height;
+- error_data.width = info->width;
+- error_data.height = info->height;
++ error_data.width = png_get_image_width (pp, info);
++ error_data.height = png_get_image_height (pp, info);
+ error_data.bpp = bpp;
+ error_data.pixel_rgn = &pixel_rgn;
+
+@@ -996,10 +1039,11 @@ load_image (const gchar *filename,
+ */
+
+ for (begin = 0, end = tile_height;
+- begin < info->height; begin += tile_height, end += tile_height)
++ begin < png_get_image_height (pp, info);
++ begin += tile_height, end += tile_height)
+ {
+- if (end > info->height)
+- end = info->height;
++ if (end > png_get_image_height (pp, info))
++ end = png_get_image_height (pp, info);
+
+ num = end - begin;
+
+@@ -1016,11 +1060,13 @@ load_image (const gchar *filename,
+ gimp_pixel_rgn_set_rect (&pixel_rgn, pixel, 0, begin,
+ drawable->width, num);
+
+- memset (pixel, 0, tile_height * info->width * bpp);
++ memset (pixel, 0,
++ tile_height * png_get_image_width (pp, info) * bpp);
+
+- gimp_progress_update (((gdouble) pass +
+- (gdouble) end / (gdouble) info->height) /
+- (gdouble) num_passes);
++ gimp_progress_update
++ (((gdouble) pass +
++ (gdouble) end / (gdouble) png_get_image_height (pp, info)) /
++ (gdouble) num_passes);
+ }
+ }
+
+@@ -1189,7 +1235,6 @@ save_image (const gchar *filename,
+ GimpPixelRgn pixel_rgn; /* Pixel region for layer */
+ png_structp pp; /* PNG read pointer */
+ png_infop info; /* PNG info pointer */
+- gint num_colors; /* Number of colors in colormap */
+ gint offx, offy; /* Drawable offsets from origin */
+ guchar **pixels, /* Pixel rows */
+ *fixed, /* Fixed-up pixel data */
+@@ -1200,56 +1245,28 @@ save_image (const gchar *filename,
+ guchar red, green, blue; /* Used for palette background */
+ time_t cutime; /* Time since epoch */
+ struct tm *gmt; /* GMT broken down */
++ int color_type;
++ int bit_depth;
+
+ guchar remap[256]; /* Re-mapping for the palette */
+
+ png_textp text = NULL;
+
+- if (pngvals.comment)
++ pp = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
++ if (!pp)
+ {
+- GimpParasite *parasite;
+- gsize text_length = 0;
+-
+- parasite = gimp_image_parasite_find (orig_image_ID, "gimp-comment");
+- if (parasite)
+- {
+- gchar *comment = g_strndup (gimp_parasite_data (parasite),
+- gimp_parasite_data_size (parasite));
++ /* this could happen if the compile time and run-time libpng
++ versions do not match. */
+
+- gimp_parasite_free (parasite);
+-
+- text = g_new0 (png_text, 1);
+- text->key = "Comment";
+-
+-#ifdef PNG_iTXt_SUPPORTED
+-
+- text->compression = PNG_ITXT_COMPRESSION_NONE;
+- text->text = comment;
+- text->itxt_length = strlen (comment);
+-
+-#else
+-
+- text->compression = PNG_TEXT_COMPRESSION_NONE;
+- text->text = g_convert (comment, -1,
+- "ISO-8859-1", "UTF-8",
+- NULL, &text_length,
+- NULL);
+- text->text_length = text_length;
+-
+-#endif
+-
+- if (!text->text)
+- {
+- g_free (text);
+- text = NULL;
+- }
+- }
++ g_set_error (error, 0, 0,
++ _("Error creating PNG write struct while saving '%s'."),
++ gimp_filename_to_utf8 (filename));
++ return FALSE;
+ }
+
+- pp = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ info = png_create_info_struct (pp);
+
+- if (setjmp (pp->jmpbuf))
++ if (setjmp (png_jmpbuf (pp)))
+ {
+ g_set_error (error, 0, 0,
+ _("Error while saving '%s'. Could not save image."),
+@@ -1257,9 +1274,6 @@ save_image (const gchar *filename,
+ return FALSE;
+ }
+
+- if (text)
+- png_set_text (pp, info, text, 1);
+-
+ /*
+ * Open the file and initialize the PNG write "engine"...
+ */
+@@ -1286,17 +1300,6 @@ save_image (const gchar *filename,
+ type = gimp_drawable_type (drawable_ID);
+
+ /*
+- * Set the image dimensions, bit depth, interlacing and compression
+- */
+-
+- png_set_compression_level (pp, pngvals.compression_level);
+-
+- info->width = drawable->width;
+- info->height = drawable->height;
+- info->bit_depth = 8;
+- info->interlace_type = pngvals.interlaced;
+-
+- /*
+ * Initialise remap[]
+ */
+ for (i = 0; i < 256; i++)
+@@ -1306,42 +1309,44 @@ save_image (const gchar *filename,
+ * Set color type and remember bytes per pixel count
+ */
+
++ bit_depth = 8;
++
+ switch (type)
+ {
+ case GIMP_RGB_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_RGB;
++ color_type = PNG_COLOR_TYPE_RGB;
+ bpp = 3;
+ break;
+
+ case GIMP_RGBA_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
++ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ bpp = 4;
+ break;
+
+ case GIMP_GRAY_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_GRAY;
++ color_type = PNG_COLOR_TYPE_GRAY;
+ bpp = 1;
+ break;
+
+ case GIMP_GRAYA_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
++ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ bpp = 2;
+ break;
+
+ case GIMP_INDEXED_IMAGE:
+ bpp = 1;
+- info->color_type = PNG_COLOR_TYPE_PALETTE;
+- info->valid |= PNG_INFO_PLTE;
+- info->palette =
+- (png_colorp) gimp_image_get_colormap (image_ID, &num_colors);
+- info->num_palette = num_colors;
++ color_type = PNG_COLOR_TYPE_PALETTE;
++ pngg.has_plte = TRUE;
++ pngg.palette = (png_colorp) gimp_image_get_colormap (image_ID,
++ &pngg.num_palette);
++ bit_depth = get_bit_depth_for_palette (pngg.num_palette);
+ break;
+
+ case GIMP_INDEXEDA_IMAGE:
+ bpp = 2;
+- info->color_type = PNG_COLOR_TYPE_PALETTE;
++ color_type = PNG_COLOR_TYPE_PALETTE;
+ /* fix up transparency */
+- respin_cmap (pp, info, remap, image_ID, drawable);
++ bit_depth = respin_cmap (pp, info, remap, image_ID, drawable);
+ break;
+
+ default:
+@@ -1349,21 +1354,29 @@ save_image (const gchar *filename,
+ return FALSE;
+ }
+
+- /*
+- * Fix bit depths for (possibly) smaller colormap images
+- */
++ /* Note: png_set_IHDR() must be called before any other png_set_*()
++ functions. */
++ png_set_IHDR (pp, info, drawable->width, drawable->height,
++ bit_depth,
++ color_type,
++ pngvals.interlaced ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE,
++ PNG_COMPRESSION_TYPE_BASE,
++ PNG_FILTER_TYPE_BASE);
++
++ if (pngg.has_trns)
++ {
++ png_set_tRNS (pp, info, pngg.trans, pngg.num_trans, NULL);
++ }
+
+- if (info->valid & PNG_INFO_PLTE)
++ if (pngg.has_plte)
+ {
+- if (info->num_palette <= 2)
+- info->bit_depth = 1;
+- else if (info->num_palette <= 4)
+- info->bit_depth = 2;
+- else if (info->num_palette <= 16)
+- info->bit_depth = 4;
+- /* otherwise the default is fine */
++ png_set_PLTE (pp, info, pngg.palette, pngg.num_palette);
+ }
+
++ /* Set the compression level */
++
++ png_set_compression_level (pp, pngvals.compression_level);
++
+ /* All this stuff is optional extras, if the user is aiming for smallest
+ possible file size she can turn them all off */
+
+@@ -1462,6 +1475,52 @@ save_image (const gchar *filename,
+ }
+ #endif
+
++ if (pngvals.comment)
++ {
++ GimpParasite *parasite;
++#ifndef PNG_iTXt_SUPPORTED
++ gsize text_length = 0;
++#endif /* PNG_iTXt_SUPPORTED */
++
++ parasite = gimp_image_parasite_find (orig_image_ID, "gimp-comment");
++ if (parasite)
++ {
++ gchar *comment = g_strndup (gimp_parasite_data (parasite),
++ gimp_parasite_data_size (parasite));
++
++ gimp_parasite_free (parasite);
++
++ text = g_new0 (png_text, 1);
++ text->key = "Comment";
++
++#ifdef PNG_iTXt_SUPPORTED
++
++ text->compression = PNG_ITXT_COMPRESSION_NONE;
++ text->text = comment;
++ text->itxt_length = strlen (comment);
++
++#else
++
++ text->compression = PNG_TEXT_COMPRESSION_NONE;
++ text->text = g_convert (comment, -1,
++ "ISO-8859-1", "UTF-8",
++ NULL, &text_length,
++ NULL);
++ text->text_length = text_length;
++
++#endif
++
++ if (!text->text)
++ {
++ g_free (text);
++ text = NULL;
++ }
++ }
++ }
++
++ if (text)
++ png_set_text (pp, info, text, 1);
++
+ png_write_info (pp, info);
+
+ /*
+@@ -1477,7 +1536,8 @@ save_image (const gchar *filename,
+ * Convert unpacked pixels to packed if necessary
+ */
+
+- if (info->color_type == PNG_COLOR_TYPE_PALETTE && info->bit_depth < 8)
++ if (color_type == PNG_COLOR_TYPE_PALETTE &&
++ bit_depth < 8)
+ png_set_packing (pp);
+
+ /*
+@@ -1507,7 +1567,9 @@ save_image (const gchar *filename,
+
+ gimp_pixel_rgn_get_rect (&pixel_rgn, pixel, 0, begin,
+ drawable->width, num);
+- /*if we are with a RGBA image and have to pre-multiply the alpha channel */
++
++ /* If we are with a RGBA image and have to pre-multiply the
++ alpha channel */
+ if (bpp == 4 && ! pngvals.save_transp_pixels)
+ {
+ for (i = 0; i < num; ++i)
+@@ -1529,7 +1591,7 @@ save_image (const gchar *filename,
+
+ /* If we're dealing with a paletted image with
+ * transparency set, write out the remapped palette */
+- if (info->valid & PNG_INFO_tRNS)
++ if (png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ guchar inverse_remap[256];
+
+@@ -1547,9 +1609,11 @@ save_image (const gchar *filename,
+ }
+ }
+ }
++
+ /* Otherwise if we have a paletted image and transparency
+ * couldn't be set, we ignore the alpha channel */
+- else if (info->valid & PNG_INFO_PLTE && bpp == 2)
++ else if (png_get_valid (pp, info, PNG_INFO_PLTE) &&
++ bpp == 2)
+ {
+ for (i = 0; i < num; ++i)
+ {
+@@ -1564,7 +1628,7 @@ save_image (const gchar *filename,
+ png_write_rows (pp, pixels, num);
+
+ gimp_progress_update (((double) pass + (double) end /
+- (double) info->height) /
++ (double) drawable->height) /
+ (double) num_passes);
+ }
+ }
+@@ -1694,14 +1758,14 @@ find_unused_ia_color (GimpDrawable *drawable,
+ }
+
+
+-static void
++static int
+ respin_cmap (png_structp pp,
+ png_infop info,
+ guchar *remap,
+ gint32 image_ID,
+ GimpDrawable *drawable)
+ {
+- static const guchar trans[] = { 0 };
++ static guchar trans[] = { 0 };
+
+ gint colors;
+ guchar *before;
+@@ -1728,10 +1792,13 @@ respin_cmap (png_structp pp,
+ * index - do like gif2png and swap
+ * index 0 and index transparent */
+ {
+- png_color palette[256];
++ static png_color palette[256];
+ gint i;
+
+- png_set_tRNS (pp, info, (png_bytep) trans, 1, NULL);
++ /* Set tRNS chunk values for writing later. */
++ pngg.has_trns = TRUE;
++ pngg.trans = trans;
++ pngg.num_trans = 1;
+
+ /* Transform all pixels with a value = transparent to
+ * 0 and vice versa to compensate for re-ordering in palette
+@@ -1752,7 +1819,10 @@ respin_cmap (png_structp pp,
+ palette[i].blue = before[3 * remap[i] + 2];
+ }
+
+- png_set_PLTE (pp, info, palette, colors);
++ /* Set PLTE chunk values for writing later. */
++ pngg.has_plte = TRUE;
++ pngg.palette = palette;
++ pngg.num_palette = colors;
+ }
+ else
+ {
+@@ -1760,14 +1830,22 @@ respin_cmap (png_structp pp,
+ * transparency & just use the full palette */
+ g_message (_("Couldn't losslessly save transparency, "
+ "saving opacity instead."));
+- png_set_PLTE (pp, info, (png_colorp) before, colors);
++
++ /* Set PLTE chunk values for writing later. */
++ pngg.has_plte = TRUE;
++ pngg.palette = (png_colorp) before;
++ pngg.num_palette = colors;
+ }
+ }
+ else
+ {
+- png_set_PLTE (pp, info, (png_colorp) before, colors);
++ /* Set PLTE chunk values for writing later. */
++ pngg.has_plte = TRUE;
++ pngg.palette = (png_colorp) before;
++ pngg.num_palette = colors;
+ }
+
++ return get_bit_depth_for_palette (colors);
+ }
+
+ static gboolean
More information about the arch-commits
mailing list