diff options
Diffstat (limited to 'plug-ins/common/file-gif-load.c')
| -rw-r--r-- | plug-ins/common/file-gif-load.c | 1268 |
1 files changed, 1268 insertions, 0 deletions
diff --git a/plug-ins/common/file-gif-load.c b/plug-ins/common/file-gif-load.c new file mode 100644 index 0000000..c4f7a3f --- /dev/null +++ b/plug-ins/common/file-gif-load.c @@ -0,0 +1,1268 @@ +/* GIF loading file filter for GIMP 2.x + * +-------------------------------------------------------------------+ + * | Copyright Adam D. Moss, Peter Mattis, Spencer Kimball | + * +-------------------------------------------------------------------+ + * Version 1.50.4 - 2003/06/03 + * Adam D. Moss - <adam@gimp.org> <adam@foxbox.org> + */ + +/* Copyright notice for old GIF code from which this plugin was long ago */ +/* derived (David Koblas has kindly granted permission to relicense): */ +/* +-------------------------------------------------------------------+ */ +/* | Copyright 1990, 1991, 1993, David Koblas. (koblas@extra.com) | */ +/* +-------------------------------------------------------------------+ */ +/* Also... + * 'This filter uses code taken from the "giftopnm" and "ppmtogif" programs + * which are part of the "netpbm" package.' + */ +/* Additionally... + * "The Graphics Interchange Format(c) is the Copyright property of + * CompuServe Incorporated. GIF(sm) is a Service Mark property of + * CompuServe Incorporated." + */ + +/* + * REVISION HISTORY + * + * 2003/06/03 + * 1.50.04 - When initializing the LZW state, watch out for a completely + * bogus input_code_size [based on fix by Raphael Quinet] + * Also, fix a stupid old bug when clearing the code table between + * subimages. (Enables us to deal better with errors when the stream is + * corrupted pretty early in a subimage.) [adam] + * Minor-version-bump to distinguish between gimp1.2/1.4 branches. + * + * 2000/03/31 + * 1.00.03 - Just mildly more useful comments/messages concerning frame + * disposals. + * + * 1999/11/20 + * 1.00.02 - Fixed a couple of possible infinite loops where an + * error condition was not being checked. Also changed some g_message()s + * back to g_warning()s as they should be (don't get carried away with + * the user feedback fellahs, no-one wants to be told of every single + * corrupt byte and block in its own little window. :-( ). + * + * 1999/11/11 + * 1.00.01 - Fixed an uninitialized variable which has been around + * forever... thanks to jrb@redhat.com for noticing that there + * was a problem somewhere! + * + * 1999/03/20 + * 1.00.00 - GIF load-only code split from main GIF plugin. + * + * For previous revision information, please consult the comments + * in the 'gif' plugin. + */ + +/* + * TODO (more *'s means more important!) + * + * - PDB stuff for comments + * + * - Remove unused colormap entries for GRAYSCALE images. + */ + +#include "config.h" + +#include <errno.h> +#include <string.h> + +#include <glib/gstdio.h> + +#include <libgimp/gimp.h> + +#include "libgimp/stdplugins-intl.h" + + +#define LOAD_PROC "file-gif-load" +#define LOAD_THUMB_PROC "file-gif-load-thumb" + + +/* uncomment the line below for a little debugging info */ +/* #define GIFDEBUG yesplease */ + + +/* 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 gint32 load_image (const gchar *filename, + gboolean thumbnail, + GError **error); + + +static guchar used_cmap[3][256]; +static guchar highest_used_index; +static gboolean promote_to_rgb = FALSE; +static guchar gimp_cmap[768]; +static GimpParasite *comment_parasite = NULL; + + +const GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + + +MAIN () + +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 entered" } + }; + static const GimpParamDef load_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Output image" } + }; + static const GimpParamDef thumb_args[] = + { + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size" } + }; + static const GimpParamDef thumb_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Output image" }, + { GIMP_PDB_INT32, "image-width", "Width of full-sized image" }, + { GIMP_PDB_INT32, "image-height", "Height of full-sized image" } + }; + + gimp_install_procedure (LOAD_PROC, + "Loads files of Compuserve GIF file format", + "FIXME: write help for gif_load", + "Spencer Kimball, Peter Mattis, Adam Moss, David Koblas", + "Spencer Kimball, Peter Mattis, Adam Moss, David Koblas", + "1995-2006", + N_("GIF 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/gif"); + gimp_register_magic_load_handler (LOAD_PROC, + "gif", + "", + "0,string,GIF8"); + + gimp_install_procedure (LOAD_THUMB_PROC, + "Loads only the first frame of a GIF image, to be " + "used as a thumbnail", + "", + "Sven Neumann", + "Sven Neumann", + "2006", + NULL, + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (thumb_args), + G_N_ELEMENTS (thumb_return_vals), + thumb_args, thumb_return_vals); + + gimp_register_thumbnail_loader (LOAD_PROC, LOAD_THUMB_PROC); +} + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + static GimpParam values[4]; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + GError *error = NULL; + gint32 image_ID; + + 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) + { + image_ID = load_image (param[1].data.d_string, FALSE, &error); + } + else if (strcmp (name, LOAD_THUMB_PROC) == 0) + { + image_ID = load_image (param[0].data.d_string, TRUE, &error); + } + else + { + status = GIMP_PDB_CALLING_ERROR; + } + + if (status == GIMP_PDB_SUCCESS) + { + if (image_ID != -1) + { + /* The GIF format only tells you how many bits per pixel + * are in the image, not the actual number of used indices (D'OH!) + * + * So if we're not careful, repeated load/save of a transparent GIF + * without intermediate indexed->RGB->indexed pumps up the number of + * bits used, as we add an index each time for the transparent + * color. Ouch. We either do some heavier analysis at save-time, + * or trim down the number of GIMP colors at load-time. We do the + * latter for now. + */ +#ifdef GIFDEBUG + g_print ("GIF: Highest used index is %d\n", highest_used_index); +#endif + if (! promote_to_rgb) + gimp_image_set_colormap (image_ID, + gimp_cmap, highest_used_index + 1); + + *nreturn_vals = 2; + values[1].type = GIMP_PDB_IMAGE; + values[1].data.d_image = image_ID; + + if (strcmp (name, LOAD_THUMB_PROC) == 0) + { + *nreturn_vals = 4; + values[2].type = GIMP_PDB_INT32; + values[2].data.d_int32 = gimp_image_width (image_ID); + values[3].type = GIMP_PDB_INT32; + values[3].data.d_int32 = gimp_image_height (image_ID); + } + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + + if (error) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + } + } + } + + values[0].data.d_status = status; +} + + +#define MAXCOLORMAPSIZE 256 + +#define CM_RED 0 +#define CM_GREEN 1 +#define CM_BLUE 2 + +#define MAX_LZW_BITS 12 + +#define INTERLACE 0x40 +#define LOCALCOLORMAP 0x80 +#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) + +#define ReadOK(file,buffer,len) (fread(buffer, len, 1, file) != 0) +#define LM_to_uint(a,b) (((b)<<8)|(a)) + +#define GRAYSCALE 1 +#define COLOR 2 + +typedef guchar CMap[3][MAXCOLORMAPSIZE]; + +static struct +{ + guint Width; + guint Height; + CMap ColorMap; + guint BitPixel; + guint ColorResolution; + guint Background; + guint AspectRatio; + /* + ** + */ + gint GrayScale; +} GifScreen; + +static struct +{ + gint transparent; + gint delayTime; + gint inputFlag; + gint disposal; +} Gif89 = { -1, -1, -1, 0 }; + +static gboolean ReadColorMap (FILE *fd, + gint number, + CMap buffer, + gint *format); +static gint DoExtension (FILE *fd, + gint label); +static gint GetDataBlock (FILE *fd, + guchar *buf); +static gint GetCode (FILE *fd, + gint code_size, + gboolean flag); +static gint LZWReadByte (FILE *fd, + gint just_reset_LZW, + gint input_code_size); +static gboolean ReadImage (FILE *fd, + const gchar *filename, + gint len, + gint height, + CMap cmap, + gint ncols, + gint format, + gint interlace, + gint number, + guint leftpos, + guint toppos, + guint screenwidth, + guint screenheight, + gint32 *image_ID); + + +static gint32 +load_image (const gchar *filename, + gboolean thumbnail, + GError **error) +{ + FILE *fd; + guchar buf[16]; + guchar c; + CMap localColorMap; + gint grayScale; + gboolean useGlobalColormap; + gint bitPixel; + gint imageCount = 0; + gchar version[4]; + gint32 image_ID = -1; + gboolean status; + + gimp_progress_init_printf (_("Opening '%s'"), + gimp_filename_to_utf8 (filename)); + + fd = g_fopen (filename, "rb"); + + if (! fd) + { + 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; + } + + if (! ReadOK (fd, buf, 6)) + { + g_message ("Error reading magic number"); + fclose (fd); + return -1; + } + + if (strncmp ((gchar *) buf, "GIF", 3) != 0) + { + g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, + "%s", _("This is not a GIF file")); + fclose (fd); + return -1; + } + + strncpy (version, (gchar *) buf + 3, 3); + version[3] = '\0'; + + if ((strcmp (version, "87a") != 0) && (strcmp (version, "89a") != 0)) + { + g_message ("Bad version number, not '87a' or '89a'"); + fclose (fd); + return -1; + } + + if (! ReadOK (fd, buf, 7)) + { + g_message ("Failed to read screen descriptor"); + fclose (fd); + return -1; + } + + GifScreen.Width = LM_to_uint (buf[0], buf[1]); + GifScreen.Height = LM_to_uint (buf[2], buf[3]); + GifScreen.BitPixel = 2 << (buf[4] & 0x07); + GifScreen.ColorResolution = (((buf[4] & 0x70) >> 3) + 1); + GifScreen.Background = buf[5]; + GifScreen.AspectRatio = buf[6]; + + if (BitSet (buf[4], LOCALCOLORMAP)) + { + /* Global Colormap */ + if (! ReadColorMap (fd, GifScreen.BitPixel, GifScreen.ColorMap, + &GifScreen.GrayScale)) + { + g_message ("Error reading global colormap"); + fclose (fd); + return -1; + } + } + + if (GifScreen.AspectRatio != 0 && GifScreen.AspectRatio != 49) + g_message ("Non-square pixels. Image might look squashed if " + "Dot for Dot mode is enabled."); + + highest_used_index = 0; + + while (TRUE) + { + if (! ReadOK (fd, &c, 1)) + { + g_message ("EOF / read error on image data"); + fclose (fd); + return image_ID; /* will be -1 if failed on first image! */ + } + + if (c == ';') + { + /* GIF terminator */ + fclose (fd); + return image_ID; + } + + if (c == '!') + { + /* Extension */ + if (! ReadOK (fd, &c, 1)) + { + g_message ("EOF / read error on extension function code"); + fclose (fd); + return image_ID; /* will be -1 if failed on first image! */ + } + + DoExtension (fd, c); + continue; + } + + if (c != ',') + { + /* Not a valid start character */ + g_printerr ("GIF: bogus character 0x%02x, ignoring.\n", (int) c); + continue; + } + + ++imageCount; + + if (! ReadOK (fd, buf, 9)) + { + g_message ("Couldn't read left/top/width/height"); + fclose (fd); + return image_ID; /* will be -1 if failed on first image! */ + } + + useGlobalColormap = !BitSet (buf[8], LOCALCOLORMAP); + + bitPixel = 1 << ((buf[8] & 0x07) + 1); + + if (! useGlobalColormap) + { + if (! ReadColorMap (fd, bitPixel, localColorMap, &grayScale)) + { + g_message ("Error reading local colormap"); + fclose (fd); + return image_ID; /* will be -1 if failed on first image! */ + } + + status = ReadImage (fd, filename, LM_to_uint (buf[4], buf[5]), + LM_to_uint (buf[6], buf[7]), + localColorMap, bitPixel, + grayScale, + BitSet (buf[8], INTERLACE), imageCount, + (guint) LM_to_uint (buf[0], buf[1]), + (guint) LM_to_uint (buf[2], buf[3]), + GifScreen.Width, + GifScreen.Height, + &image_ID); + } + else + { + status = ReadImage (fd, filename, LM_to_uint (buf[4], buf[5]), + LM_to_uint (buf[6], buf[7]), + GifScreen.ColorMap, GifScreen.BitPixel, + GifScreen.GrayScale, + BitSet (buf[8], INTERLACE), imageCount, + (guint) LM_to_uint (buf[0], buf[1]), + (guint) LM_to_uint (buf[2], buf[3]), + GifScreen.Width, + GifScreen.Height, + &image_ID); + } + + if (!status) + break; + + if (GifScreen.AspectRatio != 0 && GifScreen.AspectRatio != 49) + { + /* Byte overflow is allowed per the GIF specification */ + guint8 par = GifScreen.AspectRatio + 15; + + if (par > 0) + { + gdouble image_xres; + gdouble image_yres; + gfloat ratio = par / 64.0; + + gimp_image_get_resolution (image_ID, &image_xres, &image_yres); + if (ratio < 1) + image_xres = image_yres * (1 / ratio); + else + image_yres = image_xres * ratio; + gimp_image_set_resolution (image_ID, image_xres, image_yres); + } + } + + if (comment_parasite != NULL) + { + if (! thumbnail) + gimp_image_attach_parasite (image_ID, comment_parasite); + + gimp_parasite_free (comment_parasite); + comment_parasite = NULL; + } + + /* If we are loading a thumbnail, we stop after the first frame. */ + if (thumbnail) + break; + } + + fclose (fd); + + return image_ID; +} + +static gboolean +ReadColorMap (FILE *fd, + gint number, + CMap buffer, + gint *format) +{ + guchar rgb[3]; + gint flag; + gint i; + + flag = TRUE; + + for (i = 0; i < number; ++i) + { + if (! ReadOK (fd, rgb, sizeof (rgb))) + return FALSE; + + buffer[CM_RED][i] = rgb[0]; + buffer[CM_GREEN][i] = rgb[1]; + buffer[CM_BLUE][i] = rgb[2]; + + flag &= (rgb[0] == rgb[1] && rgb[1] == rgb[2]); + } + + *format = (flag) ? GRAYSCALE : COLOR; + + return TRUE; +} + +static gint +DoExtension (FILE *fd, + gint label) +{ + static guchar buf[256]; +#ifdef GIFDEBUG + gchar *str; +#endif + + switch (label) + { + case 0x01: /* Plain Text Extension */ +#ifdef GIFDEBUG + str = "Plain Text Extension"; +#endif + +#ifdef notdef + if (GetDataBlock (fd, (guchar *) buf) == 0) + ; + + lpos = LM_to_uint (buf[0], buf[1]); + tpos = LM_to_uint (buf[2], buf[3]); + width = LM_to_uint (buf[4], buf[5]); + height = LM_to_uint (buf[6], buf[7]); + cellw = buf[8]; + cellh = buf[9]; + foreground = buf[10]; + background = buf[11]; + + while (GetDataBlock (fd, (guchar *) buf) > 0) + { + PPM_ASSIGN (image[ypos][xpos], + cmap[CM_RED][v], + cmap[CM_GREEN][v], + cmap[CM_BLUE][v]); + ++index; + } + + return FALSE; +#else + break; +#endif + + case 0xff: /* Application Extension */ +#ifdef GIFDEBUG + str = "Application Extension"; +#endif + break; + case 0xfe: /* Comment Extension */ +#ifdef GIFDEBUG + str = "Comment Extension"; +#endif + while (GetDataBlock (fd, (guchar *) buf) > 0) + { + gchar *comment = (gchar *) buf; + + if (! g_utf8_validate (comment, -1, NULL)) + continue; + + if (comment_parasite) + gimp_parasite_free (comment_parasite); + + comment_parasite = gimp_parasite_new ("gimp-comment", + GIMP_PARASITE_PERSISTENT, + strlen (comment) + 1, comment); + } + return TRUE; + break; + + case 0xf9: /* Graphic Control Extension */ +#ifdef GIFDEBUG + str = "Graphic Control Extension"; +#endif + (void) GetDataBlock (fd, (guchar *) buf); + Gif89.disposal = (buf[0] >> 2) & 0x7; + Gif89.inputFlag = (buf[0] >> 1) & 0x1; + Gif89.delayTime = LM_to_uint (buf[1], buf[2]); + if ((buf[0] & 0x1) != 0) + Gif89.transparent = buf[3]; + else + Gif89.transparent = -1; + + while (GetDataBlock (fd, (guchar *) buf) > 0); + + return FALSE; + break; + + default: +#ifdef GIFDEBUG + str = (gchar *)buf; +#endif + sprintf ((gchar *)buf, "UNKNOWN (0x%02x)", label); + break; + } + +#ifdef GIFDEBUG + g_print ("GIF: got a '%s'\n", str); +#endif + + while (GetDataBlock (fd, (guchar *) buf) > 0); + + return FALSE; +} + +static gint ZeroDataBlock = FALSE; + +static gint +GetDataBlock (FILE *fd, + guchar *buf) +{ + guchar count; + + if (! ReadOK (fd, &count, 1)) + { + g_message ("Error in getting DataBlock size"); + return -1; + } + + ZeroDataBlock = (count == 0); + + if ((count != 0) && (! ReadOK (fd, buf, count))) + { + g_message ("Error in reading DataBlock"); + return -1; + } + + return count; +} + +static gint +GetCode (FILE *fd, + gint code_size, + gboolean flag) +{ + static guchar buf[280]; + static gint curbit, lastbit, done, last_byte; + gint i, j, ret, count; + + if (flag) + { + curbit = 0; + lastbit = 0; + done = FALSE; + last_byte = 2; + return 0; + } + + while ((curbit + code_size) > lastbit) + { + if (done) + { + if (curbit >= lastbit) + g_message ("Ran off the end of my bits"); + + return -1; + } + + buf[0] = buf[last_byte - 2]; + buf[1] = buf[last_byte - 1]; + + count = GetDataBlock (fd, &buf[2]); + if (count < 0) + { + return -1; + } + else if (count == 0) + { + done = TRUE; + } + + last_byte = 2 + count; + curbit = (curbit - lastbit) + 16; + lastbit = (2 + count) * 8; + } + + ret = 0; + for (i = curbit, j = 0; j < code_size; ++i, ++j) + ret |= ((buf[i / 8] & (1 << (i % 8))) != 0) << j; + + curbit += code_size; + + return ret; +} + +static gint +LZWReadByte (FILE *fd, + gint just_reset_LZW, + gint input_code_size) +{ + static gint fresh = FALSE; + gint code, incode; + static gint code_size, set_code_size; + static gint max_code, max_code_size; + static gint firstcode, oldcode; + static gint clear_code, end_code; + static gint table[2][(1 << MAX_LZW_BITS)]; +#define STACK_SIZE ((1 << (MAX_LZW_BITS)) * 2) + static gint stack[STACK_SIZE], *sp; + gint i; + + if (just_reset_LZW) + { + if (input_code_size > MAX_LZW_BITS || input_code_size <= 1) + { + g_message ("Value out of range for code size (corrupted file?)"); + return -1; + } + + set_code_size = input_code_size; + code_size = set_code_size + 1; + clear_code = 1 << set_code_size; + end_code = clear_code + 1; + max_code_size = 2 * clear_code; + max_code = clear_code + 2; + + if (GetCode (fd, 0, TRUE) < 0) + { + return -1; + } + + fresh = TRUE; + + sp = stack; + + for (i = 0; i < clear_code; ++i) + { + table[0][i] = 0; + table[1][i] = i; + } + for (; i < (1 << MAX_LZW_BITS); ++i) + { + table[0][i] = 0; + table[1][i] = 0; + } + + return 0; + } + else if (fresh) + { + fresh = FALSE; + do + { + firstcode = oldcode = GetCode (fd, code_size, FALSE); + } + while (firstcode == clear_code); + + if (firstcode < 0) + { + return -1; + } + + return firstcode & 255; + } + + if (sp > stack) + return (*--sp) & 255; + + while ((code = GetCode (fd, code_size, FALSE)) >= 0) + { + if (code == clear_code) + { + for (i = 0; i < clear_code; ++i) + { + table[0][i] = 0; + table[1][i] = i; + } + for (; i < (1 << MAX_LZW_BITS); ++i) + { + table[0][i] = 0; + table[1][i] = 0; + } + + code_size = set_code_size + 1; + max_code_size = 2 * clear_code; + max_code = clear_code + 2; + sp = stack; + firstcode = oldcode = GetCode (fd, code_size, FALSE); + + if (firstcode < 0) + { + return -1; + } + + return firstcode & 255; + } + else if (code == end_code || code > max_code) + { + gint count; + guchar buf[260]; + + if (ZeroDataBlock) + return -2; + + while ((count = GetDataBlock (fd, buf)) > 0) + ; + + if (count != 0) + g_print ("GIF: missing EOD in data stream (common occurrence)"); + + return -2; + } + + incode = code; + + if (code == max_code) + { + if (sp < &(stack[STACK_SIZE])) + *sp++ = firstcode; + code = oldcode; + } + + while (code >= clear_code && sp < &(stack[STACK_SIZE])) + { + *sp++ = table[1][code]; + if (code == table[0][code]) + { + g_message ("Circular table entry. Corrupt file."); + gimp_quit (); + } + code = table[0][code]; + } + + if (sp < &(stack[STACK_SIZE])) + *sp++ = firstcode = table[1][code]; + + if ((code = max_code) < (1 << MAX_LZW_BITS)) + { + table[0][code] = oldcode; + table[1][code] = firstcode; + ++max_code; + if ((max_code >= max_code_size) && + (max_code_size < (1 << MAX_LZW_BITS))) + { + max_code_size *= 2; + ++code_size; + } + } + + oldcode = incode; + + if (sp > stack) + return (*--sp) & 255; + } + + if (code < 0) + { + return -1; + } + + return code & 255; +} + +static gboolean +ReadImage (FILE *fd, + const gchar *filename, + gint len, + gint height, + CMap cmap, + gint ncols, + gint format, + gint interlace, + gint number, + guint leftpos, + guint toppos, + guint screenwidth, + guint screenheight, + gint32 *image_ID) +{ + static gint frame_number = 1; + + gint32 layer_ID; + GeglBuffer *buffer; + guchar *dest, *temp; + guchar c; + gint xpos = 0, ypos = 0, pass = 0; + gint cur_progress, max_progress; + gint v; + gint i, j; + gchar *framename; + gchar *framename_ptr; + gboolean alpha_frame = FALSE; + static gint previous_disposal; + + /* Guard against bogus frame size */ + if (len < 1 || height < 1) + { + g_message ("Bogus frame dimensions"); + *image_ID = -1; + return FALSE; + } + + /* + ** Initialize the Compression routines + */ + if (! ReadOK (fd, &c, 1)) + { + g_message ("EOF / read error on image data"); + *image_ID = -1; + return FALSE; + } + + if (LZWReadByte (fd, TRUE, c) < 0) + { + g_message ("Error while reading"); + *image_ID = -1; + return FALSE; + } + + if (frame_number == 1) + { + /* Guard against bogus logical screen size values */ + if (screenwidth == 0) + screenwidth = len; + + if (screenheight == 0) + screenheight = height; + + *image_ID = gimp_image_new (screenwidth, screenheight, GIMP_INDEXED); + gimp_image_set_filename (*image_ID, filename); + + for (i = 0, j = 0; i < ncols; i++) + { + used_cmap[0][i] = gimp_cmap[j++] = cmap[0][i]; + used_cmap[1][i] = gimp_cmap[j++] = cmap[1][i]; + used_cmap[2][i] = gimp_cmap[j++] = cmap[2][i]; + } + + gimp_image_set_colormap (*image_ID, gimp_cmap, ncols); + + if (Gif89.delayTime < 0) + framename = g_strdup (_("Background")); + else + framename = g_strdup_printf (_("Background (%d%s)"), + 10 * Gif89.delayTime, "ms"); + + previous_disposal = Gif89.disposal; + + if (Gif89.transparent == -1) + { + layer_ID = gimp_layer_new (*image_ID, framename, + len, height, + GIMP_INDEXED_IMAGE, + 100, + gimp_image_get_default_new_layer_mode (*image_ID)); + } + else + { + layer_ID = gimp_layer_new (*image_ID, framename, + len, height, + GIMP_INDEXEDA_IMAGE, + 100, + gimp_image_get_default_new_layer_mode (*image_ID)); + alpha_frame=TRUE; + } + + g_free (framename); + } + else /* NOT FIRST FRAME */ + { + gimp_progress_set_text_printf (_("Opening '%s' (frame %d)"), + gimp_filename_to_utf8 (filename), + frame_number); + gimp_progress_pulse (); + + /* If the colormap is now different, we have to promote to RGB! */ + if (! promote_to_rgb) + { + for (i = 0; i < ncols; i++) + { + if ((used_cmap[0][i] != cmap[0][i]) || + (used_cmap[1][i] != cmap[1][i]) || + (used_cmap[2][i] != cmap[2][i])) + { + /* Everything is RGB(A) from now on... sigh. */ + promote_to_rgb = TRUE; + + /* Promote everything we have so far into RGB(A) */ +#ifdef GIFDEBUG + g_print ("GIF: Promoting image to RGB...\n"); +#endif + gimp_image_convert_rgb (*image_ID); + + break; + } + } + } + + if (Gif89.delayTime < 0) + framename = g_strdup_printf (_("Frame %d"), frame_number); + else + framename = g_strdup_printf (_("Frame %d (%d%s)"), + frame_number, 10 * Gif89.delayTime, "ms"); + + switch (previous_disposal) + { + case 0x00: + break; /* 'don't care' */ + case 0x01: + framename_ptr = framename; + framename = g_strconcat (framename, " (combine)", NULL); + g_free (framename_ptr); + break; + case 0x02: + framename_ptr = framename; + framename = g_strconcat (framename, " (replace)", NULL); + g_free (framename_ptr); + break; + case 0x03: /* Rarely-used, and unhandled by many + loaders/players (including GIMP: we treat as + 'combine' mode). */ + framename_ptr = framename; + framename = g_strconcat (framename, " (combine) (!)", NULL); + g_free (framename_ptr); + break; + case 0x04: /* I've seen a composite of this type. stvo_online_banner2.gif */ + case 0x05: + case 0x06: /* I've seen a composite of this type. bn31.Gif */ + case 0x07: + framename_ptr = framename; + framename = g_strconcat (framename, " (unknown disposal)", NULL); + g_free (framename_ptr); + g_message (_("GIF: Undocumented GIF composite type %d is " + "not handled. Animation might not play or " + "re-save perfectly."), + previous_disposal); + break; + default: + g_message ("Disposal word got corrupted. Bug."); + break; + } + previous_disposal = Gif89.disposal; + + layer_ID = gimp_layer_new (*image_ID, framename, + len, height, + promote_to_rgb ? + GIMP_RGBA_IMAGE : GIMP_INDEXEDA_IMAGE, + 100, + gimp_image_get_default_new_layer_mode (*image_ID)); + alpha_frame = TRUE; + g_free (framename); + } + + frame_number++; + + gimp_image_insert_layer (*image_ID, layer_ID, -1, 0); + gimp_item_transform_translate (layer_ID, (gint) leftpos, (gint) toppos); + + cur_progress = 0; + max_progress = height; + + if (len > (G_MAXSIZE / height / (alpha_frame ? (promote_to_rgb ? 4 : 2) : 1))) + { + g_message ("'%s' has a larger image size than GIMP can handle.", + gimp_filename_to_utf8 (filename)); + *image_ID = -1; + return FALSE; + } + + if (alpha_frame) + dest = (guchar *) g_malloc ((gsize)len * (gsize)height * (promote_to_rgb ? 4 : 2)); + else + dest = (guchar *) g_malloc ((gsize)len * (gsize)height); + +#ifdef GIFDEBUG + g_print ("GIF: reading %d by %d%s GIF image, ncols=%d\n", + len, height, interlace ? " interlaced" : "", ncols); +#endif + + if (! alpha_frame && promote_to_rgb) + { + /* I don't see how one would easily construct a GIF in which + this could happen, but it's a mad mad world. */ + g_message ("Ouch! Can't handle non-alpha RGB frames.\n" + "Please file a bug report at " + "https://gitlab.gnome.org/GNOME/gimp/issues"); + gimp_quit (); + } + + while ((v = LZWReadByte (fd, FALSE, c)) >= 0) + { + if (alpha_frame) + { + if (((guchar) v > highest_used_index) && !(v == Gif89.transparent)) + highest_used_index = (guchar) v; + + if (promote_to_rgb) + { + temp = dest + ( (ypos * len) + xpos ) * 4; + *(temp ) = (guchar) cmap[0][v]; + *(temp+1) = (guchar) cmap[1][v]; + *(temp+2) = (guchar) cmap[2][v]; + *(temp+3) = (guchar) ((v == Gif89.transparent) ? 0 : 255); + } + else + { + temp = dest + ( (ypos * len) + xpos ) * 2; + *temp = (guchar) v; + *(temp+1) = (guchar) ((v == Gif89.transparent) ? 0 : 255); + } + } + else + { + if ((guchar) v > highest_used_index) + highest_used_index = (guchar) v; + + temp = dest + (ypos * len) + xpos; + *temp = (guchar) v; + } + + xpos++; + if (xpos == len) + { + xpos = 0; + if (interlace) + { + switch (pass) + { + case 0: + case 1: + ypos += 8; + break; + case 2: + ypos += 4; + break; + case 3: + ypos += 2; + break; + } + + if (ypos >= height) + { + pass++; + switch (pass) + { + case 1: + ypos = 4; + break; + case 2: + ypos = 2; + break; + case 3: + ypos = 1; + break; + default: + goto fini; + } + } + } + else + { + ypos++; + } + + if (frame_number == 1) + { + cur_progress++; + if ((cur_progress % 16) == 0) + gimp_progress_update ((gdouble) cur_progress / + (gdouble) max_progress); + } + } + + if (ypos >= height) + break; + } + + if (v < 0) + { + return FALSE; + } + + fini: + buffer = gimp_drawable_get_buffer (layer_ID); + + gegl_buffer_set (buffer, GEGL_RECTANGLE (0, 0, len, height), 0, + NULL, dest, GEGL_AUTO_ROWSTRIDE); + + g_free (dest); + + g_object_unref (buffer); + + gimp_progress_update (1.0); + + if (LZWReadByte (fd, FALSE, c) >= 0) + { + g_print ("GIF: too much input data, ignoring extra...\n"); + return FALSE; + } + + return TRUE; +} |