diff options
Diffstat (limited to 'plug-ins/common/file-gif-save.c')
| -rw-r--r-- | plug-ins/common/file-gif-save.c | 2589 |
1 files changed, 2589 insertions, 0 deletions
diff --git a/plug-ins/common/file-gif-save.c b/plug-ins/common/file-gif-save.c new file mode 100644 index 0000000..3563172 --- /dev/null +++ b/plug-ins/common/file-gif-save.c @@ -0,0 +1,2589 @@ +/* GIF exporting file filter for GIMP + * + * Copyright + * - Adam D. Moss + * - Peter Mattis + * - Spencer Kimball + * + * Based around original GIF code by David Koblas. + * + * + * Version 4.1.0 - 2003-06-16 + * Adam D. Moss - <adam@gimp.org> <adam@foxbox.org> + */ +/* + * This filter uses code taken from the "giftopnm" and "ppmtogif" programs + * which are part of the "netpbm" package. + */ +/* + * "The Graphics Interchange Format(c) is the Copyright property of + * CompuServe Incorporated. GIF(sm) is a Service Mark property of + * CompuServe Incorporated." + */ +/* Copyright notice for GIF code from which this plugin was long ago */ +/* derived (David Koblas has granted permission to relicense): */ +/* +-------------------------------------------------------------------+ */ +/* | Copyright 1990, 1991, 1993, David Koblas. (koblas@extra.com) | */ +/* +-------------------------------------------------------------------+ */ + +#include "config.h" + +#include <string.h> + +#include <libgimp/gimp.h> +#include <libgimp/gimpui.h> + +#include "libgimp/stdplugins-intl.h" + + +#define SAVE_PROC "file-gif-save" +#define SAVE2_PROC "file-gif-save2" +#define PLUG_IN_BINARY "file-gif-save" +#define PLUG_IN_ROLE "gimp-file-gif-save" + + +/* uncomment the line below for a little debugging info */ +/* #define GIFDEBUG yesplease */ + + +enum +{ + DISPOSE_STORE_VALUE_COLUMN, + DISPOSE_STORE_LABEL_COLUMN +}; + +enum +{ + DISPOSE_UNSPECIFIED, + DISPOSE_COMBINE, + DISPOSE_REPLACE +}; + +typedef struct +{ + gint interlace; + gint save_comment; + gint loop; + gint default_delay; + gint default_dispose; + gboolean always_use_default_delay; + gboolean always_use_default_dispose; + gboolean as_animation; +} GIFSaveVals; + + +/* Declare some local functions. + */ +static void query (void); +static void run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals); + +static gboolean save_image (GFile *file, + gint32 image_ID, + gint32 drawable_ID, + gint32 orig_image_ID, + GError **error); + +static GimpPDBStatusType sanity_check (GFile *file, + gint32 *image_ID, + GimpRunMode run_mode, + GError **error); +static gboolean bad_bounds_dialog (void); + +static gboolean save_dialog (gint32 image_ID); +static void comment_entry_callback (GtkTextBuffer *buffer); + + +static gboolean comment_was_edited = FALSE; +static gchar *globalcomment = NULL; +static gint Interlace; /* For compression code */ + + +const GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + +static GIFSaveVals gsvals = +{ + FALSE, /* interlace */ + TRUE, /* save comment */ + TRUE, /* loop infinitely */ + 100, /* default_delay between frames (100ms) */ + 0, /* default_dispose = "don't care" */ + FALSE, /* don't always use default_delay */ + FALSE, /* don't always use default_dispose */ + FALSE /* as_animation */ +}; + + +MAIN () + +#define COMMON_SAVE_ARGS \ + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, \ + { GIMP_PDB_IMAGE, "image", "Image to export" }, \ + { GIMP_PDB_DRAWABLE, "drawable", "Drawable to export" }, \ + { GIMP_PDB_STRING, "uri", "The name of the URI to export the image in" }, \ + { GIMP_PDB_STRING, "raw-uri", "The name of the URI to export the image in" }, \ + { GIMP_PDB_INT32, "interlace", "Try to export as interlaced" }, \ + { GIMP_PDB_INT32, "loop", "(animated gif) loop infinitely" }, \ + { GIMP_PDB_INT32, "default-delay", "(animated gif) Default delay between frames in milliseconds" }, \ + { GIMP_PDB_INT32, "default-dispose", "(animated gif) Default disposal type (0=`don't care`, 1=combine, 2=replace)" } + +static void +query (void) +{ + static const GimpParamDef save_args[] = + { + COMMON_SAVE_ARGS + }; + + static const GimpParamDef save2_args[] = + { + COMMON_SAVE_ARGS, + { GIMP_PDB_INT32, "as-animation", "Export GIF as animation?" }, + { GIMP_PDB_INT32, "force-delay", "(animated gif) Use specified delay for all frames?" }, + { GIMP_PDB_INT32, "force-dispose", "(animated gif) Use specified disposal for all frames?" } + }; + + gimp_install_procedure (SAVE_PROC, + "exports files in Compuserve GIF file format", + "Export a file in Compuserve GIF format, with " + "possible animation, transparency, and comment. " + "To export an animation, operate on a multi-layer " + "file. The plug-in will interpret <50% alpha as " + "transparent. When run non-interactively, the " + "value for the comment is taken from the " + "'gimp-comment' parasite. ", + "Spencer Kimball, Peter Mattis, Adam Moss, David Koblas", + "Spencer Kimball, Peter Mattis, Adam Moss, David Koblas", + "1995-1997", + N_("GIF image"), + "INDEXED*, GRAY*", + GIMP_PLUGIN, + G_N_ELEMENTS (save_args), 0, + save_args, NULL); + + gimp_install_procedure (SAVE2_PROC, + "exports files in Compuserve GIF file format", + "Export a file in Compuserve GIF format, with " + "possible animation, transparency, and comment. " + "To export an animation, operate on a multi-layer " + "file and give the 'as-animation' parameter " + "as TRUE. The plug-in will interpret <50% " + "alpha as transparent. When run " + "non-interactively, the value for the comment " + "is taken from the 'gimp-comment' parasite. ", + "Spencer Kimball, Peter Mattis, Adam Moss, David Koblas", + "Spencer Kimball, Peter Mattis, Adam Moss, David Koblas", + "1995-1997", + N_("GIF image"), + "INDEXED*, GRAY*", + GIMP_PLUGIN, + G_N_ELEMENTS (save2_args), 0, + save2_args, NULL); + + gimp_register_file_handler_mime (SAVE_PROC, "image/gif"); + gimp_register_save_handler (SAVE_PROC, "gif", ""); + gimp_register_file_handler_uri (SAVE_PROC); + + gimp_register_save_handler (SAVE2_PROC, "gif", ""); + gimp_register_file_handler_uri (SAVE2_PROC); +} + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + static GimpParam values[2]; + GimpRunMode run_mode; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + GimpExportReturn export = GIMP_EXPORT_CANCEL; + GError *error = NULL; + + INIT_I18N (); + gegl_init (NULL, NULL); + + run_mode = param[0].data.d_int32; + + *nreturn_vals = 1; + *return_vals = values; + + values[0].type = GIMP_PDB_STATUS; + values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; + + if (strcmp (name, SAVE_PROC) == 0 || + strcmp (name, SAVE2_PROC) == 0) + { + GFile *file; + gint32 image_ID; + gint32 orig_image_ID; + gint32 sanitized_image_ID = 0; + gint32 drawable_ID; + + image_ID = orig_image_ID = param[1].data.d_int32; + drawable_ID = param[2].data.d_int32; + file = g_file_new_for_uri (param[3].data.d_string); + + if (run_mode == GIMP_RUN_INTERACTIVE || + run_mode == GIMP_RUN_WITH_LAST_VALS) + gimp_ui_init (PLUG_IN_BINARY, FALSE); + + status = sanity_check (file, &image_ID, run_mode, &error); + + /* Get the export options */ + if (status == GIMP_PDB_SUCCESS) + { + /* If the sanity check succeeded, the image_ID will point to + * a duplicate image to delete later. + */ + sanitized_image_ID = image_ID; + + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + /* Possibly retrieve data */ + gimp_get_data (SAVE_PROC, &gsvals); + + /* First acquire information with a dialog */ + if (! save_dialog (image_ID)) + { + gimp_image_delete (sanitized_image_ID); + status = GIMP_PDB_CANCEL; + } + break; + + case GIMP_RUN_NONINTERACTIVE: + /* Make sure all the arguments are there! */ + if (nparams != 9 && nparams != 12) + { + status = GIMP_PDB_CALLING_ERROR; + } + else + { + gsvals.interlace = (param[5].data.d_int32) ? TRUE : FALSE; + gsvals.save_comment = TRUE; /* no way to to specify that through the PDB */ + gsvals.loop = (param[6].data.d_int32) ? TRUE : FALSE; + gsvals.default_delay = param[7].data.d_int32; + gsvals.default_dispose = param[8].data.d_int32; + if (nparams == 12) + { + gsvals.as_animation = (param[9].data.d_int32) ? TRUE : FALSE; + gsvals.always_use_default_delay = (param[10].data.d_int32) ? TRUE : FALSE; + gsvals.always_use_default_dispose = (param[11].data.d_int32) ? TRUE : FALSE; + } + } + break; + + case GIMP_RUN_WITH_LAST_VALS: + /* Possibly retrieve data */ + gimp_get_data (SAVE_PROC, &gsvals); + break; + + default: + break; + } + } + + if (status == GIMP_PDB_SUCCESS) + { + /* Create an exportable image based on the export options */ + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + case GIMP_RUN_WITH_LAST_VALS: + { + GimpExportCapabilities capabilities = + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA; + + if (gsvals.as_animation) + capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS; + + export = gimp_export_image (&image_ID, &drawable_ID, "GIF", + capabilities); + + if (export == GIMP_EXPORT_CANCEL) + { + values[0].data.d_status = GIMP_PDB_CANCEL; + if (sanitized_image_ID) + gimp_image_delete (sanitized_image_ID); + return; + } + } + break; + default: + break; + } + + /* Load comment from parasite for non-interactive export */ + if (run_mode != GIMP_RUN_INTERACTIVE) + { + GimpParasite *parasite; + + parasite = gimp_image_get_parasite (image_ID, "gimp-comment"); + if (parasite) + { + globalcomment = g_strndup (gimp_parasite_data (parasite), + gimp_parasite_data_size (parasite)); + gimp_parasite_free (parasite); + } + } + + /* Write the image to file */ + if (save_image (file, + image_ID, drawable_ID, orig_image_ID, + &error)) + { + /* Store psvals data */ + gimp_set_data (SAVE_PROC, &gsvals, sizeof (GIFSaveVals)); + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + } + + gimp_image_delete (sanitized_image_ID); + } + + if (export == GIMP_EXPORT_EXPORT) + gimp_image_delete (image_ID); + + g_object_unref (file); + } + + 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; +} + + +/* ppmtogif.c - read a portable pixmap and produce a GIF file +** +** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>. A +** Lempel-Ziv compression based on "compress". +** +** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl> +** +** +** Copyright (C) 1989 by Jef Poskanzer. +** +** Permission to use, copy, modify, and distribute this software and its +** documentation for any purpose and without fee is hereby granted, provided +** that the above copyright notice appear in all copies and that both that +** copyright notice and this permission notice appear in supporting +** documentation. This software is provided "as is" without express or +** implied warranty. +** +** The Graphics Interchange Format(c) is the Copyright property of +** CompuServe Incorporated. GIF(sm) is a Service Mark property of +** CompuServe Incorporated. +*/ + +#define MAXCOLORS 256 + +/* + * Pointer to function returning an int + */ +typedef gint (* ifunptr) (gint x, + gint y); + + +static gint find_unused_ia_color (const guchar *pixels, + gint numpixels, + gint num_indices, + gint *colors); + +static void special_flatten_indexed_alpha (guchar *pixels, + gint transparent, + gint numpixels); + +static gint colors_to_bpp (gint colors); +static gint bpp_to_colors (gint bpp); +static gint get_pixel (gint x, + gint y); +static gint gif_next_pixel (ifunptr getpixel); +static void bump_pixel (void); + +static gboolean gif_encode_header (GOutputStream *output, + gboolean gif89, + gint width, + gint height, + gint background, + gint bpp, + gint *red, + gint *green, + gint *blue, + ifunptr get_pixel, + GError **error); +static gboolean gif_encode_graphic_control_ext (GOutputStream *output, + gint disposal, + gint delay89, + gint n_frames, + gint width, + gint height, + gint transparent, + gint bpp, + ifunptr get_pixel, + GError **error); +static gboolean gif_encode_image_data (GOutputStream *output, + gint width, + gint height, + gint interlace, + gint bpp, + ifunptr get_pixel, + gint offset_x, + gint offset_y, + GError **error); +static gboolean gif_encode_close (GOutputStream *output, + GError **error); +static gboolean gif_encode_loop_ext (GOutputStream *output, + guint n_loops, + GError **error); +static gboolean gif_encode_comment_ext (GOutputStream *output, + const gchar *comment, + GError **error); + +static gint rowstride; +static guchar *pixels; +static gint cur_progress; +static gint max_progress; + +static gboolean compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error); +static gboolean no_compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error); +static gboolean rle_compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error); +static gboolean normal_compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error); + +static gboolean put_byte (GOutputStream *output, + guchar b, + GError **error); +static gboolean put_word (GOutputStream *output, + gint w, + GError **error); +static gboolean put_string (GOutputStream *output, + const gchar *s, + GError **error); +static gboolean output_code (GOutputStream *output, + gint code, + GError **error); +static gboolean cl_block (GOutputStream *output, + GError **error); +static void cl_hash (glong hsize); + +static void char_init (void); +static gboolean char_out (GOutputStream *output, + gint c, + GError **error); +static gboolean char_flush (GOutputStream *output, + GError **error); + + +static gint +find_unused_ia_color (const guchar *pixels, + gint numpixels, + gint num_indices, + gint *colors) +{ + gboolean ix_used[256]; + gint i; + +#ifdef GIFDEBUG + g_printerr ("GIF: fuiac: Image claims to use %d/%d indices - finding free " + "index...\n", *colors, num_indices); +#endif + + for (i = 0; i < 256; i++) + ix_used[i] = FALSE; + + for (i = 0; i < numpixels; i++) + { + if (pixels[i * 2 + 1]) + ix_used[pixels[i * 2]] = TRUE; + } + + for (i = num_indices - 1; i >= 0; i--) + { + if (! ix_used[i]) + { +#ifdef GIFDEBUG + g_printerr ("GIF: Found unused color index %d.\n", (int) i); +#endif + return i; + } + } + + /* Couldn't find an unused color index within the number of bits per + * pixel we wanted. Will have to increment the number of colors in + * the image and assign a transparent pixel there. + */ + if (*colors < 256) + { + (*colors)++; + + g_printerr ("GIF: 2nd pass " + "- Increasing bounds and using color index %d.\n", + *colors - 1); + return ((*colors) - 1); + } + + g_message (_("Couldn't simply reduce colors further. Exporting as opaque.")); + + return -1; +} + + +static void +special_flatten_indexed_alpha (guchar *pixels, + gint transparent, + gint numpixels) +{ + guint32 i; + + /* Each transparent pixel in the image is mapped to a uniform value + * for encoding, if image already has <=255 colors + */ + + if (transparent == -1) /* tough, no indices left for the trans. index */ + { + for (i = 0; i < numpixels; i++) + pixels[i] = pixels[i * 2]; + } + else /* make transparent */ + { + for (i = 0; i < numpixels; i++) + { + if (! (pixels[i * 2 + 1] & 128)) + { + pixels[i] = (guchar) transparent; + } + else + { + pixels[i] = pixels[i * 2]; + } + } + } +} + + +static gint +parse_ms_tag (const gchar *str) +{ + gint sum = 0; + gint offset = 0; + gint length; + + length = strlen (str); + + find_another_bra: + + while ((offset < length) && (str[offset] != '(')) + offset++; + + if (offset >= length) + return(-1); + + if (! g_ascii_isdigit (str[++offset])) + goto find_another_bra; + + do + { + sum *= 10; + sum += str[offset] - '0'; + offset++; + } + while ((offset < length) && (g_ascii_isdigit (str[offset]))); + + if (length - offset <= 2) + return(-3); + + if ((g_ascii_toupper (str[offset]) != 'M') || + (g_ascii_toupper (str[offset + 1]) != 'S')) + return -4; + + return sum; +} + + +static gint +parse_disposal_tag (const gchar *str) +{ + gint offset = 0; + gint length; + + length = strlen (str); + + while ((offset + 9) <= length) + { + if (strncmp (&str[offset], "(combine)", 9) == 0) + return 0x01; + + if (strncmp (&str[offset], "(replace)", 9) == 0) + return 0x02 ; + + offset++; + } + + return gsvals.default_dispose; +} + + +static GimpPDBStatusType +sanity_check (GFile *file, + gint32 *image_ID, + GimpRunMode run_mode, + GError **error) +{ + gint32 *layers; + gint nlayers; + gint image_width; + gint image_height; + gint i; + + image_width = gimp_image_width (*image_ID); + image_height = gimp_image_height (*image_ID); + + if (image_width > G_MAXUSHORT || image_height > G_MAXUSHORT) + { + g_set_error (error, 0, 0, + _("Unable to export '%s'. " + "The GIF file format does not support images that are " + "more than %d pixels wide or tall."), + gimp_file_get_utf8_name (file), G_MAXUSHORT); + + return GIMP_PDB_EXECUTION_ERROR; + } + + /*** Iterate through the layers to make sure they're all ***/ + /*** within the bounds of the image ***/ + + *image_ID = gimp_image_duplicate (*image_ID); + layers = gimp_image_get_layers (*image_ID, &nlayers); + + for (i = 0; i < nlayers; i++) + { + gint offset_x; + gint offset_y; + + gimp_drawable_offsets (layers[i], &offset_x, &offset_y); + + if (offset_x < 0 || + offset_y < 0 || + offset_x + gimp_drawable_width (layers[i]) > image_width || + offset_y + gimp_drawable_height (layers[i]) > image_height) + { + g_free (layers); + + /* Image has illegal bounds - ask the user what it wants to do */ + + /* Do the crop if we can't talk to the user, or if we asked + * the user and they said yes. + */ + if ((run_mode == GIMP_RUN_NONINTERACTIVE) || bad_bounds_dialog ()) + { + gimp_image_crop (*image_ID, image_width, image_height, 0, 0); + return GIMP_PDB_SUCCESS; + } + else + { + gimp_image_delete (*image_ID); + return GIMP_PDB_CANCEL; + } + } + } + + g_free (layers); + + return GIMP_PDB_SUCCESS; +} + + +static gboolean +save_image (GFile *file, + gint32 image_ID, + gint32 drawable_ID, + gint32 orig_image_ID, + GError **error) +{ + GeglBuffer *buffer; + GimpImageType drawable_type; + const Babl *format = NULL; + GOutputStream *output; + gint Red[MAXCOLORS]; + gint Green[MAXCOLORS]; + gint Blue[MAXCOLORS]; + guchar *cmap; + guint rows, cols; + gint BitsPerPixel; + gint liberalBPP = 0; + gint useBPP = 0; + gint colors; + gint i; + gint transparent; + gint offset_x, offset_y; + + gint32 *layers; + gint nlayers; + + gboolean is_gif89 = FALSE; + + gint Delay89; + gint Disposal; + gchar *layer_name; + + GimpRGB background; + guchar bgred, bggreen, bgblue; + guchar bgindex = 0; + guint best_error = 0xFFFFFFFF; + + /* Save the comment back to the ImageID, if appropriate */ + if (globalcomment != NULL && comment_was_edited) + { + GimpParasite *parasite; + + parasite = gimp_parasite_new ("gimp-comment", + GIMP_PARASITE_PERSISTENT, + strlen (globalcomment) + 1, + (gpointer) globalcomment); + gimp_image_attach_parasite (orig_image_ID, parasite); + gimp_parasite_free (parasite); + } + + /* The GIF spec says 7bit ASCII for the comment block. */ + if (gsvals.save_comment && globalcomment) + { + const gchar *c = globalcomment; + gint len; + + for (len = strlen (c); len; c++, len--) + { + if ((guchar) *c > 127) + { + g_message (_("The GIF format only supports comments in " + "7bit ASCII encoding. No comment is saved.")); + + g_free (globalcomment); + globalcomment = NULL; + + break; + } + } + } + + /* get a list of layers for this image_ID */ + layers = gimp_image_get_layers (image_ID, &nlayers); + + drawable_type = gimp_drawable_type (layers[0]); + + /* If the image has multiple layers (i.e. will be animated), a + * comment, or transparency, then it must be encoded as a GIF89a + * file, not a vanilla GIF87a. + */ + if (nlayers > 1) + { + is_gif89 = TRUE; + + /* Layers can be with or without alpha channel. Make sure we set + * alpha if there is at least one layer with alpha channel. */ + if (drawable_type == GIMP_GRAY_IMAGE || + drawable_type == GIMP_INDEXED_IMAGE) + { + for (i = nlayers - 1; i >= 0; i--) + { + GimpImageType dr_type = gimp_drawable_type (layers[i]); + + if (dr_type == GIMP_GRAYA_IMAGE || + dr_type == GIMP_INDEXEDA_IMAGE) + { + drawable_type = dr_type; + break; + } + } + } + } + + if (gsvals.save_comment) + is_gif89 = TRUE; + + switch (drawable_type) + { + case GIMP_INDEXEDA_IMAGE: + is_gif89 = TRUE; + case GIMP_INDEXED_IMAGE: + cmap = gimp_image_get_colormap (image_ID, &colors); + + gimp_context_get_background (&background); + gimp_rgb_get_uchar (&background, &bgred, &bggreen, &bgblue); + + for (i = 0; i < colors; i++) + { + Red[i] = *cmap++; + Green[i] = *cmap++; + Blue[i] = *cmap++; + } + for ( ; i < 256; i++) + { + Red[i] = bgred; + Green[i] = bggreen; + Blue[i] = bgblue; + } + break; + case GIMP_GRAYA_IMAGE: + is_gif89 = TRUE; + case GIMP_GRAY_IMAGE: + colors = 256; /* FIXME: Not ideal. */ + for ( i = 0; i < 256; i++) + { + Red[i] = Green[i] = Blue[i] = i; + } + break; + + default: + g_message (_("Cannot export RGB color images. Convert to " + "indexed color or grayscale first.")); + return FALSE; + } + + + /* find earliest index in palette which is closest to the background + * color, and ATTEMPT to use that as the GIF's default background + * color. + */ + for (i = 255; i >= 0; --i) + { + guint local_error = 0; + + local_error += (Red[i] - bgred) * (Red[i] - bgred); + local_error += (Green[i] - bggreen) * (Green[i] - bggreen); + local_error += (Blue[i] - bgblue) * (Blue[i] - bgblue); + + if (local_error <= best_error) + { + bgindex = i; + best_error = local_error; + } + } + + + /* init the progress meter */ + gimp_progress_init_printf (_("Exporting '%s'"), + gimp_file_get_utf8_name (file)); + + + /* open the destination file for writing */ + output = G_OUTPUT_STREAM (g_file_replace (file, + NULL, FALSE, G_FILE_CREATE_NONE, + NULL, error)); + if (output) + { + GDataOutputStream *data_output; + + data_output = g_data_output_stream_new (output); + g_object_unref (output); + + g_data_output_stream_set_byte_order (data_output, + G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN); + + output = G_OUTPUT_STREAM (data_output); + } + else + { + return FALSE; + } + + + /* write the GIFheader */ + + if (colors < 256) + { + /* we keep track of how many bits we promised to have in + * liberalBPP, so that we don't accidentally come under this + * when doing clever transparency stuff where we can re-use + * wasted indices. + */ + liberalBPP = BitsPerPixel = + colors_to_bpp (colors + ((drawable_type==GIMP_INDEXEDA_IMAGE) ? 1 : 0)); + } + else + { + liberalBPP = BitsPerPixel = + colors_to_bpp (256); + + if (drawable_type == GIMP_INDEXEDA_IMAGE) + { + g_printerr ("GIF: Too many colors?\n"); + } + } + + cols = gimp_image_width (image_ID); + rows = gimp_image_height (image_ID); + Interlace = gsvals.interlace; + if (! gif_encode_header (output, is_gif89, cols, rows, bgindex, + BitsPerPixel, Red, Green, Blue, get_pixel, + error)) + return FALSE; + + + /* If the image has multiple layers it'll be made into an animated + * GIF, so write out the infinite-looping extension + */ + if ((nlayers > 1) && (gsvals.loop)) + if (! gif_encode_loop_ext (output, 0, error)) + return FALSE; + + /* Write comment extension - mustn't be written before the looping ext. */ + if (gsvals.save_comment && globalcomment) + { + if (! gif_encode_comment_ext (output, globalcomment, error)) + return FALSE; + } + + + /*** Now for each layer in the image, save an image in a compound GIF ***/ + /************************************************************************/ + + cur_progress = 0; + max_progress = nlayers * rows; + + for (i = nlayers - 1; i >= 0; i--, cur_progress = (nlayers - i) * rows) + { + drawable_type = gimp_drawable_type (layers[i]); + if (drawable_type == GIMP_GRAYA_IMAGE) + { + format = babl_format ("Y'A u8"); + } + else if (drawable_type == GIMP_GRAY_IMAGE) + { + format = babl_format ("Y' u8"); + } + buffer = gimp_drawable_get_buffer (layers[i]); + gimp_drawable_offsets (layers[i], &offset_x, &offset_y); + cols = gimp_drawable_width (layers[i]); + rows = gimp_drawable_height (layers[i]); + rowstride = cols; + + pixels = g_new (guchar, (cols * rows * + (((drawable_type == GIMP_INDEXEDA_IMAGE) || + (drawable_type == GIMP_GRAYA_IMAGE)) ? 2 : 1))); + + gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, cols, rows), 1.0, + format, pixels, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + /* sort out whether we need to do transparency jiggery-pokery */ + if ((drawable_type == GIMP_INDEXEDA_IMAGE) || + (drawable_type == GIMP_GRAYA_IMAGE)) + { + /* Try to find an entry which isn't actually used in the + * image, for a transparency index. + */ + + transparent = + find_unused_ia_color (pixels, + cols * rows, + bpp_to_colors (colors_to_bpp (colors)), + &colors); + + special_flatten_indexed_alpha (pixels, + transparent, + cols * rows); + } + else + { + transparent = -1; + } + + BitsPerPixel = colors_to_bpp (colors); + + if (BitsPerPixel != liberalBPP) + { + /* We were able to re-use an index within the existing + * bitspace, whereas the estimate in the header was + * pessimistic but still needs to be upheld... + */ +#ifdef GIFDEBUG + static gboolean onceonly = FALSE; + + if (! onceonly) + { + g_warning ("Promised %d bpp, pondered writing chunk with %d bpp!", + liberalBPP, BitsPerPixel); + onceonly = TRUE; + } +#endif + } + + useBPP = (BitsPerPixel > liberalBPP) ? BitsPerPixel : liberalBPP; + + if (is_gif89) + { + if (i > 0 && ! gsvals.always_use_default_dispose) + { + layer_name = gimp_item_get_name (layers[i - 1]); + Disposal = parse_disposal_tag (layer_name); + g_free (layer_name); + } + else + { + Disposal = gsvals.default_dispose; + } + + layer_name = gimp_item_get_name (layers[i]); + Delay89 = parse_ms_tag (layer_name); + g_free (layer_name); + + if (Delay89 < 0 || gsvals.always_use_default_delay) + Delay89 = (gsvals.default_delay + 5) / 10; + else + Delay89 = (Delay89 + 5) / 10; + + /* don't allow a CPU-sucking completely 0-delay looping anim */ + if ((nlayers > 1) && gsvals.loop && (Delay89 == 0)) + { + static gboolean onceonly = FALSE; + + if (! onceonly) + { + g_message (_("Delay inserted to prevent evil " + "CPU-sucking animation.")); + onceonly = TRUE; + } + + Delay89 = 1; + } + + if (! gif_encode_graphic_control_ext (output, + Disposal, Delay89, nlayers, + cols, rows, + transparent, + useBPP, + get_pixel, + error)) + return FALSE; + } + + if (! gif_encode_image_data (output, cols, rows, + (rows > 4) ? gsvals.interlace : 0, + useBPP, + get_pixel, + offset_x, offset_y, + error)) + return FALSE; + + gimp_progress_update (1.0); + + g_object_unref (buffer); + + g_free (pixels); + } + + g_free (layers); + + if (! gif_encode_close (output, error)) + return FALSE; + + return TRUE; +} + +static gboolean +bad_bounds_dialog (void) +{ + GtkWidget *dialog; + gboolean crop; + + dialog = gtk_message_dialog_new (NULL, 0, + GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, + _("The image you are trying to export as a " + "GIF contains layers which extend beyond " + "the actual borders of the image.")); + + gtk_dialog_add_buttons (GTK_DIALOG (dialog), + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("Cr_op"), GTK_RESPONSE_OK, + NULL); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + + gimp_window_set_transient (GTK_WINDOW (dialog)); + + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("The GIF file format does not " + "allow this. You may choose " + "whether to crop all of the " + "layers to the image borders, " + "or cancel this export.")); + + gtk_widget_show (dialog); + + crop = (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK); + + gtk_widget_destroy (dialog); + + return crop; +} + +static GtkWidget * +file_gif_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 GtkWidget * +file_gif_spin_button_int_init (GtkBuilder *builder, + const gchar *name, + int initial_value, + int *value_pointer) +{ + GtkWidget *spin_button = NULL; + GtkAdjustment *adjustment = NULL; + + spin_button = GTK_WIDGET (gtk_builder_get_object (builder, name)); + + adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin_button)); + gtk_adjustment_set_value (adjustment, initial_value); + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gimp_int_adjustment_update), + value_pointer); + + return spin_button; +} + +static void +file_gif_combo_box_int_update_value (GtkComboBox *combo, + gint *value) +{ + GtkTreeIter iter; + + if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) + { + gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (combo)), + &iter, + DISPOSE_STORE_VALUE_COLUMN, value, + -1); + } +} + +static GtkWidget * +file_gif_combo_box_int_init (GtkBuilder *builder, + const gchar *name, + int initial_value, + int *value_pointer, + const gchar *first_label, + gint first_value, + ...) +{ + GtkWidget *combo = NULL; + GtkListStore *store = NULL; + const gchar *label = NULL; + gint value = 0; + GtkTreeIter iter = { 0, }; + va_list values; + + combo = GTK_WIDGET (gtk_builder_get_object (builder, name)); + store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo))); + + /* Populate */ + va_start (values, first_value); + for (label = first_label, value = first_value; + label; + label = va_arg (values, const gchar *), value = va_arg (values, gint)) + { + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + DISPOSE_STORE_VALUE_COLUMN, value, + DISPOSE_STORE_LABEL_COLUMN, label, + -1); + } + va_end (values); + + /* Set initial value */ + gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), + &iter, + NULL, + initial_value); + gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter); + + /* Arrange update of value */ + g_signal_connect (combo, "changed", + G_CALLBACK (file_gif_combo_box_int_update_value), + value_pointer); + + return combo; +} + +static gboolean +save_dialog (gint32 image_ID) +{ + GtkBuilder *builder = NULL; + gchar *ui_file = NULL; + GError *error = NULL; + GtkWidget *dialog; + GtkWidget *text_view; + GtkTextBuffer *text_buffer; + GtkWidget *toggle; + GtkWidget *frame; + GimpParasite *GIF2_CMNT; + gint32 nlayers; + gboolean animation_supported = FALSE; + gboolean run; + + g_free (gimp_image_get_layers (image_ID, &nlayers)); + animation_supported = nlayers > 1; + + dialog = gimp_export_dialog_new (_("GIF"), PLUG_IN_BINARY, SAVE_PROC); + + /* GtkBuilder init */ + builder = gtk_builder_new (); + ui_file = g_build_filename (gimp_data_directory (), + "ui/plug-ins/plug-in-file-gif.ui", + NULL); + if (! gtk_builder_add_from_file (builder, ui_file, &error)) + g_printerr (_("Error loading UI file '%s':\n%s"), + ui_file, error ? error->message : "???"); + g_free (ui_file); + + /* Main vbox */ + gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)), + GTK_WIDGET (gtk_builder_get_object (builder, "main-vbox")), + TRUE, TRUE, 0); + + /* regular gif parameter settings */ + file_gif_toggle_button_init (builder, "interlace", + gsvals.interlace, &gsvals.interlace); + file_gif_toggle_button_init (builder, "save-comment", + gsvals.save_comment, &gsvals.save_comment); + file_gif_toggle_button_init (builder, "as-animation", + gsvals.as_animation, &gsvals.as_animation); + + text_view = GTK_WIDGET (gtk_builder_get_object (builder, "comment")); + text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); + + if (globalcomment) + g_free (globalcomment); + + GIF2_CMNT = gimp_image_get_parasite (image_ID, "gimp-comment"); + if (GIF2_CMNT) + { + globalcomment = g_strndup (gimp_parasite_data (GIF2_CMNT), + gimp_parasite_data_size (GIF2_CMNT)); + gimp_parasite_free (GIF2_CMNT); + } + else + { + globalcomment = gimp_get_default_comment (); + } + + if (globalcomment) + gtk_text_buffer_set_text (text_buffer, globalcomment, -1); + + g_signal_connect (text_buffer, "changed", + G_CALLBACK (comment_entry_callback), + NULL); + + /* additional animated gif parameter settings */ + file_gif_toggle_button_init (builder, "loop-forever", + gsvals.loop, &gsvals.loop); + + /* default_delay entry field */ + file_gif_spin_button_int_init (builder, "delay-spin", + gsvals.default_delay, &gsvals.default_delay); + + /* Disposal selector */ + file_gif_combo_box_int_init (builder, "dispose-combo", + gsvals.default_dispose, &gsvals.default_dispose, + _("I don't care"), + DISPOSE_UNSPECIFIED, + _("Cumulative layers (combine)"), + DISPOSE_COMBINE, + _("One frame per layer (replace)"), + DISPOSE_REPLACE, + NULL); + + /* The "Always use default values" toggles */ + file_gif_toggle_button_init (builder, "use-default-delay", + gsvals.always_use_default_delay, + &gsvals.always_use_default_delay); + file_gif_toggle_button_init (builder, "use-default-dispose", + gsvals.always_use_default_dispose, + &gsvals.always_use_default_dispose); + + frame = GTK_WIDGET (gtk_builder_get_object (builder, "animation-frame")); + toggle = GTK_WIDGET (gtk_builder_get_object (builder, "as-animation")); + if (! animation_supported) + { + gimp_help_set_help_data (toggle, + _("You can only export as animation when the " + "image has more than one layer. The image " + "you are trying to export only has one " + "layer."), + NULL); + /* Make sure the checkbox is not checked from session data. */ + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE); + } + gtk_widget_set_sensitive (toggle, animation_supported); + + g_object_bind_property (toggle, "active", + frame, "sensitive", + G_BINDING_SYNC_CREATE); + + gtk_widget_show (dialog); + + run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); + + gtk_widget_destroy (dialog); + + return run; +} + +static int +colors_to_bpp (gint colors) +{ + gint bpp; + + if (colors <= 2) + bpp = 1; + else if (colors <= 4) + bpp = 2; + else if (colors <= 8) + bpp = 3; + else if (colors <= 16) + bpp = 4; + else if (colors <= 32) + bpp = 5; + else if (colors <= 64) + bpp = 6; + else if (colors <= 128) + bpp = 7; + else if (colors <= 256) + bpp = 8; + else + { + g_warning ("GIF: colors_to_bpp - Eep! too many colors: %d\n", colors); + return 8; + } + + return bpp; +} + +static int +bpp_to_colors (gint bpp) +{ + gint colors; + + if (bpp > 8) + { + g_warning ("GIF: bpp_to_colors - Eep! bpp==%d !\n", bpp); + return 256; + } + + colors = 1 << bpp; + + return colors; +} + + + +static gint +get_pixel (gint x, + gint y) +{ + return *(pixels + (rowstride * (long) y) + (long) x); +} + + +/***************************************************************************** + * + * GIFENCODE.C - GIF Image compression interface + * + * GIFEncode( FName, GHeight, GWidth, GInterlace, Background, Transparent, + * BitsPerPixel, Red, Green, Blue, get_pixel ) + * + *****************************************************************************/ + +static gint Width, Height; +static gint curx, cury; +static glong CountDown; +static gint Pass = 0; + +/* + * Bump the 'curx' and 'cury' to point to the next pixel + */ +static void +bump_pixel (void) +{ + /* + * Bump the current X position + */ + curx++; + + /* + * If we are at the end of a scan line, set curx back to the beginning + * If we are interlaced, bump the cury to the appropriate spot, + * otherwise, just increment it. + */ + if (curx == Width) + { + cur_progress++; + + if ((cur_progress % 20) == 0) + gimp_progress_update ((gdouble) cur_progress / (gdouble) max_progress); + + curx = 0; + + if (! Interlace) + ++cury; + else + { + switch (Pass) + { + + case 0: + cury += 8; + if (cury >= Height) + { + Pass++; + cury = 4; + } + break; + + case 1: + cury += 8; + if (cury >= Height) + { + Pass++; + cury = 2; + } + break; + + case 2: + cury += 4; + if (cury >= Height) + { + Pass++; + cury = 1; + } + break; + + case 3: + cury += 2; + break; + } + } + } +} + +/* + * Return the next pixel from the image + */ +static gint +gif_next_pixel (ifunptr getpixel) +{ + gint r; + + if (CountDown == 0) + return EOF; + + --CountDown; + + r = (*getpixel) (curx, cury); + + bump_pixel (); + + return r; +} + +/* public */ + +static gboolean +gif_encode_header (GOutputStream *output, + gboolean gif89, + gint GWidth, + gint GHeight, + gint Background, + gint BitsPerPixel, + gint Red[], + gint Green[], + gint Blue[], + ifunptr get_pixel, + GError **error) +{ + gint B; + gint RWidth, RHeight; + gint Resolution; + gint ColorMapSize; + gint i; + + ColorMapSize = 1 << BitsPerPixel; + + RWidth = Width = GWidth; + RHeight = Height = GHeight; + + Resolution = BitsPerPixel; + + /* + * Calculate number of bits we are expecting + */ + CountDown = (long) Width *(long) Height; + + /* + * Indicate which pass we are on (if interlace) + */ + Pass = 0; + + /* + * Set up the current x and y position + */ + curx = cury = 0; + + /* + * Write the Magic header + */ + if (! put_string (output, gif89 ? "GIF89a" : "GIF87a", error)) + return FALSE; + + /* + * Write out the screen width and height + */ + if (! put_word (output, RWidth, error) || + ! put_word (output, RHeight, error)) + return FALSE; + + /* + * Indicate that there is a global color map + */ + B = 0x80; /* Yes, there is a color map */ + + /* + * OR in the resolution + */ + B |= (Resolution - 1) << 5; + + /* + * OR in the Bits per Pixel + */ + B |= (BitsPerPixel - 1); + + /* + * Write it out + */ + if (! put_byte (output, B, error)) + return FALSE; + + /* + * Write out the Background color + */ + if (! put_byte (output, Background, error)) + return FALSE; + + /* + * Byte of 0's (future expansion) + */ + if (! put_byte (output, 0, error)) + return FALSE; + + /* + * Write out the Global Color Map + */ + for (i = 0; i < ColorMapSize; i++) + { + if (! put_byte (output, Red[i], error) || + ! put_byte (output, Green[i], error) || + ! put_byte (output, Blue[i], error)) + return FALSE; + } + + return TRUE; +} + + +static gboolean +gif_encode_graphic_control_ext (GOutputStream *output, + int Disposal, + int Delay89, + int NumFramesInImage, + int GWidth, + int GHeight, + int Transparent, + int BitsPerPixel, + ifunptr get_pixel, + GError **error) +{ + Width = GWidth; + Height = GHeight; + + /* + * Calculate number of bits we are expecting + */ + CountDown = (long) Width *(long) Height; + + /* + * Indicate which pass we are on (if interlace) + */ + Pass = 0; + + /* + * Set up the current x and y position + */ + curx = cury = 0; + + /* + * Write out extension for transparent color index, if necessary. + */ + if ( (Transparent >= 0) || (NumFramesInImage > 1) ) + { + /* Extension Introducer - fixed. */ + if (! put_byte (output, '!', error)) + return FALSE; + + /* Graphic Control Label - fixed. */ + if (! put_byte (output, 0xf9, error)) + return FALSE; + + /* Block Size - fixed. */ + if (! put_byte (output, 4, error)) + return FALSE; + + /* Packed Fields - XXXdddut (d=disposal, u=userInput, t=transFlag) */ + /* s8421 */ + if (! put_byte (output, + ((Transparent >= 0) ? 0x01 : 0x00) /* TRANSPARENCY */ + + /* DISPOSAL */ + | ((NumFramesInImage > 1) ? (Disposal << 2) : 0x00 ), + /* 0x03 or 0x01 build frames cumulatively */ + /* 0x02 clears frame before drawing */ + /* 0x00 'don't care' */ + + error)) + return FALSE; + + if (! put_word (output, Delay89, error)) + return FALSE; + + if (! put_byte (output, Transparent, error) || + ! put_byte (output, 0, error)) + return FALSE; + } + + return TRUE; +} + + +static gboolean +gif_encode_image_data (GOutputStream *output, + int GWidth, + int GHeight, + int GInterlace, + int BitsPerPixel, + ifunptr get_pixel, + gint offset_x, + gint offset_y, + GError **error) +{ + gint LeftOfs, TopOfs; + gint InitCodeSize; + + Interlace = GInterlace; + + Width = GWidth; + Height = GHeight; + LeftOfs = (gint) offset_x; + TopOfs = (gint) offset_y; + + /* + * Calculate number of bits we are expecting + */ + CountDown = (long) Width * (long) Height; + + /* + * Indicate which pass we are on (if interlace) + */ + Pass = 0; + + /* + * The initial code size + */ + if (BitsPerPixel <= 1) + InitCodeSize = 2; + else + InitCodeSize = BitsPerPixel; + + /* + * Set up the current x and y position + */ + curx = cury = 0; + + /* + * Write an Image separator + */ + if (! put_byte (output, ',', error)) + return FALSE; + + /* + * Write the Image header + */ + + if (! put_word (output, LeftOfs, error) || + ! put_word (output, TopOfs, error) || + ! put_word (output, Width, error) || + ! put_word (output, Height, error)) + return FALSE; + + /* + * Write out whether or not the image is interlaced + */ + if (Interlace) + { + if (! put_byte (output, 0x40, error)) + return FALSE; + } + else + { + if (! put_byte (output, 0x00, error)) + return FALSE; + } + + /* + * Write out the initial code size + */ + if (! put_byte (output, InitCodeSize, error)) + return FALSE; + + /* + * Go and actually compress the data + */ + if (! compress (output, InitCodeSize + 1, get_pixel, error)) + return FALSE; + + /* + * Write out a Zero-length packet (to end the series) + */ + if (! put_byte (output, 0, error)) + return FALSE; + +#if 0 + /***************************/ + Interlace = GInterlace; + Width = GWidth; + Height = GHeight; + LeftOfs = TopOfs = 0; + + CountDown = (long) Width *(long) Height; + Pass = 0; + /* + * The initial code size + */ + if (BitsPerPixel <= 1) + InitCodeSize = 2; + else + InitCodeSize = BitsPerPixel; + /* + * Set up the current x and y position + */ + curx = cury = 0; +#endif + + return TRUE; +} + + +static gboolean +gif_encode_close (GOutputStream *output, + GError **error) +{ + /* + * Write the GIF file terminator + */ + if (! put_byte (output, ';', error)) + return FALSE; + + /* + * And close the file + */ + return g_output_stream_close (output, NULL, error); +} + + +static gboolean +gif_encode_loop_ext (GOutputStream *output, + guint num_loops, + GError **error) +{ + return (put_byte (output, 0x21, error) && + put_byte (output, 0xff, error) && + put_byte (output, 0x0b, error) && + put_string (output, "NETSCAPE2.0", error) && + put_byte (output, 0x03, error) && + put_byte (output, 0x01, error) && + put_word (output, num_loops, error) && + put_byte (output, 0x00, error)); + + /* NOTE: num_loops == 0 means 'loop infinitely' */ +} + + +static gboolean +gif_encode_comment_ext (GOutputStream *output, + const gchar *comment, + GError **error) +{ + if (!comment || !*comment) + return TRUE; + + if (strlen (comment) > 240) + { + g_printerr ("GIF: warning:" + "comment too large - comment block not written.\n"); + return TRUE; + } + + return (put_byte (output, 0x21, error) && + put_byte (output, 0xfe, error) && + put_byte (output, strlen (comment), error) && + put_string (output, comment, error) && + put_byte (output, 0x00, error)); +} + + +/* + * Write stuff to the GIF file + */ +static gboolean +put_byte (GOutputStream *output, + guchar b, + GError **error) +{ + return g_data_output_stream_put_byte (G_DATA_OUTPUT_STREAM (output), + b, NULL, error); +} + +static gboolean +put_word (GOutputStream *output, + gint w, + GError **error) +{ + return g_data_output_stream_put_int16 (G_DATA_OUTPUT_STREAM (output), + w, NULL, error); +} + +static gboolean +put_string (GOutputStream *output, + const gchar *s, + GError **error) +{ + return g_data_output_stream_put_string (G_DATA_OUTPUT_STREAM (output), + s, NULL, error); +} + + +/*************************************************************************** + * + * GIFCOMPR.C - GIF Image compression routines + * + * Lempel-Ziv compression based on 'compress'. GIF modifications by + * David Rowley (mgardi@watdcsu.waterloo.edu) + * + ***************************************************************************/ + +/* + * General DEFINEs + */ + +#define GIF_BITS 12 + +#define HSIZE 5003 /* 80% occupancy */ + +/* + * GIF Image compression - modified 'compress' + * + * Based on: compress.c - File compression ala IEEE Computer, June 1984. + * + * By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas) + * Jim McKie (decvax!mcvax!jim) + * Steve Davies (decvax!vax135!petsd!peora!srd) + * Ken Turkowski (decvax!decwrl!turtlevax!ken) + * James A. Woods (decvax!ihnp4!ames!jaw) + * Joe Orost (decvax!vax135!petsd!joe) + * + */ + +static gint n_bits; /* number of bits/code */ +static gint maxbits = GIF_BITS; /* user settable max # bits/code */ +static gint maxcode; /* maximum code, given n_bits */ +static gint maxmaxcode = (gint) 1 << GIF_BITS; /* should NEVER generate this code */ +#ifdef COMPATIBLE /* But wrong! */ +#define MAXCODE(Mn_bits) ((gint) 1 << (Mn_bits) - 1) +#else /*COMPATIBLE */ +#define MAXCODE(Mn_bits) (((gint) 1 << (Mn_bits)) - 1) +#endif /*COMPATIBLE */ + +static glong htab[HSIZE]; +static gushort codetab[HSIZE]; +#define HashTabOf(i) htab[i] +#define CodeTabOf(i) codetab[i] + +static const gint hsize = HSIZE; /* the original reason for this being + variable was "for dynamic table sizing", + but since it was never actually changed + I made it const --Adam. */ + +static gint free_ent = 0; /* first unused entry */ + +/* + * block compression parameters -- after all codes are used up, + * and compression rate changes, start over. + */ +static gint clear_flg = 0; + +static gint offset; +static glong in_count = 1; /* length of input */ +static glong out_count = 0; /* # of codes output (for debugging) */ + +/* + * compress stdin to stdout + * + * Algorithm: use open addressing double hashing (no chaining) on the + * prefix code / next character combination. We do a variant of Knuth's + * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime + * secondary probe. Here, the modular division first probe is gives way + * to a faster exclusive-or manipulation. Also do block compression with + * an adaptive reset, whereby the code table is cleared when the compression + * ratio decreases, but after the table fills. The variable-length output + * codes are re-sized at this point, and a special CLEAR code is generated + * for the decompressor. Late addition: construct the table according to + * file size for noticeable speed improvement on small files. Please direct + * questions about this implementation to ames!jaw. + */ + +static gint g_init_bits; + +static gint ClearCode; +static gint EOFCode; + +static gulong cur_accum; +static gint cur_bits; + +static gulong masks[] = +{ + 0x0000, 0x0001, 0x0003, 0x0007, + 0x000F, 0x001F, 0x003F, 0x007F, + 0x00FF, 0x01FF, 0x03FF, 0x07FF, + 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, + 0xFFFF +}; + + +static gboolean +compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error) +{ + if (FALSE) + return no_compress (output, init_bits, ReadValue, error); + else if (FALSE) + return rle_compress (output, init_bits, ReadValue, error); + else + return normal_compress (output, init_bits, ReadValue, error); +} + +static gboolean +no_compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error) +{ + glong fcode; + gint i /* = 0 */ ; + gint c; + gint ent; + gint hsize_reg; + gint hshift; + + /* + * Set up the globals: g_init_bits - initial number of bits + */ + g_init_bits = init_bits; + + cur_bits = 0; + cur_accum = 0; + + /* + * Set up the necessary values + */ + offset = 0; + out_count = 0; + clear_flg = 0; + in_count = 1; + + ClearCode = (1 << (init_bits - 1)); + EOFCode = ClearCode + 1; + free_ent = ClearCode + 2; + + + /* Had some problems here... should be okay now. --Adam */ + n_bits = g_init_bits; + maxcode = MAXCODE (n_bits); + + + char_init(); + + ent = gif_next_pixel (ReadValue); + + hshift = 0; + for (fcode = (long) hsize; fcode < 65536L; fcode *= 2L) + ++hshift; + hshift = 8 - hshift; /* set hash code range bound */ + + hsize_reg = hsize; + cl_hash ((glong) hsize_reg); /* clear hash table */ + + if (! output_code (output, (gint) ClearCode, error)) + return FALSE; + + while ((c = gif_next_pixel (ReadValue)) != EOF) + { + ++in_count; + + fcode = (long) (((long) c << maxbits) + ent); + i = (((gint) c << hshift) ^ ent); /* xor hashing */ + + if (! output_code (output, (gint) ent, error)) + return FALSE; + + ++out_count; + ent = c; + + if (free_ent < maxmaxcode) + { + CodeTabOf (i) = free_ent++; /* code -> hashtable */ + HashTabOf (i) = fcode; + } + else + { + if (! cl_block (output, error)) + return FALSE; + } + } + + /* + * Put out the final code. + */ + if (! output_code (output, (gint) ent, error)) + return FALSE; + + ++out_count; + + if (! output_code (output, (gint) EOFCode, error)) + return FALSE; + + return TRUE; +} + +static gboolean +rle_compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error) +{ + glong fcode; + gint i /* = 0 */ ; + gint c, last; + gint ent; + gint disp; + gint hsize_reg; + gint hshift; + + /* + * Set up the globals: g_init_bits - initial number of bits + */ + g_init_bits = init_bits; + + cur_bits = 0; + cur_accum = 0; + + /* + * Set up the necessary values + */ + offset = 0; + out_count = 0; + clear_flg = 0; + in_count = 1; + + ClearCode = (1 << (init_bits - 1)); + EOFCode = ClearCode + 1; + free_ent = ClearCode + 2; + + + /* Had some problems here... should be okay now. --Adam */ + n_bits = g_init_bits; + maxcode = MAXCODE (n_bits); + + + char_init (); + + last = ent = gif_next_pixel (ReadValue); + + hshift = 0; + for (fcode = (long) hsize; fcode < 65536L; fcode *= 2L) + ++hshift; + hshift = 8 - hshift; /* set hash code range bound */ + + hsize_reg = hsize; + cl_hash ((glong) hsize_reg); /* clear hash table */ + + if (! output_code (output, (gint) ClearCode, error)) + return FALSE; + + + while ((c = gif_next_pixel (ReadValue)) != EOF) + { + ++in_count; + + fcode = (long) (((long) c << maxbits) + ent); + i = (((gint) c << hshift) ^ ent); /* xor hashing */ + + + if (last == c) { + if (HashTabOf (i) == fcode) + { + ent = CodeTabOf (i); + continue; + } + else if ((long) HashTabOf (i) < 0) /* empty slot */ + goto nomatch; + disp = hsize_reg - i; /* secondary hash (after G. Knott) */ + if (i == 0) + disp = 1; + probe: + if ((i -= disp) < 0) + i += hsize_reg; + + if (HashTabOf (i) == fcode) + { + ent = CodeTabOf (i); + continue; + } + if ((long) HashTabOf (i) > 0) + goto probe; + } + nomatch: + if (! output_code (output, (gint) ent, error)) + return FALSE; + + ++out_count; + last = ent = c; + if (free_ent < maxmaxcode) + { + CodeTabOf (i) = free_ent++; /* code -> hashtable */ + HashTabOf (i) = fcode; + } + else + { + if (! cl_block (output, error)) + return FALSE; + } + } + + /* + * Put out the final code. + */ + if (! output_code (output, (gint) ent, error)) + return FALSE; + + ++out_count; + + if (! output_code (output, (gint) EOFCode, error)) + return FALSE; + + return TRUE; +} + +static gboolean +normal_compress (GOutputStream *output, + gint init_bits, + ifunptr ReadValue, + GError **error) +{ + glong fcode; + gint i /* = 0 */ ; + gint c; + gint ent; + gint disp; + gint hsize_reg; + gint hshift; + + /* + * Set up the globals: g_init_bits - initial number of bits + */ + g_init_bits = init_bits; + + cur_bits = 0; + cur_accum = 0; + + /* + * Set up the necessary values + */ + offset = 0; + out_count = 0; + clear_flg = 0; + in_count = 1; + + ClearCode = (1 << (init_bits - 1)); + EOFCode = ClearCode + 1; + free_ent = ClearCode + 2; + + + /* Had some problems here... should be okay now. --Adam */ + n_bits = g_init_bits; + maxcode = MAXCODE (n_bits); + + + char_init(); + + ent = gif_next_pixel (ReadValue); + + hshift = 0; + for (fcode = (long) hsize; fcode < 65536L; fcode *= 2L) + ++hshift; + hshift = 8 - hshift; /* set hash code range bound */ + + hsize_reg = hsize; + cl_hash ((glong) hsize_reg); /* clear hash table */ + + if (! output_code (output, (gint) ClearCode, error)) + return FALSE; + + + while ((c = gif_next_pixel (ReadValue)) != EOF) + { + ++in_count; + + fcode = (long) (((long) c << maxbits) + ent); + i = (((gint) c << hshift) ^ ent); /* xor hashing */ + + if (HashTabOf (i) == fcode) + { + ent = CodeTabOf (i); + continue; + } + else if ((long) HashTabOf (i) < 0) /* empty slot */ + goto nomatch; + disp = hsize_reg - i; /* secondary hash (after G. Knott) */ + if (i == 0) + disp = 1; + probe: + if ((i -= disp) < 0) + i += hsize_reg; + + if (HashTabOf (i) == fcode) + { + ent = CodeTabOf (i); + continue; + } + if ((long) HashTabOf (i) > 0) + goto probe; + nomatch: + if (! output_code (output, (gint) ent, error)) + return FALSE; + + ++out_count; + ent = c; + if (free_ent < maxmaxcode) + { + CodeTabOf (i) = free_ent++; /* code -> hashtable */ + HashTabOf (i) = fcode; + } + else + { + if (! cl_block (output, error)) + return FALSE; + } + } + + /* + * Put out the final code. + */ + if (! output_code (output, (gint) ent, error)) + return FALSE; + + ++out_count; + + if (! output_code (output, (gint) EOFCode, error)) + return FALSE; + + return TRUE; +} + + +/***************************************************************** + * TAG( output ) + * + * Output the given code. + * Inputs: + * code: A n_bits-bit integer. If == -1, then EOF. This assumes + * that n_bits =< (long)wordsize - 1. + * Outputs: + * Outputs code to the file. + * Assumptions: + * Chars are 8 bits long. + * Algorithm: + * Maintain a GIF_BITS character long buffer (so that 8 codes will + * fit in it exactly). Use the VAX insv instruction to insert each + * code in turn. When the buffer fills up empty it and start over. + */ + +static gboolean +output_code (GOutputStream *output, + gint code, + GError **error) +{ + cur_accum &= masks[cur_bits]; + + if (cur_bits > 0) + cur_accum |= ((long) code << cur_bits); + else + cur_accum = code; + + cur_bits += n_bits; + + while (cur_bits >= 8) + { + if (! char_out (output, (guchar) (cur_accum & 0xff), error)) + return FALSE; + + cur_accum >>= 8; + cur_bits -= 8; + } + + /* + * If the next entry is going to be too big for the code size, + * then increase it, if possible. + */ + if (free_ent > maxcode || clear_flg) + { + if (clear_flg) + { + maxcode = MAXCODE (n_bits = g_init_bits); + clear_flg = 0; + } + else + { + ++n_bits; + if (n_bits == maxbits) + maxcode = maxmaxcode; + else + maxcode = MAXCODE (n_bits); + } + } + + if (code == EOFCode) + { + /* + * At EOF, write the rest of the buffer. + */ + while (cur_bits > 0) + { + if (! char_out (output, (guchar) (cur_accum & 0xff), error)) + return FALSE; + + cur_accum >>= 8; + cur_bits -= 8; + } + + if (! char_flush (output, error)) + return FALSE; + } + + return TRUE; +} + +/* + * Clear out the hash table + */ +static gboolean +cl_block (GOutputStream *output, + GError **error) /* table clear for block compress */ +{ + cl_hash ((glong) hsize); + free_ent = ClearCode + 2; + clear_flg = 1; + + return output_code (output, (gint) ClearCode, error); +} + +static void +cl_hash (glong hsize) /* reset code table */ +{ + glong *htab_p = htab + hsize; + + long i; + long m1 = -1; + + i = hsize - 16; + do + { /* might use Sys V memset(3) here */ + *(htab_p - 16) = m1; + *(htab_p - 15) = m1; + *(htab_p - 14) = m1; + *(htab_p - 13) = m1; + *(htab_p - 12) = m1; + *(htab_p - 11) = m1; + *(htab_p - 10) = m1; + *(htab_p - 9) = m1; + *(htab_p - 8) = m1; + *(htab_p - 7) = m1; + *(htab_p - 6) = m1; + *(htab_p - 5) = m1; + *(htab_p - 4) = m1; + *(htab_p - 3) = m1; + *(htab_p - 2) = m1; + *(htab_p - 1) = m1; + htab_p -= 16; + } + while ((i -= 16) >= 0); + + for (i += 16; i > 0; --i) + *--htab_p = m1; +} + + +/****************************************************************************** + * GIF Specific routines + ******************************************************************************/ + +/* + * Number of characters so far in this 'packet' + */ +static int a_count; + +/* + * Set up the 'byte output' routine + */ +static void +char_init (void) +{ + a_count = 0; +} + +/* + * Define the storage for the packet accumulator + */ +static char accum[256]; + +/* + * Add a character to the end of the current packet, and if it is 254 + * characters, flush the packet to disk. + */ +static gboolean +char_out (GOutputStream *output, + gint c, + GError **error) +{ + accum[a_count++] = c; + + if (a_count >= 254) + return char_flush (output, error); + + return TRUE; +} + +/* + * Flush the packet to disk, and reset the accumulator + */ +static gboolean +char_flush (GOutputStream *output, + GError **error) +{ + if (a_count > 0) + { + if (! put_byte (output, a_count, error)) + return FALSE; + + if (! g_output_stream_write_all (output, accum, a_count, + NULL, NULL, error)) + return FALSE; + + a_count = 0; + } + + return TRUE; +} + + +/* Save interface functions */ + +static void +comment_entry_callback (GtkTextBuffer *buffer) +{ + GtkTextIter start_iter; + GtkTextIter end_iter; + gchar *text; + + gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter); + text = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE); + +#define MAX_COMMENT 240 + + if (strlen (text) > MAX_COMMENT) + { + /* translators: the %d is *always* 240 here */ + g_message (_("The default comment is limited to %d characters."), + MAX_COMMENT); + + gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, MAX_COMMENT - 1); + gtk_text_buffer_get_end_iter (buffer, &end_iter); + + /* this calls us recursivaly, but in the else branch + */ + gtk_text_buffer_delete (buffer, &start_iter, &end_iter); + } + else + { + g_free (globalcomment); + globalcomment = g_strdup (text); + comment_was_edited = TRUE; + } + + g_free (text); +} |