/* 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 . * * 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 #include #include #include #include #include /* 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 , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>", "Michael Sweet , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, " "Nick Lamb ", 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 , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>", "Michael Sweet , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, " "Nick Lamb ", 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 , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>", "Michael Sweet , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, " "Nick Lamb ", 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 , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>", "Michael Sweet , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, " "Nick Lamb ", 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 , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>", "Michael Sweet , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, " "Nick Lamb ", 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 , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>", "Michael Sweet , " "Daniel Skarda <0rfelyus@atrey.karlin.mff.cuni.cz>, " "Nick Lamb ", 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 (! 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); }