summaryrefslogtreecommitdiffstats
path: root/plug-ins/common/file-png.c
diff options
context:
space:
mode:
Diffstat (limited to 'plug-ins/common/file-png.c')
-rw-r--r--plug-ins/common/file-png.c2654
1 files changed, 2654 insertions, 0 deletions
diff --git a/plug-ins/common/file-png.c b/plug-ins/common/file-png.c
new file mode 100644
index 0000000..063f201
--- /dev/null
+++ b/plug-ins/common/file-png.c
@@ -0,0 +1,2654 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * Portable Network Graphics (PNG) plug-in
+ *
+ * Copyright 1997-1998 Michael Sweet (mike@easysw.com) and
+ * Daniel Skarda (0rfelyus@atrey.karlin.mff.cuni.cz).
+ * and 1999-2000 Nick Lamb (njl195@zepler.org.uk)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Contents:
+ *
+ * main() - Main entry - just call gimp_main()...
+ * query() - Respond to a plug-in query...
+ * run() - Run the plug-in...
+ * load_image() - Load a PNG image into a new image window.
+ * offsets_dialog() - Asks the user about offsets when loading.
+ * respin_cmap() - Re-order a Gimp colormap for PNG tRNS
+ * save_image() - Export the specified image to a PNG file.
+ * save_compression_callback() - Update the image compression level.
+ * save_interlace_update() - Update the interlacing option.
+ * save_dialog() - Pop up the export dialog.
+ *
+ * Revision History:
+ *
+ * see ChangeLog
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <errno.h>
+
+#include <glib/gstdio.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include <png.h> /* PNG library definitions */
+
+#include "libgimp/stdplugins-intl.h"
+
+
+/*
+ * Constants...
+ */
+
+#define LOAD_PROC "file-png-load"
+#define SAVE_PROC "file-png-save"
+#define SAVE2_PROC "file-png-save2"
+#define SAVE_DEFAULTS_PROC "file-png-save-defaults"
+#define GET_DEFAULTS_PROC "file-png-get-defaults"
+#define SET_DEFAULTS_PROC "file-png-set-defaults"
+#define PLUG_IN_BINARY "file-png"
+#define PLUG_IN_ROLE "gimp-file-png"
+
+#define PLUG_IN_VERSION "1.3.4 - 03 September 2002"
+#define SCALE_WIDTH 125
+
+#define DEFAULT_GAMMA 2.20
+
+#define PNG_DEFAULTS_PARASITE "png-save-defaults"
+
+/*
+ * Structures...
+ */
+
+typedef enum _PngExportformat {
+ PNG_FORMAT_AUTO = 0,
+ PNG_FORMAT_RGB8,
+ PNG_FORMAT_GRAY8,
+ PNG_FORMAT_RGBA8,
+ PNG_FORMAT_GRAYA8,
+ PNG_FORMAT_RGB16,
+ PNG_FORMAT_GRAY16,
+ PNG_FORMAT_RGBA16,
+ PNG_FORMAT_GRAYA16
+} PngExportFormat;
+
+typedef struct
+{
+ gboolean interlaced;
+ gboolean bkgd;
+ gboolean gama;
+ gboolean offs;
+ gboolean phys;
+ gboolean time;
+ gboolean comment;
+ gboolean save_transp_pixels;
+ gint compression_level;
+ gboolean save_exif;
+ gboolean save_xmp;
+ gboolean save_iptc;
+ gboolean save_thumbnail;
+ gboolean save_profile;
+ PngExportFormat export_format;
+}
+PngSaveVals;
+
+typedef struct
+{
+ gboolean run;
+
+ GtkWidget *interlaced;
+ GtkWidget *bkgd;
+ GtkWidget *gama;
+ GtkWidget *offs;
+ GtkWidget *phys;
+ GtkWidget *time;
+ GtkWidget *comment;
+ GtkWidget *pixelformat;
+ GtkWidget *save_transp_pixels;
+ GtkAdjustment *compression_level;
+ GtkWidget *save_exif;
+ GtkWidget *save_xmp;
+ GtkWidget *save_iptc;
+ GtkWidget *save_thumbnail;
+ GtkWidget *save_profile;
+}
+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...
+ */
+
+static void query (void);
+static void run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals);
+
+static gint32 load_image (const gchar *filename,
+ gboolean interactive,
+ gboolean *resolution_loaded,
+ gboolean *profile_loaded,
+ GError **error);
+static gboolean save_image (const gchar *filename,
+ gint32 image_ID,
+ gint32 drawable_ID,
+ gint32 orig_image_ID,
+ GError **error);
+
+static int respin_cmap (png_structp pp,
+ png_infop info,
+ guchar *remap,
+ gint32 image_ID,
+ gint32 drawable_ID);
+
+static gboolean save_dialog (gint32 image_ID,
+ gboolean alpha);
+
+static void save_dialog_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data);
+
+static gboolean offsets_dialog (gint offset_x,
+ gint offset_y);
+
+static gboolean ia_has_transparent_pixels (GeglBuffer *buffer);
+
+static gint find_unused_ia_color (GeglBuffer *buffer,
+ gint *colors);
+
+static void load_parasite (void);
+static void save_parasite (void);
+static void load_gui_defaults (PngSaveGui *pg);
+
+
+/*
+ * Globals...
+ */
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL,
+ NULL,
+ query,
+ run
+};
+
+static const PngSaveVals defaults =
+{
+ FALSE,
+ TRUE,
+ FALSE,
+ FALSE,
+ TRUE,
+ TRUE,
+ TRUE,
+ FALSE,
+ 9,
+ FALSE, /* save exif */
+ FALSE, /* save xmp */
+ FALSE, /* save iptc */
+ TRUE, /* save thumbnail */
+ PNG_FORMAT_AUTO
+};
+
+static PngSaveVals pngvals;
+static PngGlobals pngg;
+
+
+/*
+ * 'main()' - Main entry - just call gimp_main()...
+ */
+
+MAIN ()
+
+
+/*
+ * 'query()' - Respond to a plug-in query...
+ */
+
+static void
+query (void)
+{
+ static const GimpParamDef load_args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+ { GIMP_PDB_STRING, "filename", "The name of the file to load" },
+ { GIMP_PDB_STRING, "raw-filename", "The name of the file to load" }
+ };
+ static const GimpParamDef load_return_vals[] =
+ {
+ { GIMP_PDB_IMAGE, "image", "Output image" }
+ };
+
+#define COMMON_SAVE_ARGS \
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, \
+ { GIMP_PDB_IMAGE, "image", "Input image" }, \
+ { GIMP_PDB_DRAWABLE, "drawable", "Drawable to export" }, \
+ { GIMP_PDB_STRING, "filename", "The name of the file to export the image in"}, \
+ { GIMP_PDB_STRING, "raw-filename", "The name of the file to export the image in"}
+
+#define OLD_CONFIG_ARGS \
+ { GIMP_PDB_INT32, "interlace", "Use Adam7 interlacing?" }, \
+ { GIMP_PDB_INT32, "compression", "Deflate Compression factor (0--9)" }, \
+ { GIMP_PDB_INT32, "bkgd", "Write bKGD chunk?" }, \
+ { GIMP_PDB_INT32, "gama", "Write gAMA chunk?" }, \
+ { GIMP_PDB_INT32, "offs", "Write oFFs chunk?" }, \
+ { GIMP_PDB_INT32, "phys", "Write pHYs chunk?" }, \
+ { GIMP_PDB_INT32, "time", "Write tIME chunk?" }
+
+#define FULL_CONFIG_ARGS \
+ OLD_CONFIG_ARGS, \
+ { GIMP_PDB_INT32, "comment", "Write comment?" }, \
+ { GIMP_PDB_INT32, "svtrans", "Preserve color of transparent pixels?" }
+
+ static const GimpParamDef save_args[] =
+ {
+ COMMON_SAVE_ARGS,
+ OLD_CONFIG_ARGS
+ };
+
+ static const GimpParamDef save_args2[] =
+ {
+ COMMON_SAVE_ARGS,
+ FULL_CONFIG_ARGS
+ };
+
+ static const GimpParamDef save_args_defaults[] =
+ {
+ COMMON_SAVE_ARGS
+ };
+
+ static const GimpParamDef save_get_defaults_return_vals[] =
+ {
+ FULL_CONFIG_ARGS
+ };
+
+ static const GimpParamDef save_args_set_defaults[] =
+ {
+ FULL_CONFIG_ARGS
+ };
+
+ gimp_install_procedure (LOAD_PROC,
+ "Loads files in PNG file format",
+ "This plug-in loads Portable Network Graphics "
+ "(PNG) files.",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, "
+ "Nick Lamb <njl195@zepler.org.uk>",
+ PLUG_IN_VERSION,
+ N_("PNG image"),
+ NULL,
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (load_args),
+ G_N_ELEMENTS (load_return_vals),
+ load_args, load_return_vals);
+
+ gimp_register_file_handler_mime (LOAD_PROC, "image/png");
+ gimp_register_magic_load_handler (LOAD_PROC,
+ "png", "", "0,string,\211PNG\r\n\032\n");
+
+ gimp_install_procedure (SAVE_PROC,
+ "Exports files in PNG file format",
+ "This plug-in exports Portable Network Graphics "
+ "(PNG) files.",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, "
+ "Nick Lamb <njl195@zepler.org.uk>",
+ PLUG_IN_VERSION,
+ N_("PNG image"),
+ "RGB*,GRAY*,INDEXED*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args), 0,
+ save_args, NULL);
+
+ gimp_install_procedure (SAVE2_PROC,
+ "Exports files in PNG file format",
+ "This plug-in exports Portable Network Graphics "
+ "(PNG) files. "
+ "This procedure adds 2 extra parameters to "
+ "file-png-save that control whether "
+ "image comments are saved and whether transparent "
+ "pixels are saved or nullified.",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, "
+ "Nick Lamb <njl195@zepler.org.uk>",
+ PLUG_IN_VERSION,
+ N_("PNG image"),
+ "RGB*,GRAY*,INDEXED*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args2), 0,
+ save_args2, NULL);
+
+ gimp_install_procedure (SAVE_DEFAULTS_PROC,
+ "Exports files in PNG file format",
+ "This plug-in exports Portable Network Graphics (PNG) "
+ "files, using the default settings stored as "
+ "a parasite.",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, "
+ "Nick Lamb <njl195@zepler.org.uk>",
+ PLUG_IN_VERSION,
+ N_("PNG image"),
+ "RGB*,GRAY*,INDEXED*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args_defaults), 0,
+ save_args_defaults, NULL);
+
+ gimp_register_file_handler_mime (SAVE_DEFAULTS_PROC, "image/png");
+ gimp_register_save_handler (SAVE_DEFAULTS_PROC, "png", "");
+
+ gimp_install_procedure (GET_DEFAULTS_PROC,
+ "Get the current set of defaults used by the "
+ "PNG file export plug-in",
+ "This procedure returns the current set of "
+ "defaults stored as a parasite for the PNG "
+ "export plug-in. "
+ "These defaults are used to seed the UI, by the "
+ "file_png_save_defaults procedure, and by "
+ "gimp_file_save when it detects to use PNG.",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, "
+ "Nick Lamb <njl195@zepler.org.uk>",
+ PLUG_IN_VERSION,
+ NULL,
+ NULL,
+ GIMP_PLUGIN,
+ 0, G_N_ELEMENTS (save_get_defaults_return_vals),
+ NULL, save_get_defaults_return_vals);
+
+ gimp_install_procedure (SET_DEFAULTS_PROC,
+ "Set the current set of defaults used by the "
+ "PNG file export plug-in",
+ "This procedure set the current set of defaults "
+ "stored as a parasite for the PNG export plug-in. "
+ "These defaults are used to seed the UI, by the "
+ "file_png_save_defaults procedure, and by "
+ "gimp_file_save when it detects to use PNG.",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>",
+ "Michael Sweet <mike@easysw.com>, "
+ "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, "
+ "Nick Lamb <njl195@zepler.org.uk>",
+ PLUG_IN_VERSION,
+ NULL,
+ NULL,
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args_set_defaults), 0,
+ save_args_set_defaults, NULL);
+}
+
+
+/*
+ * 'run()' - Run the plug-in...
+ */
+
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
+{
+ static GimpParam values[10];
+ GimpRunMode run_mode = GIMP_RUN_NONINTERACTIVE;
+ GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+ gint32 image_ID;
+ gint32 drawable_ID;
+ GError *error = NULL;
+
+ if (nparams)
+ run_mode = param[0].data.d_int32;
+
+ INIT_I18N ();
+ gegl_init (NULL, NULL);
+
+ *nreturn_vals = 1;
+ *return_vals = values;
+
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+
+ if (strcmp (name, LOAD_PROC) == 0)
+ {
+ gboolean interactive;
+ gboolean resolution_loaded = FALSE;
+ gboolean profile_loaded = FALSE;
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ case GIMP_RUN_WITH_LAST_VALS:
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+ interactive = TRUE;
+ break;
+ default:
+ interactive = FALSE;
+ break;
+ }
+
+ image_ID = load_image (param[1].data.d_string,
+ interactive,
+ &resolution_loaded,
+ &profile_loaded,
+ &error);
+
+ if (image_ID != -1)
+ {
+ GFile *file = g_file_new_for_path (param[1].data.d_string);
+ GimpMetadata *metadata;
+
+ metadata = gimp_image_metadata_load_prepare (image_ID, "image/png",
+ file, NULL);
+
+ if (metadata)
+ {
+ GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL;
+
+ if (resolution_loaded)
+ flags &= ~GIMP_METADATA_LOAD_RESOLUTION;
+
+ if (profile_loaded)
+ flags &= ~GIMP_METADATA_LOAD_COLORSPACE;
+
+ gimp_image_metadata_load_finish (image_ID, "image/png",
+ metadata, flags,
+ interactive);
+
+ g_object_unref (metadata);
+ }
+
+ g_object_unref (file);
+
+ *nreturn_vals = 2;
+ values[1].type = GIMP_PDB_IMAGE;
+ values[1].data.d_image = image_ID;
+ }
+ else
+ {
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+ }
+ else if (strcmp (name, SAVE_PROC) == 0 ||
+ strcmp (name, SAVE2_PROC) == 0 ||
+ strcmp (name, SAVE_DEFAULTS_PROC) == 0)
+ {
+ GimpMetadata *metadata;
+ GimpMetadataSaveFlags metadata_flags;
+ gint32 orig_image_ID;
+ GimpExportReturn export = GIMP_EXPORT_CANCEL;
+ gboolean alpha;
+
+ image_ID = param[1].data.d_int32;
+ drawable_ID = param[2].data.d_int32;
+
+ orig_image_ID = image_ID;
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ case GIMP_RUN_WITH_LAST_VALS:
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+ export = gimp_export_image (&image_ID, &drawable_ID, "PNG",
+ GIMP_EXPORT_CAN_HANDLE_RGB |
+ GIMP_EXPORT_CAN_HANDLE_GRAY |
+ GIMP_EXPORT_CAN_HANDLE_INDEXED |
+ GIMP_EXPORT_CAN_HANDLE_ALPHA);
+
+ if (export == GIMP_EXPORT_CANCEL)
+ {
+ *nreturn_vals = 1;
+ values[0].data.d_status = GIMP_PDB_CANCEL;
+ return;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ /* Initialize with hardcoded defaults */
+ pngvals = defaults;
+
+ /* Override the defaults with preferences. */
+ metadata = gimp_image_metadata_save_prepare (orig_image_ID,
+ "image/png",
+ &metadata_flags);
+ pngvals.save_exif = (metadata_flags & GIMP_METADATA_SAVE_EXIF) != 0;
+ pngvals.save_xmp = (metadata_flags & GIMP_METADATA_SAVE_XMP) != 0;
+ pngvals.save_iptc = (metadata_flags & GIMP_METADATA_SAVE_IPTC) != 0;
+ pngvals.save_thumbnail = (metadata_flags & GIMP_METADATA_SAVE_THUMBNAIL) != 0;
+ pngvals.save_profile = (metadata_flags & GIMP_METADATA_SAVE_COLOR_PROFILE) != 0;
+
+ /* Override preferences from PNG export defaults (if saved). */
+ load_parasite ();
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ /* Finally possibly retrieve data from previous run. */
+ gimp_get_data (SAVE_PROC, &pngvals);
+
+ alpha = gimp_drawable_has_alpha (drawable_ID);
+
+ /* If the image has no transparency, then there is usually
+ * no need to save a bKGD chunk. For more information, see:
+ * http://bugzilla.gnome.org/show_bug.cgi?id=92395
+ */
+ if (! alpha)
+ pngvals.bkgd = FALSE;
+
+ /* Then acquire information with a dialog...
+ */
+ if (! save_dialog (orig_image_ID, alpha))
+ status = GIMP_PDB_CANCEL;
+ break;
+
+ case GIMP_RUN_NONINTERACTIVE:
+ /*
+ * Make sure all the arguments are there!
+ */
+ if (nparams != 5)
+ {
+ if (nparams != 12 && nparams != 14)
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ else
+ {
+ pngvals.interlaced = param[5].data.d_int32;
+ pngvals.compression_level = param[6].data.d_int32;
+ pngvals.bkgd = param[7].data.d_int32;
+ pngvals.gama = param[8].data.d_int32;
+ pngvals.offs = param[9].data.d_int32;
+ pngvals.phys = param[10].data.d_int32;
+ pngvals.time = param[11].data.d_int32;
+
+ if (nparams == 14)
+ {
+ pngvals.comment = param[12].data.d_int32;
+ pngvals.save_transp_pixels = param[13].data.d_int32;
+ }
+ else
+ {
+ pngvals.comment = TRUE;
+ pngvals.save_transp_pixels = TRUE;
+ }
+
+ if (pngvals.compression_level < 0 ||
+ pngvals.compression_level > 9)
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ }
+ }
+ break;
+
+ case GIMP_RUN_WITH_LAST_VALS:
+ /* possibly retrieve data */
+ gimp_get_data (SAVE_PROC, &pngvals);
+ break;
+
+ default:
+ break;
+ }
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ if (save_image (param[3].data.d_string,
+ image_ID, drawable_ID, orig_image_ID, &error))
+ {
+ if (metadata)
+ {
+ GFile *file;
+
+ gimp_metadata_set_bits_per_sample (metadata, 8);
+
+ if (pngvals.save_exif)
+ metadata_flags |= GIMP_METADATA_SAVE_EXIF;
+ else
+ metadata_flags &= ~GIMP_METADATA_SAVE_EXIF;
+
+ if (pngvals.save_xmp)
+ metadata_flags |= GIMP_METADATA_SAVE_XMP;
+ else
+ metadata_flags &= ~GIMP_METADATA_SAVE_XMP;
+
+ if (pngvals.save_iptc)
+ metadata_flags |= GIMP_METADATA_SAVE_IPTC;
+ else
+ metadata_flags &= ~GIMP_METADATA_SAVE_IPTC;
+
+ if (pngvals.save_thumbnail)
+ metadata_flags |= GIMP_METADATA_SAVE_THUMBNAIL;
+ else
+ metadata_flags &= ~GIMP_METADATA_SAVE_THUMBNAIL;
+
+ if (pngvals.save_profile)
+ metadata_flags |= GIMP_METADATA_SAVE_COLOR_PROFILE;
+ else
+ metadata_flags &= ~GIMP_METADATA_SAVE_COLOR_PROFILE;
+
+ file = g_file_new_for_path (param[3].data.d_string);
+ gimp_image_metadata_save_finish (orig_image_ID,
+ "image/png",
+ metadata, metadata_flags,
+ file, NULL);
+ g_object_unref (file);
+ }
+
+ gimp_set_data (SAVE_PROC, &pngvals, sizeof (pngvals));
+ }
+ else
+ {
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+ }
+
+ if (export == GIMP_EXPORT_EXPORT)
+ gimp_image_delete (image_ID);
+
+ if (metadata)
+ g_object_unref (metadata);
+ }
+ else if (strcmp (name, GET_DEFAULTS_PROC) == 0)
+ {
+ pngvals = defaults;
+ load_parasite ();
+
+ *nreturn_vals = 10;
+
+#define SET_VALUE(index, field) G_STMT_START { \
+ values[(index)].type = GIMP_PDB_INT32; \
+ values[(index)].data.d_int32 = pngvals.field; \
+} G_STMT_END
+
+ SET_VALUE (1, interlaced);
+ SET_VALUE (2, compression_level);
+ SET_VALUE (3, bkgd);
+ SET_VALUE (4, gama);
+ SET_VALUE (5, offs);
+ SET_VALUE (6, phys);
+ SET_VALUE (7, time);
+ SET_VALUE (8, comment);
+ SET_VALUE (9, save_transp_pixels);
+
+#undef SET_VALUE
+ }
+ else if (strcmp (name, SET_DEFAULTS_PROC) == 0)
+ {
+ if (nparams == 9)
+ {
+ pngvals = defaults;
+ load_parasite ();
+
+ pngvals.interlaced = param[0].data.d_int32;
+ pngvals.compression_level = param[1].data.d_int32;
+ pngvals.bkgd = param[2].data.d_int32;
+ pngvals.gama = param[3].data.d_int32;
+ pngvals.offs = param[4].data.d_int32;
+ pngvals.phys = param[5].data.d_int32;
+ pngvals.time = param[6].data.d_int32;
+ pngvals.comment = param[7].data.d_int32;
+ pngvals.save_transp_pixels = param[8].data.d_int32;
+
+ save_parasite ();
+ }
+ else
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ }
+ else
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+
+ if (status != GIMP_PDB_SUCCESS && error)
+ {
+ *nreturn_vals = 2;
+ values[1].type = GIMP_PDB_STRING;
+ values[1].data.d_string = error->message;
+ }
+
+ values[0].data.d_status = status;
+}
+
+
+struct read_error_data
+{
+ guchar *pixel; /* Pixel data */
+ GeglBuffer *buffer; /* GEGL buffer for layer */
+ const Babl *file_format;
+ guint32 width; /* png_infop->width */
+ guint32 height; /* png_infop->height */
+ gint bpp; /* Bytes per pixel */
+ gint tile_height; /* Height of tile in GIMP */
+ gint begin; /* Beginning tile row */
+ gint end; /* Ending tile row */
+ gint num; /* Number of rows to load */
+};
+
+static void
+on_read_error (png_structp png_ptr,
+ png_const_charp error_msg)
+{
+ struct read_error_data *error_data = png_get_error_ptr (png_ptr);
+ gint begin;
+ gint end;
+ gint num;
+
+ g_printerr (_("Error loading PNG file: %s\n"), error_msg);
+
+ /* Flush the current half-read row of tiles */
+
+ gegl_buffer_set (error_data->buffer,
+ GEGL_RECTANGLE (0, error_data->begin,
+ error_data->width,
+ error_data->num),
+ 0,
+ error_data->file_format,
+ error_data->pixel,
+ GEGL_AUTO_ROWSTRIDE);
+
+ begin = error_data->begin + error_data->tile_height;
+
+ if (begin < error_data->height)
+ {
+ end = MIN (error_data->end + error_data->tile_height, error_data->height);
+ num = end - begin;
+
+ gegl_buffer_clear (error_data->buffer,
+ GEGL_RECTANGLE (0, begin, error_data->width, num));
+ }
+
+ g_object_unref (error_data->buffer);
+ 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;
+}
+
+static GimpColorProfile *
+load_color_profile (png_structp pp,
+ png_infop info,
+ gchar **profile_name)
+{
+ GimpColorProfile *profile = NULL;
+
+#if defined(PNG_iCCP_SUPPORTED)
+ png_uint_32 proflen;
+ png_charp profname;
+ png_bytep prof;
+ int profcomp;
+
+ if (png_get_iCCP (pp, info, &profname, &profcomp, &prof, &proflen))
+ {
+ profile = gimp_color_profile_new_from_icc_profile ((guint8 *) prof,
+ proflen, NULL);
+ if (profile && profname)
+ {
+ *profile_name = g_convert (profname, strlen (profname),
+ "ISO-8859-1", "UTF-8", NULL, NULL, NULL);
+ }
+ }
+#endif
+
+ return profile;
+}
+
+/*
+ * 'load_image()' - Load a PNG image into a new image window.
+ */
+static gint32
+load_image (const gchar *filename,
+ gboolean interactive,
+ gboolean *resolution_loaded,
+ gboolean *profile_loaded,
+ GError **error)
+{
+ gint i; /* Looping var */
+ gint trns; /* Transparency present */
+ gint bpp; /* Bytes per pixel */
+ gint width; /* image width */
+ gint height; /* image height */
+ gint num_passes; /* Number of interlace passes in file */
+ gint pass; /* Current pass in file */
+ gint tile_height; /* Height of tile in GIMP */
+ gint begin; /* Beginning tile row */
+ gint end; /* Ending tile row */
+ gint num; /* Number of rows to load */
+ GimpImageBaseType image_type; /* Type of image */
+ GimpPrecision image_precision; /* Precision of image */
+ GimpImageType layer_type; /* Type of drawable/layer */
+ GimpColorProfile *profile = NULL; /* Color profile */
+ gchar *profile_name = NULL; /* Profile's name */
+ gboolean linear = FALSE; /* Linear RGB */
+ FILE *fp; /* File pointer */
+ volatile gint32 image = -1; /* Image -- protected for setjmp() */
+ gint32 layer; /* Layer */
+ GeglBuffer *buffer; /* GEGL buffer for layer */
+ const Babl *file_format; /* BABL format for layer */
+ png_structp pp; /* PNG read pointer */
+ png_infop info; /* PNG info pointers */
+ guchar **pixels; /* Pixel rows */
+ guchar *pixel; /* Pixel data */
+ guchar alpha[256]; /* Index -> Alpha */
+ png_textp text;
+ gint num_texts;
+ struct read_error_data error_data;
+
+ 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 loading '%s'."),
+ gimp_filename_to_utf8 (filename));
+ return -1;
+ }
+
+ info = png_create_info_struct (pp);
+ if (! info)
+ {
+ g_set_error (error, 0, 0,
+ _("Error while reading '%s'. Could not create PNG header info structure."),
+ gimp_filename_to_utf8 (filename));
+ return -1;
+ }
+
+ if (setjmp (png_jmpbuf (pp)))
+ {
+ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+ _("Error while reading '%s'. File corrupted?"),
+ gimp_filename_to_utf8 (filename));
+ return image;
+ }
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+ /* Change some libpng errors to warnings (e.g. bug 721135) */
+ png_set_benign_errors (pp, TRUE);
+
+ /* bug 765850 */
+ png_set_option (pp, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
+#endif
+
+ /*
+ * Open the file and initialize the PNG read "engine"...
+ */
+
+ gimp_progress_init_printf (_("Opening '%s'"),
+ gimp_filename_to_utf8 (filename));
+
+ fp = g_fopen (filename, "rb");
+
+ if (fp == NULL)
+ {
+ g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+ _("Could not open '%s' for reading: %s"),
+ gimp_filename_to_utf8 (filename), g_strerror (errno));
+ return -1;
+ }
+
+ png_init_io (pp, fp);
+ png_set_compression_buffer_size (pp, 512);
+
+ /*
+ * Get the image info
+ */
+
+ png_read_info (pp, info);
+
+ if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
+ png_set_swap (pp);
+
+ /*
+ * Get the iCCP (color profile) chunk, if any, and figure if it's
+ * a linear RGB profile
+ */
+ profile = load_color_profile (pp, info, &profile_name);
+
+ if (profile)
+ {
+ *profile_loaded = TRUE;
+
+ linear = gimp_color_profile_is_linear (profile);
+ }
+
+ /*
+ * Get image precision and color model
+ */
+
+ if (png_get_bit_depth (pp, info) == 16)
+ {
+ if (linear)
+ image_precision = GIMP_PRECISION_U16_LINEAR;
+ else
+ image_precision = GIMP_PRECISION_U16_GAMMA;
+ }
+ else
+ {
+ if (linear)
+ image_precision = GIMP_PRECISION_U8_LINEAR;
+ else
+ image_precision = GIMP_PRECISION_U8_GAMMA;
+ }
+
+ if (png_get_bit_depth (pp, info) < 8)
+ {
+ if (png_get_color_type (pp, info) == PNG_COLOR_TYPE_GRAY)
+ png_set_expand (pp);
+
+ if (png_get_color_type (pp, info) == PNG_COLOR_TYPE_PALETTE)
+ png_set_packing (pp);
+ }
+
+ /*
+ * Expand G+tRNS to GA, RGB+tRNS to RGBA
+ */
+
+ if (png_get_color_type (pp, info) != PNG_COLOR_TYPE_PALETTE &&
+ png_get_valid (pp, info, PNG_INFO_tRNS))
+ png_set_expand (pp);
+
+ /*
+ * Turn on interlace handling... libpng returns just 1 (ie single pass)
+ * if the image is not interlaced
+ */
+
+ num_passes = png_set_interlace_handling (pp);
+
+ /*
+ * Special handling for INDEXED + tRNS (transparency palette)
+ */
+
+ if (png_get_valid (pp, info, PNG_INFO_tRNS) &&
+ png_get_color_type (pp, info) == PNG_COLOR_TYPE_PALETTE)
+ {
+ guchar *alpha_ptr;
+
+ png_get_tRNS (pp, info, &alpha_ptr, &num, NULL);
+
+ /* Copy the existing alpha values from the tRNS chunk */
+ for (i = 0; i < num; ++i)
+ alpha[i] = alpha_ptr[i];
+
+ /* And set any others to fully opaque (255) */
+ for (i = num; i < 256; ++i)
+ alpha[i] = 255;
+
+ trns = 1;
+ }
+ else
+ {
+ trns = 0;
+ }
+
+ /*
+ * Update the info structures after the transformations take effect
+ */
+
+ png_read_update_info (pp, info);
+
+ switch (png_get_color_type (pp, info))
+ {
+ case PNG_COLOR_TYPE_RGB:
+ image_type = GIMP_RGB;
+ layer_type = GIMP_RGB_IMAGE;
+ break;
+
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ image_type = GIMP_RGB;
+ layer_type = GIMP_RGBA_IMAGE;
+ break;
+
+ case PNG_COLOR_TYPE_GRAY:
+ image_type = GIMP_GRAY;
+ layer_type = GIMP_GRAY_IMAGE;
+ break;
+
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ image_type = GIMP_GRAY;
+ layer_type = GIMP_GRAYA_IMAGE;
+ break;
+
+ case PNG_COLOR_TYPE_PALETTE:
+ image_type = GIMP_INDEXED;
+ layer_type = GIMP_INDEXED_IMAGE;
+ break;
+
+ default:
+ g_set_error (error, 0, 0,
+ _("Unknown color model in PNG file '%s'."),
+ gimp_filename_to_utf8 (filename));
+ return -1;
+ }
+
+ width = png_get_image_width (pp, info);
+ height = png_get_image_height (pp, info);
+
+ image = gimp_image_new_with_precision (width, height,
+ image_type, image_precision);
+ if (image == -1)
+ {
+ g_set_error (error, 0, 0,
+ _("Could not create new image for '%s': %s"),
+ gimp_filename_to_utf8 (filename), gimp_get_pdb_error ());
+ return -1;
+ }
+
+ /*
+ * Create the "background" layer to hold the image...
+ */
+
+ layer = gimp_layer_new (image, _("Background"), width, height,
+ layer_type,
+ 100,
+ gimp_image_get_default_new_layer_mode (image));
+ gimp_image_insert_layer (image, layer, -1, 0);
+
+ file_format = gimp_drawable_get_format (layer);
+
+ /*
+ * Find out everything we can about the image resolution
+ * This is only practical with the new 1.0 APIs, I'm afraid
+ * due to a bug in libpng-1.0.6, see png-implement for details
+ */
+
+ if (png_get_valid (pp, info, PNG_INFO_gAMA))
+ {
+ GimpParasite *parasite;
+ gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
+ gdouble gamma;
+
+ png_get_gAMA (pp, info, &gamma);
+
+ g_ascii_dtostr (buf, sizeof (buf), gamma);
+
+ parasite = gimp_parasite_new ("gamma",
+ GIMP_PARASITE_PERSISTENT,
+ strlen (buf) + 1, buf);
+ gimp_image_attach_parasite (image, parasite);
+ gimp_parasite_free (parasite);
+ }
+
+ if (png_get_valid (pp, info, PNG_INFO_oFFs))
+ {
+ gint offset_x = png_get_x_offset_pixels (pp, info);
+ gint offset_y = png_get_y_offset_pixels (pp, info);
+
+ if (offset_x != 0 ||
+ offset_y != 0)
+ {
+ if (! interactive)
+ {
+ gimp_layer_set_offsets (layer, offset_x, offset_y);
+ }
+ else if (offsets_dialog (offset_x, offset_y))
+ {
+ gimp_layer_set_offsets (layer, offset_x, offset_y);
+
+ if (abs (offset_x) > width ||
+ abs (offset_y) > height)
+ {
+ g_message (_("The PNG file specifies an offset that caused "
+ "the layer to be positioned outside the image."));
+ }
+ }
+ }
+ }
+
+ if (png_get_valid (pp, info, PNG_INFO_pHYs))
+ {
+ png_uint_32 xres;
+ png_uint_32 yres;
+ gint unit_type;
+
+ if (png_get_pHYs (pp, info,
+ &xres, &yres, &unit_type) && xres > 0 && yres > 0)
+ {
+ switch (unit_type)
+ {
+ case PNG_RESOLUTION_UNKNOWN:
+ {
+ gdouble image_xres, image_yres;
+
+ gimp_image_get_resolution (image, &image_xres, &image_yres);
+
+ if (xres > yres)
+ image_xres = image_yres * (gdouble) xres / (gdouble) yres;
+ else
+ image_yres = image_xres * (gdouble) yres / (gdouble) xres;
+
+ gimp_image_set_resolution (image, image_xres, image_yres);
+
+ *resolution_loaded = TRUE;
+ }
+ break;
+
+ case PNG_RESOLUTION_METER:
+ gimp_image_set_resolution (image,
+ (gdouble) xres * 0.0254,
+ (gdouble) yres * 0.0254);
+ gimp_image_set_unit (image, GIMP_UNIT_MM);
+
+ *resolution_loaded = TRUE;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ }
+
+ gimp_image_set_filename (image, filename);
+
+ /*
+ * Load the colormap as necessary...
+ */
+
+ 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);
+ gimp_image_set_colormap (image, (guchar *) palette,
+ num_palette);
+ }
+
+ bpp = babl_format_get_bytes_per_pixel (file_format);
+
+ buffer = gimp_drawable_get_buffer (layer);
+
+ /*
+ * Temporary buffer...
+ */
+
+ tile_height = gimp_tile_height ();
+ pixel = g_new0 (guchar, tile_height * width * bpp);
+ pixels = g_new (guchar *, tile_height);
+
+ for (i = 0; i < tile_height; i++)
+ pixels[i] = pixel + width * bpp * i;
+
+ /* Install our own error handler to handle incomplete PNG files better */
+ error_data.buffer = buffer;
+ error_data.pixel = pixel;
+ error_data.file_format = file_format;
+ error_data.tile_height = tile_height;
+ error_data.width = width;
+ error_data.height = height;
+ error_data.bpp = bpp;
+
+ png_set_error_fn (pp, &error_data, on_read_error, NULL);
+
+ for (pass = 0; pass < num_passes; pass++)
+ {
+ /*
+ * This works if you are only reading one row at a time...
+ */
+
+ for (begin = 0; begin < height; begin += tile_height)
+ {
+ end = MIN (begin + tile_height, height);
+ num = end - begin;
+
+ if (pass != 0) /* to handle interlaced PiNGs */
+ gegl_buffer_get (buffer,
+ GEGL_RECTANGLE (0, begin, width, num),
+ 1.0,
+ file_format,
+ pixel,
+ GEGL_AUTO_ROWSTRIDE,
+ GEGL_ABYSS_NONE);
+
+ error_data.begin = begin;
+ error_data.end = end;
+ error_data.num = num;
+
+ png_read_rows (pp, pixels, NULL, num);
+
+ gegl_buffer_set (buffer,
+ GEGL_RECTANGLE (0, begin, width, num),
+ 0,
+ file_format,
+ pixel,
+ GEGL_AUTO_ROWSTRIDE);
+
+ gimp_progress_update
+ (((gdouble) pass +
+ (gdouble) end / (gdouble) height) /
+ (gdouble) num_passes);
+ }
+ }
+
+ png_read_end (pp, info);
+
+ /* Switch back to default error handler */
+ png_set_error_fn (pp, NULL, NULL, NULL);
+
+ if (png_get_text (pp, info, &text, &num_texts))
+ {
+ gchar *comment = NULL;
+
+ for (i = 0; i < num_texts && !comment; i++, text++)
+ {
+ if (text->key == NULL || strcmp (text->key, "Comment"))
+ continue;
+
+ if (text->text_length > 0) /* tEXt */
+ {
+ comment = g_convert (text->text, -1,
+ "UTF-8", "ISO-8859-1",
+ NULL, NULL, NULL);
+ }
+ else if (g_utf8_validate (text->text, -1, NULL))
+ { /* iTXt */
+ comment = g_strdup (text->text);
+ }
+ }
+
+ if (comment && *comment)
+ {
+ GimpParasite *parasite;
+
+ parasite = gimp_parasite_new ("gimp-comment",
+ GIMP_PARASITE_PERSISTENT,
+ strlen (comment) + 1, comment);
+ gimp_image_attach_parasite (image, parasite);
+ gimp_parasite_free (parasite);
+ }
+
+ g_free (comment);
+ }
+
+ /*
+ * Attach the color profile, if any
+ */
+
+ if (profile)
+ {
+ gimp_image_set_color_profile (image, profile);
+ g_object_unref (profile);
+
+ if (profile_name)
+ {
+ GimpParasite *parasite;
+
+ parasite = gimp_parasite_new ("icc-profile-name",
+ GIMP_PARASITE_PERSISTENT |
+ GIMP_PARASITE_UNDOABLE,
+ strlen (profile_name),
+ profile_name);
+ gimp_image_attach_parasite (image, parasite);
+ gimp_parasite_free (parasite);
+
+ g_free (profile_name);
+ }
+ }
+
+ /*
+ * Done with the file...
+ */
+
+ png_destroy_read_struct (&pp, &info, NULL);
+
+ g_free (pixel);
+ g_free (pixels);
+ g_object_unref (buffer);
+ free (pp);
+ free (info);
+
+ fclose (fp);
+
+ if (trns)
+ {
+ GeglBufferIterator *iter;
+ gint n_components;
+
+ gimp_layer_add_alpha (layer);
+ buffer = gimp_drawable_get_buffer (layer);
+ file_format = gegl_buffer_get_format (buffer);
+
+ iter = gegl_buffer_iterator_new (buffer, NULL, 0, file_format,
+ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1);
+ n_components = babl_format_get_n_components (file_format);
+ g_warn_if_fail (n_components == 2);
+
+ while (gegl_buffer_iterator_next (iter))
+ {
+ guchar *data = iter->items[0].data;
+ gint length = iter->length;
+
+ while (length--)
+ {
+ data[1] = alpha[data[0]];
+
+ data += n_components;
+ }
+ }
+
+ g_object_unref (buffer);
+ }
+
+ return image;
+}
+
+/*
+ * 'offsets_dialog ()' - Asks the user about offsets when loading.
+ */
+static gboolean
+offsets_dialog (gint offset_x,
+ gint offset_y)
+{
+ GtkWidget *dialog;
+ GtkWidget *hbox;
+ GtkWidget *image;
+ GtkWidget *label;
+ gchar *message;
+ gboolean run;
+
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+ dialog = gimp_dialog_new (_("Apply PNG Offset"), PLUG_IN_ROLE,
+ NULL, 0,
+ gimp_standard_help_func, LOAD_PROC,
+
+ _("Ignore PNG offset"), GTK_RESPONSE_NO,
+ _("Apply PNG offset to layer"), GTK_RESPONSE_YES,
+
+ NULL);
+
+ gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_YES,
+ GTK_RESPONSE_NO,
+ -1);
+
+ gimp_window_set_transient (GTK_WINDOW (dialog));
+ gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ image = gtk_image_new_from_icon_name (GIMP_ICON_DIALOG_QUESTION,
+ GTK_ICON_SIZE_DIALOG);
+ gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
+ gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
+ gtk_widget_show (image);
+
+ message = g_strdup_printf (_("The PNG image you are importing specifies an "
+ "offset of %d, %d. Do you want to apply "
+ "this offset to the layer?"),
+ offset_x, offset_y);
+ label = gtk_label_new (message);
+ gtk_label_set_yalign (GTK_LABEL (label), 0.0);
+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+ gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
+ gtk_widget_show (label);
+
+ gtk_widget_show (dialog);
+
+ run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_YES);
+
+ gtk_widget_destroy (dialog);
+
+ return run;
+}
+
+/*
+ * 'save_image ()' - Export the specified image to a PNG file.
+ */
+
+static gboolean
+save_image (const gchar *filename,
+ gint32 image_ID,
+ gint32 drawable_ID,
+ gint32 orig_image_ID,
+ GError **error)
+{
+ gint i, k; /* Looping vars */
+ gint bpp = 0; /* Bytes per pixel */
+ gint type; /* Type of drawable/layer */
+ gint num_passes; /* Number of interlace passes in file */
+ gint pass; /* Current pass in file */
+ gint tile_height; /* Height of tile in GIMP */
+ gint width; /* image width */
+ gint height; /* image height */
+ gint begin; /* Beginning tile row */
+ gint end; /* Ending tile row */
+ gint num; /* Number of rows to load */
+ FILE *fp; /* File pointer */
+ GimpColorProfile *profile = NULL; /* Color profile */
+ gboolean out_linear; /* Save linear RGB */
+ GeglBuffer *buffer; /* GEGL buffer for layer */
+ const Babl *file_format; /* BABL format of file */
+ png_structp pp; /* PNG read pointer */
+ png_infop info; /* PNG info pointer */
+ gint offx, offy; /* Drawable offsets from origin */
+ guchar **pixels; /* Pixel rows */
+ guchar *fixed; /* Fixed-up pixel data */
+ guchar *pixel; /* Pixel data */
+ gdouble xres, yres; /* GIMP resolution (dpi) */
+ png_color_16 background; /* Background color */
+ png_time mod_time; /* Modification time (ie NOW) */
+ time_t cutime; /* Time since epoch */
+ struct tm *gmt; /* GMT broken down */
+ gint color_type; /* PNG color type */
+ gint bit_depth; /* Default to bit depth 16 */
+
+ guchar remap[256]; /* Re-mapping for the palette */
+
+ png_textp text = NULL;
+
+ out_linear = FALSE;
+#if defined(PNG_iCCP_SUPPORTED)
+ /* If no profile is written: export as sRGB.
+ * If manually assigned profile written: follow its TRC.
+ * If default profile written:
+ * - when export as auto or 16-bit: follow the storage TRC.
+ * - when export from 8-bit storage: follow the storage TRC.
+ * - when converting high bit depth to 8-bit: export as sRGB.
+ */
+ if (pngvals.save_profile)
+ {
+ profile = gimp_image_get_color_profile (orig_image_ID);
+
+ if (profile ||
+ pngvals.export_format == PNG_FORMAT_AUTO ||
+ pngvals.export_format == PNG_FORMAT_RGB16 ||
+ pngvals.export_format == PNG_FORMAT_RGBA16 ||
+ pngvals.export_format == PNG_FORMAT_GRAY16 ||
+ pngvals.export_format == PNG_FORMAT_GRAYA16 ||
+ gimp_image_get_precision (image_ID) == GIMP_PRECISION_U8_LINEAR ||
+ gimp_image_get_precision (image_ID) == GIMP_PRECISION_U8_GAMMA)
+ {
+ if (! profile)
+ profile = gimp_image_get_effective_color_profile (orig_image_ID);
+ out_linear = (gimp_color_profile_is_linear (profile));
+ }
+ else
+ {
+ /* When converting higher bit depth work image into 8-bit,
+ * with no manually assigned profile, make sure the result is
+ * sRGB.
+ */
+ profile = gimp_image_get_effective_color_profile (orig_image_ID);
+
+ if (gimp_color_profile_is_linear (profile))
+ {
+ GimpColorProfile *saved_profile;
+
+ saved_profile = gimp_color_profile_new_srgb_trc_from_color_profile (profile);
+ g_object_unref (profile);
+ profile = saved_profile;
+ }
+ }
+ }
+#endif
+
+ /* We save as 8-bit PNG only if:
+ * (1) Work image is 8-bit linear with linear profile to be saved.
+ * (2) Work image is 8-bit non-linear or perceptual with or without
+ * profile.
+ */
+ bit_depth = 16;
+ switch (gimp_image_get_precision (image_ID))
+ {
+ case GIMP_PRECISION_U8_LINEAR:
+ if (out_linear)
+ bit_depth = 8;
+ break;
+
+ case GIMP_PRECISION_U8_GAMMA:
+ if (! out_linear)
+ bit_depth = 8;
+ break;
+
+ default:
+ break;
+ }
+
+ pp = png_create_write_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 write struct while exporting '%s'."),
+ gimp_filename_to_utf8 (filename));
+ return FALSE;
+ }
+
+ info = png_create_info_struct (pp);
+ if (! info)
+ {
+ g_set_error (error, 0, 0,
+ _("Error while exporting '%s'. Could not create PNG header info structure."),
+ gimp_filename_to_utf8 (filename));
+ return FALSE;
+ }
+
+ if (setjmp (png_jmpbuf (pp)))
+ {
+ g_set_error (error, 0, 0,
+ _("Error while exporting '%s'. Could not export image."),
+ gimp_filename_to_utf8 (filename));
+ return FALSE;
+ }
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+ /* Change some libpng errors to warnings (e.g. bug 721135) */
+ png_set_benign_errors (pp, TRUE);
+
+ /* bug 765850 */
+ png_set_option (pp, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
+#endif
+
+ /*
+ * Open the file and initialize the PNG write "engine"...
+ */
+
+ gimp_progress_init_printf (_("Exporting '%s'"),
+ gimp_filename_to_utf8 (filename));
+
+ fp = g_fopen (filename, "wb");
+ if (fp == NULL)
+ {
+ g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+ _("Could not open '%s' for writing: %s"),
+ gimp_filename_to_utf8 (filename), g_strerror (errno));
+ return FALSE;
+ }
+
+ png_init_io (pp, fp);
+
+ /*
+ * Get the buffer for the current image...
+ */
+
+ buffer = gimp_drawable_get_buffer (drawable_ID);
+ width = gegl_buffer_get_width (buffer);
+ height = gegl_buffer_get_height (buffer);
+ type = gimp_drawable_type (drawable_ID);
+
+ /*
+ * Initialise remap[]
+ */
+ for (i = 0; i < 256; i++)
+ remap[i] = i;
+
+ if (pngvals.export_format == PNG_FORMAT_AUTO)
+ {
+ /*
+ * Set color type and remember bytes per pixel count
+ */
+
+ switch (type)
+ {
+ case GIMP_RGB_IMAGE:
+ color_type = PNG_COLOR_TYPE_RGB;
+ if (bit_depth == 8)
+ {
+ if (out_linear)
+ file_format = babl_format ("RGB u8");
+ else
+ file_format = babl_format ("R'G'B' u8");
+ }
+ else
+ {
+ if (out_linear)
+ file_format = babl_format ("RGB u16");
+ else
+ file_format = babl_format ("R'G'B' u16");
+ }
+ break;
+
+ case GIMP_RGBA_IMAGE:
+ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ if (bit_depth == 8)
+ {
+ if (out_linear)
+ file_format = babl_format ("RGBA u8");
+ else
+ file_format = babl_format ("R'G'B'A u8");
+ }
+ else
+ {
+ if (out_linear)
+ file_format = babl_format ("RGBA u16");
+ else
+ file_format = babl_format ("R'G'B'A u16");
+ }
+ break;
+
+ case GIMP_GRAY_IMAGE:
+ color_type = PNG_COLOR_TYPE_GRAY;
+ if (bit_depth == 8)
+ {
+ if (out_linear)
+ file_format = babl_format ("Y u8");
+ else
+ file_format = babl_format ("Y' u8");
+ }
+ else
+ {
+ if (out_linear)
+ file_format = babl_format ("Y u16");
+ else
+ file_format = babl_format ("Y' u16");
+ }
+ break;
+
+ case GIMP_GRAYA_IMAGE:
+ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ if (bit_depth == 8)
+ {
+ if (out_linear)
+ file_format = babl_format ("YA u8");
+ else
+ file_format = babl_format ("Y'A u8");
+ }
+ else
+ {
+ if (out_linear)
+ file_format = babl_format ("YA u16");
+ else
+ file_format = babl_format ("Y'A u16");
+ }
+ break;
+
+ case GIMP_INDEXED_IMAGE:
+ color_type = PNG_COLOR_TYPE_PALETTE;
+ file_format = gimp_drawable_get_format (drawable_ID);
+ 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:
+ color_type = PNG_COLOR_TYPE_PALETTE;
+ file_format = gimp_drawable_get_format (drawable_ID);
+ /* fix up transparency */
+ bit_depth = respin_cmap (pp, info, remap, image_ID, drawable_ID);
+ break;
+
+ default:
+ g_set_error (error, 0, 0, "Image type can't be exported as PNG");
+ return FALSE;
+ }
+ }
+ else
+ {
+ switch (pngvals.export_format)
+ {
+ case PNG_FORMAT_RGB8:
+ color_type = PNG_COLOR_TYPE_RGB;
+ if (out_linear)
+ file_format = babl_format ("RGB u8");
+ else
+ file_format = babl_format ("R'G'B' u8");
+ bit_depth = 8;
+ break;
+ case PNG_FORMAT_GRAY8:
+ color_type = PNG_COLOR_TYPE_GRAY;
+ if (out_linear)
+ file_format = babl_format ("Y u8");
+ else
+ file_format = babl_format ("Y' u8");
+ bit_depth = 8;
+ break;
+ case PNG_FORMAT_RGBA8:
+ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ if (out_linear)
+ file_format = babl_format ("RGBA u8");
+ else
+ file_format = babl_format ("R'G'B'A u8");
+ bit_depth = 8;
+ break;
+ case PNG_FORMAT_GRAYA8:
+ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ if (out_linear)
+ file_format = babl_format ("YA u8");
+ else
+ file_format = babl_format ("Y'A u8");
+ bit_depth = 8;
+ break;
+ case PNG_FORMAT_RGB16:
+ color_type = PNG_COLOR_TYPE_RGB;
+ if (out_linear)
+ file_format = babl_format ("RGB u16");
+ else
+ file_format = babl_format ("R'G'B' u16");
+ bit_depth = 16;
+ break;
+ case PNG_FORMAT_GRAY16:
+ color_type = PNG_COLOR_TYPE_GRAY;
+ if (out_linear)
+ file_format = babl_format ("Y u16");
+ else
+ file_format = babl_format ("Y' u16");
+ bit_depth = 16;
+ break;
+ case PNG_FORMAT_RGBA16:
+ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ if (out_linear)
+ file_format = babl_format ("RGBA u16");
+ else
+ file_format = babl_format ("R'G'B'A u16");
+ bit_depth = 16;
+ break;
+ case PNG_FORMAT_GRAYA16:
+ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ if (out_linear)
+ file_format = babl_format ("YA u16");
+ else
+ file_format = babl_format ("Y'A u16");
+ bit_depth = 16;
+ break;
+ case PNG_FORMAT_AUTO:
+ g_return_val_if_reached (FALSE);
+ }
+ }
+
+ bpp = babl_format_get_bytes_per_pixel (file_format);
+
+ /* Note: png_set_IHDR() must be called before any other png_set_*()
+ functions. */
+ png_set_IHDR (pp, info, width, 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 (pngg.has_plte)
+ 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 */
+
+ if (pngvals.bkgd)
+ {
+ GimpRGB color;
+ guchar red, green, blue;
+
+ gimp_context_get_background (&color);
+ gimp_rgb_get_uchar (&color, &red, &green, &blue);
+
+ background.index = 0;
+ background.red = red;
+ background.green = green;
+ background.blue = blue;
+ background.gray = gimp_rgb_luminance_uchar (&color);
+ png_set_bKGD (pp, info, &background);
+ }
+
+ if (pngvals.gama)
+ {
+ GimpParasite *parasite;
+ gdouble gamma = 1.0 / DEFAULT_GAMMA;
+
+ parasite = gimp_image_get_parasite (orig_image_ID, "gamma");
+ if (parasite)
+ {
+ gamma = g_ascii_strtod (gimp_parasite_data (parasite), NULL);
+ gimp_parasite_free (parasite);
+ }
+
+ png_set_gAMA (pp, info, gamma);
+ }
+
+ if (pngvals.offs)
+ {
+ gimp_drawable_offsets (drawable_ID, &offx, &offy);
+ if (offx != 0 || offy != 0)
+ png_set_oFFs (pp, info, offx, offy, PNG_OFFSET_PIXEL);
+ }
+
+ if (pngvals.phys)
+ {
+ gimp_image_get_resolution (orig_image_ID, &xres, &yres);
+ png_set_pHYs (pp, info, RINT (xres / 0.0254), RINT (yres / 0.0254),
+ PNG_RESOLUTION_METER);
+ }
+
+ if (pngvals.time)
+ {
+ cutime = time (NULL); /* time right NOW */
+ gmt = gmtime (&cutime);
+
+ mod_time.year = gmt->tm_year + 1900;
+ mod_time.month = gmt->tm_mon + 1;
+ mod_time.day = gmt->tm_mday;
+ mod_time.hour = gmt->tm_hour;
+ mod_time.minute = gmt->tm_min;
+ mod_time.second = gmt->tm_sec;
+ png_set_tIME (pp, info, &mod_time);
+ }
+
+#if defined(PNG_iCCP_SUPPORTED)
+ if (pngvals.save_profile)
+ {
+ GimpParasite *parasite;
+ gchar *profile_name = NULL;
+ const guint8 *icc_data;
+ gsize icc_length;
+
+ icc_data = gimp_color_profile_get_icc_profile (profile, &icc_length);
+
+ parasite = gimp_image_get_parasite (orig_image_ID,
+ "icc-profile-name");
+ if (parasite)
+ profile_name = g_convert (gimp_parasite_data (parasite),
+ gimp_parasite_data_size (parasite),
+ "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
+
+ png_set_iCCP (pp,
+ info,
+ profile_name ? profile_name : "ICC profile",
+ 0,
+ icc_data,
+ icc_length);
+
+ g_free (profile_name);
+ g_object_unref (profile);
+ }
+#endif
+
+#ifdef PNG_zTXt_SUPPORTED
+/* Small texts are not worth compressing and will be even bigger if compressed.
+ Empirical length limit of a text being worth compressing. */
+#define COMPRESSION_WORTHY_LENGTH 200
+#endif
+
+ if (pngvals.comment)
+ {
+ GimpParasite *parasite;
+ gsize text_length = 0;
+
+ parasite = gimp_image_get_parasite (orig_image_ID, "gimp-comment");
+ if (parasite)
+ {
+ gchar *comment = g_strndup (gimp_parasite_data (parasite),
+ gimp_parasite_data_size (parasite));
+
+ gimp_parasite_free (parasite);
+
+ if (comment && strlen (comment) > 0)
+ {
+ text = g_new0 (png_text, 1);
+
+ text[0].key = "Comment";
+
+#ifdef PNG_iTXt_SUPPORTED
+
+ text[0].text = g_convert (comment, -1,
+ "ISO-8859-1",
+ "UTF-8",
+ NULL,
+ &text_length,
+ NULL);
+
+ if (text[0].text == NULL || strlen (text[0].text) == 0)
+ {
+ /* We can't convert to ISO-8859-1 without loss.
+ Save the comment as iTXt (UTF-8). */
+ g_free (text[0].text);
+
+ text[0].text = g_strdup (comment);
+ text[0].itxt_length = strlen (text[0].text);
+
+#ifdef PNG_zTXt_SUPPORTED
+ text[0].compression = strlen (text[0].text) > COMPRESSION_WORTHY_LENGTH ?
+ PNG_ITXT_COMPRESSION_zTXt : PNG_ITXT_COMPRESSION_NONE;
+#else
+ text[0].compression = PNG_ITXT_COMPRESSION_NONE;
+#endif /* PNG_zTXt_SUPPORTED */
+ }
+ else
+ /* The comment is ISO-8859-1 compatible, so we use tEXt
+ even if there is iTXt support for compatibility to more
+ png reading programs. */
+#endif /* PNG_iTXt_SUPPORTED */
+ {
+#ifndef PNG_iTXt_SUPPORTED
+ /* No iTXt support, so we are forced to use tEXt (ISO-8859-1).
+ A broken comment is better than no comment at all, so the
+ conversion does not fail on unknown character.
+ They are simply ignored. */
+ text[0].text = g_convert_with_fallback (comment, -1,
+ "ISO-8859-1",
+ "UTF-8",
+ "",
+ NULL,
+ &text_length,
+ NULL);
+#endif
+
+#ifdef PNG_zTXt_SUPPORTED
+ text[0].compression = strlen (text[0].text) > COMPRESSION_WORTHY_LENGTH ?
+ PNG_TEXT_COMPRESSION_zTXt : PNG_TEXT_COMPRESSION_NONE;
+#else
+ text[0].compression = PNG_TEXT_COMPRESSION_NONE;
+#endif /* PNG_zTXt_SUPPORTED */
+
+ text[0].text_length = text_length;
+ }
+
+ if (! text[0].text || strlen (text[0].text) == 0)
+ {
+ g_free (text[0].text);
+ g_free (text);
+ text = NULL;
+ }
+
+ g_free (comment);
+ }
+ }
+ }
+
+#ifdef PNG_zTXt_SUPPORTED
+#undef COMPRESSION_WORTHY_LENGTH
+#endif
+
+ if (text)
+ png_set_text (pp, info, text, 1);
+
+ png_write_info (pp, info);
+ if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
+ png_set_swap (pp);
+
+ /*
+ * Turn on interlace handling...
+ */
+
+ if (pngvals.interlaced)
+ num_passes = png_set_interlace_handling (pp);
+ else
+ num_passes = 1;
+
+ /*
+ * Convert unpacked pixels to packed if necessary
+ */
+
+ if (color_type == PNG_COLOR_TYPE_PALETTE &&
+ bit_depth < 8)
+ png_set_packing (pp);
+
+ /*
+ * Allocate memory for "tile_height" rows and export the image...
+ */
+
+ tile_height = gimp_tile_height ();
+ pixel = g_new (guchar, tile_height * width * bpp);
+ pixels = g_new (guchar *, tile_height);
+
+ for (i = 0; i < tile_height; i++)
+ pixels[i] = pixel + width * bpp * i;
+
+ for (pass = 0; pass < num_passes; pass++)
+ {
+ /* This works if you are only writing one row at a time... */
+ for (begin = 0, end = tile_height;
+ begin < height; begin += tile_height, end += tile_height)
+ {
+ if (end > height)
+ end = height;
+
+ num = end - begin;
+
+ gegl_buffer_get (buffer,
+ GEGL_RECTANGLE (0, begin, width, num),
+ 1.0,
+ file_format,
+ pixel,
+ GEGL_AUTO_ROWSTRIDE,
+ GEGL_ABYSS_NONE);
+
+ /* 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)
+ {
+ fixed = pixels[i];
+ for (k = 0; k < width; ++k)
+ {
+ if (!fixed[3])
+ fixed[0] = fixed[1] = fixed[2] = 0;
+ fixed += bpp;
+ }
+ }
+ }
+
+ if (bpp == 8 && ! pngvals.save_transp_pixels)
+ {
+ for (i = 0; i < num; ++i)
+ {
+ fixed = pixels[i];
+ for (k = 0; k < width; ++k)
+ {
+ if (!fixed[6] && !fixed[7])
+ fixed[0] = fixed[1] = fixed[2] =
+ fixed[3] = fixed[4] = fixed[5] = 0;
+ fixed += bpp;
+ }
+ }
+ }
+
+ /* If we're dealing with a paletted image with
+ * transparency set, write out the remapped palette */
+ if (png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ guchar inverse_remap[256];
+
+ for (i = 0; i < 256; i++)
+ inverse_remap[ remap[i] ] = i;
+
+ for (i = 0; i < num; ++i)
+ {
+ fixed = pixels[i];
+ for (k = 0; k < width; ++k)
+ {
+ fixed[k] = (fixed[k*2+1] > 127) ?
+ inverse_remap[ fixed[k*2] ] :
+ 0;
+ }
+ }
+ }
+
+ /* Otherwise if we have a paletted image and transparency
+ * couldn't be set, we ignore the alpha channel */
+ else if (png_get_valid (pp, info, PNG_INFO_PLTE) &&
+ bpp == 2)
+ {
+ for (i = 0; i < num; ++i)
+ {
+ fixed = pixels[i];
+ for (k = 0; k < width; ++k)
+ {
+ fixed[k] = fixed[k * 2];
+ }
+ }
+ }
+
+ png_write_rows (pp, pixels, num);
+
+ gimp_progress_update (((double) pass + (double) end /
+ (double) height) /
+ (double) num_passes);
+ }
+ }
+
+ gimp_progress_update (1.0);
+
+ png_write_end (pp, info);
+ png_destroy_write_struct (&pp, &info);
+
+ g_free (pixel);
+ g_free (pixels);
+
+ /*
+ * Done with the file...
+ */
+
+ if (text)
+ {
+ g_free (text[0].text);
+ g_free (text);
+ }
+
+ free (pp);
+ free (info);
+
+ fclose (fp);
+
+ return TRUE;
+}
+
+static gboolean
+ia_has_transparent_pixels (GeglBuffer *buffer)
+{
+ GeglBufferIterator *iter;
+ const Babl *format;
+ gint n_components;
+
+ format = gegl_buffer_get_format (buffer);
+ iter = gegl_buffer_iterator_new (buffer, NULL, 0, format,
+ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1);
+ n_components = babl_format_get_n_components (format);
+ g_return_val_if_fail (n_components == 2, FALSE);
+
+ while (gegl_buffer_iterator_next (iter))
+ {
+ const guchar *data = iter->items[0].data;
+ gint length = iter->length;
+
+ while (length--)
+ {
+ if (data[1] <= 127)
+ {
+ gegl_buffer_iterator_stop (iter);
+ return TRUE;
+ }
+
+ data += n_components;
+ }
+ }
+
+ return FALSE;
+}
+
+/* Try to find a color in the palette which isn't actually
+ * used in the image, so that we can use it as the transparency
+ * index. Taken from gif.c */
+static gint
+find_unused_ia_color (GeglBuffer *buffer,
+ gint *colors)
+{
+ GeglBufferIterator *iter;
+ const Babl *format;
+ gint n_components;
+ gboolean ix_used[256];
+ gboolean trans_used = FALSE;
+ gint i;
+
+ for (i = 0; i < *colors; i++)
+ ix_used[i] = FALSE;
+
+ format = gegl_buffer_get_format (buffer);
+ iter = gegl_buffer_iterator_new (buffer, NULL, 0, format,
+ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1);
+ n_components = babl_format_get_n_components (format);
+ g_return_val_if_fail (n_components == 2, FALSE);
+
+ while (gegl_buffer_iterator_next (iter))
+ {
+ const guchar *data = iter->items[0].data;
+ gint length = iter->length;
+
+ while (length--)
+ {
+ if (data[1] > 127)
+ ix_used[data[0]] = TRUE;
+ else
+ trans_used = TRUE;
+
+ data += n_components;
+ }
+ }
+
+ /* If there is no transparency, ignore alpha. */
+ if (trans_used == FALSE)
+ return -1;
+
+ /* If there is still some room at the end of the palette, increment
+ * the number of colors in the image and assign a transparent pixel
+ * there. */
+ if ((*colors) < 256)
+ {
+ (*colors)++;
+
+ return (*colors) - 1;
+ }
+
+ for (i = 0; i < *colors; i++)
+ {
+ if (ix_used[i] == FALSE)
+ return i;
+ }
+
+ return -1;
+}
+
+
+static int
+respin_cmap (png_structp pp,
+ png_infop info,
+ guchar *remap,
+ gint32 image_ID,
+ gint32 drawable_ID)
+{
+ static guchar trans[] = { 0 };
+ GeglBuffer *buffer;
+
+ gint colors;
+ guchar *before;
+
+ before = gimp_image_get_colormap (image_ID, &colors);
+ buffer = gimp_drawable_get_buffer (drawable_ID);
+
+ /*
+ * Make sure there is something in the colormap.
+ */
+ if (colors == 0)
+ {
+ before = g_newa (guchar, 3);
+ memset (before, 0, sizeof (guchar) * 3);
+
+ colors = 1;
+ }
+
+ /* Try to find an entry which isn't actually used in the
+ image, for a transparency index. */
+
+ if (ia_has_transparent_pixels (buffer))
+ {
+ gint transparent = find_unused_ia_color (buffer, &colors);
+
+ if (transparent != -1) /* we have a winner for a transparent
+ * index - do like gif2png and swap
+ * index 0 and index transparent */
+ {
+ static png_color palette[256];
+ gint i;
+
+ /* 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
+ * due to png_set_tRNS() */
+
+ remap[0] = transparent;
+ for (i = 1; i <= transparent; i++)
+ remap[i] = i - 1;
+
+ /* Copy from index 0 to index transparent - 1 to index 1 to
+ * transparent of after, then from transparent+1 to colors-1
+ * unchanged, and finally from index transparent to index 0. */
+
+ for (i = 0; i < colors; i++)
+ {
+ palette[i].red = before[3 * remap[i]];
+ palette[i].green = before[3 * remap[i] + 1];
+ palette[i].blue = before[3 * remap[i] + 2];
+ }
+
+ /* Set PLTE chunk values for writing later. */
+ pngg.has_plte = TRUE;
+ pngg.palette = palette;
+ pngg.num_palette = colors;
+ }
+ else
+ {
+ /* Inform the user that we couldn't losslessly save the
+ * transparency & just use the full palette */
+ g_message (_("Couldn't losslessly save transparency, "
+ "saving opacity instead."));
+
+ /* Set PLTE chunk values for writing later. */
+ pngg.has_plte = TRUE;
+ pngg.palette = (png_colorp) before;
+ pngg.num_palette = colors;
+ }
+ }
+ else
+ {
+ /* Set PLTE chunk values for writing later. */
+ pngg.has_plte = TRUE;
+ pngg.palette = (png_colorp) before;
+ pngg.num_palette = colors;
+ }
+
+ g_object_unref (buffer);
+
+ return get_bit_depth_for_palette (colors);
+}
+
+static GtkWidget *
+toggle_button_init (GtkBuilder *builder,
+ const gchar *name,
+ gboolean initial_value,
+ gboolean *value_pointer)
+{
+ GtkWidget *toggle = NULL;
+
+ toggle = GTK_WIDGET (gtk_builder_get_object (builder, name));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), initial_value);
+ g_signal_connect (toggle, "toggled",
+ G_CALLBACK (gimp_toggle_button_update),
+ value_pointer);
+
+ return toggle;
+}
+
+static void pixformat_changed (GtkWidget *widget,
+ void *foo)
+{
+ PngExportFormat *ep = foo;
+ *ep = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
+}
+
+static gboolean
+save_dialog (gint32 image_ID,
+ gboolean alpha)
+{
+ PngSaveGui pg;
+ GtkWidget *dialog;
+ GtkBuilder *builder;
+ gchar *ui_file;
+ GimpParasite *parasite;
+ GError *error = NULL;
+
+ /* Dialog init */
+ dialog = gimp_export_dialog_new (_("PNG"), PLUG_IN_BINARY, SAVE_PROC);
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (save_dialog_response),
+ &pg);
+ g_signal_connect (dialog, "destroy",
+ G_CALLBACK (gtk_main_quit),
+ NULL);
+
+ /* GtkBuilder init */
+ builder = gtk_builder_new ();
+ ui_file = g_build_filename (gimp_data_directory (),
+ "ui/plug-ins/plug-in-file-png.ui",
+ NULL);
+ if (! gtk_builder_add_from_file (builder, ui_file, &error))
+ {
+ gchar *display_name = g_filename_display_name (ui_file);
+
+ g_printerr (_("Error loading UI file '%s': %s"),
+ display_name, error ? error->message : _("Unknown error"));
+
+ g_free (display_name);
+ }
+
+ g_free (ui_file);
+
+ /* Table */
+ gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
+ GTK_WIDGET (gtk_builder_get_object (builder, "table")),
+ FALSE, FALSE, 0);
+
+ /* Toggles */
+ pg.interlaced = toggle_button_init (builder, "interlace",
+ pngvals.interlaced,
+ &pngvals.interlaced);
+ pg.bkgd = toggle_button_init (builder, "save-background-color",
+ pngvals.bkgd,
+ &pngvals.bkgd);
+ pg.gama = toggle_button_init (builder, "save-gamma",
+ pngvals.gama,
+ &pngvals.gama);
+ pg.offs = toggle_button_init (builder, "save-layer-offset",
+ pngvals.offs,
+ &pngvals.offs);
+ pg.phys = toggle_button_init (builder, "save-resolution",
+ pngvals.phys,
+ &pngvals.phys);
+ pg.time = toggle_button_init (builder, "save-creation-time",
+ pngvals.time,
+ &pngvals.time);
+ pg.save_exif = toggle_button_init (builder, "save-exif",
+ pngvals.save_exif,
+ &pngvals.save_exif);
+ pg.save_xmp = toggle_button_init (builder, "save-xmp",
+ pngvals.save_xmp,
+ &pngvals.save_xmp);
+ pg.save_iptc = toggle_button_init (builder, "save-iptc",
+ pngvals.save_iptc,
+ &pngvals.save_iptc);
+ pg.save_thumbnail = toggle_button_init (builder, "save-thumbnail",
+ pngvals.save_thumbnail,
+ &pngvals.save_thumbnail);
+ pg.save_profile = toggle_button_init (builder, "save-color-profile",
+ pngvals.save_profile,
+ &pngvals.save_profile);
+
+#if !defined(PNG_iCCP_SUPPORTED)
+ gtk_widget_hide (pg.save_profile);
+#endif
+
+ /* Comment toggle */
+ parasite = gimp_image_get_parasite (image_ID, "gimp-comment");
+ pg.comment =
+ toggle_button_init (builder, "save-comment",
+ pngvals.comment && parasite != NULL,
+ &pngvals.comment);
+ gtk_widget_set_sensitive (pg.comment, parasite != NULL);
+ gimp_parasite_free (parasite);
+
+ /* Transparent pixels toggle */
+ pg.save_transp_pixels =
+ toggle_button_init (builder,
+ "save-transparent-pixels",
+ alpha && pngvals.save_transp_pixels,
+ &pngvals.save_transp_pixels);
+ gtk_widget_set_sensitive (pg.save_transp_pixels, alpha);
+
+ /* Compression level scale */
+ pg.compression_level =
+ GTK_ADJUSTMENT (gtk_builder_get_object (builder, "compression-level"));
+ gtk_adjustment_set_value (pg.compression_level, pngvals.compression_level);
+ g_signal_connect (pg.compression_level, "value-changed",
+ G_CALLBACK (gimp_int_adjustment_update),
+ &pngvals.compression_level);
+
+ /* Compression level scale */
+ pg.pixelformat =
+ GTK_WIDGET (gtk_builder_get_object (builder, "pixelformat-combo"));
+ gtk_combo_box_set_active (GTK_COMBO_BOX (pg.pixelformat), pngvals.export_format);
+ g_signal_connect (pg.pixelformat, "changed",
+ G_CALLBACK (pixformat_changed),
+ &pngvals.export_format);
+
+#if 0
+ gtk_adjustment_set_value (pg.compression_level, pngvals.compression_level);
+ g_signal_connect (pg.compression_level, "value-changed",
+ G_CALLBACK (gimp_int_adjustment_update),
+ &pngvals.compression_level);
+#endif
+
+ /* Load/save defaults buttons */
+ g_signal_connect_swapped (gtk_builder_get_object (builder, "load-defaults"),
+ "clicked",
+ G_CALLBACK (load_gui_defaults),
+ &pg);
+
+ g_signal_connect_swapped (gtk_builder_get_object (builder, "save-defaults"),
+ "clicked",
+ G_CALLBACK (save_parasite),
+ &pg);
+
+ /* Show dialog and run */
+ gtk_widget_show (dialog);
+
+ pg.run = FALSE;
+
+ gtk_main ();
+
+ return pg.run;
+}
+
+static void
+save_dialog_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data)
+{
+ PngSaveGui *pg = data;
+
+ switch (response_id)
+ {
+ case GTK_RESPONSE_OK:
+ pg->run = TRUE;
+
+ default:
+ gtk_widget_destroy (widget);
+ break;
+ }
+}
+
+static void
+load_parasite (void)
+{
+ GimpParasite *parasite;
+
+ parasite = gimp_get_parasite (PNG_DEFAULTS_PARASITE);
+
+ if (parasite)
+ {
+ gchar *def_str;
+ PngSaveVals tmpvals = defaults;
+ gint num_fields;
+
+ def_str = g_strndup (gimp_parasite_data (parasite),
+ gimp_parasite_data_size (parasite));
+
+ gimp_parasite_free (parasite);
+
+ num_fields = sscanf (def_str, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d",
+ &tmpvals.interlaced,
+ &tmpvals.bkgd,
+ &tmpvals.gama,
+ &tmpvals.offs,
+ &tmpvals.phys,
+ &tmpvals.time,
+ &tmpvals.comment,
+ &tmpvals.save_transp_pixels,
+ &tmpvals.compression_level,
+ &tmpvals.save_exif,
+ &tmpvals.save_xmp,
+ &tmpvals.save_iptc,
+ &tmpvals.save_thumbnail,
+ &tmpvals.save_profile);
+
+ g_free (def_str);
+
+ if (num_fields == 9 || num_fields == 13 || num_fields == 14)
+ pngvals = tmpvals;
+ }
+}
+
+static void
+save_parasite (void)
+{
+ GimpParasite *parasite;
+ gchar *def_str;
+
+ def_str = g_strdup_printf ("%d %d %d %d %d %d %d %d %d %d %d %d %d %d",
+ pngvals.interlaced,
+ pngvals.bkgd,
+ pngvals.gama,
+ pngvals.offs,
+ pngvals.phys,
+ pngvals.time,
+ pngvals.comment,
+ pngvals.save_transp_pixels,
+ pngvals.compression_level,
+ pngvals.save_exif,
+ pngvals.save_xmp,
+ pngvals.save_iptc,
+ pngvals.save_thumbnail,
+ pngvals.save_profile);
+
+ parasite = gimp_parasite_new (PNG_DEFAULTS_PARASITE,
+ GIMP_PARASITE_PERSISTENT,
+ strlen (def_str), def_str);
+
+ gimp_attach_parasite (parasite);
+
+ gimp_parasite_free (parasite);
+ g_free (def_str);
+}
+
+static void
+load_gui_defaults (PngSaveGui *pg)
+{
+ /* initialize with hardcoded defaults */
+ pngvals = defaults;
+ /* Override with parasite. */
+ load_parasite ();
+
+#define SET_ACTIVE(field) \
+ if (gtk_widget_is_sensitive (pg->field)) \
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pg->field), pngvals.field)
+
+ SET_ACTIVE (interlaced);
+ SET_ACTIVE (bkgd);
+ SET_ACTIVE (gama);
+ SET_ACTIVE (offs);
+ SET_ACTIVE (phys);
+ SET_ACTIVE (time);
+ SET_ACTIVE (comment);
+ SET_ACTIVE (save_transp_pixels);
+ SET_ACTIVE (save_exif);
+ SET_ACTIVE (save_xmp);
+ SET_ACTIVE (save_iptc);
+ SET_ACTIVE (save_thumbnail);
+ SET_ACTIVE (save_profile);
+
+#undef SET_ACTIVE
+
+ gtk_adjustment_set_value (pg->compression_level,
+ pngvals.compression_level);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 03:54:56 +0000