+ if (context->frame_cmap_active)
+ cmap = context->frame_color_map;
+ else
+ cmap = context->global_color_map;
+
+ if (context->gif89.transparent != -1) {
+ pixel = dest + (context->draw_ypos + offset) * gdk_pixbuf_get_rowstride (context->frame->pixbuf) + context->draw_xpos * 4;
+ *pixel = cmap [0][(guchar) v];
+ *(pixel+1) = cmap [1][(guchar) v];
+ *(pixel+2) = cmap [2][(guchar) v];
+ *(pixel+3) = (guchar) ((v == context->gif89.transparent) ? 0 : 255);
+ } else {
+ pixel = dest + (context->draw_ypos + offset) * gdk_pixbuf_get_rowstride (context->frame->pixbuf) + context->draw_xpos * 3;
+ *pixel = cmap [0][(guchar) v];
+ *(pixel+1) = cmap [1][(guchar) v];
+ *(pixel+2) = cmap [2][(guchar) v];
+ }
+}
+
+
+/* only called if progressive and interlaced */
+static void
+gif_fill_in_lines (GifContext *context, guchar *dest, guchar v)
+{
+ switch (context->draw_pass) {
+ case 0:
+ if (context->draw_ypos > 4) {
+ gif_fill_in_pixels (context, dest, -4, v);
+ gif_fill_in_pixels (context, dest, -3, v);
+ }
+ if (context->draw_ypos < (context->frame_height - 4)) {
+ gif_fill_in_pixels (context, dest, 3, v);
+ gif_fill_in_pixels (context, dest, 4, v);
+ }
+ /* we don't need a break here. We draw the outer pixels first, then the
+ * inner ones, then the innermost ones. case 0 needs to draw all 3 bands.
+ * case 1, just the last two, and case 2 just draws the last one*/
+ case 1:
+ if (context->draw_ypos > 2)
+ gif_fill_in_pixels (context, dest, -2, v);
+ if (context->draw_ypos < (context->frame_height - 2))
+ gif_fill_in_pixels (context, dest, 2, v);
+ /* no break as above. */
+ case 2:
+ if (context->draw_ypos > 1)
+ gif_fill_in_pixels (context, dest, -1, v);
+ if (context->draw_ypos < (context->frame_height - 1))
+ gif_fill_in_pixels (context, dest, 1, v);
+ case 3:
+ default:
+ break;
+ }
+}
+
+/* Clips a rectancle to the base dimensions. Returns TRUE if the clipped rectangle is non-empty. */
+static gboolean
+clip_frame (GifContext *context,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height)
+{
+ gint orig_x, orig_y;
+
+ orig_x = *x;
+ orig_y = *y;
+ *x = MAX (0, *x);
+ *y = MAX (0, *y);
+ *width = MIN (context->width, orig_x + *width) - *x;
+ *height = MIN (context->height, orig_y + *height) - *y;
+
+ if (*width > 0 && *height > 0)
+ return TRUE;
+
+ /* The frame is completely off-bounds */
+
+ *x = 0;
+ *y = 0;
+ *width = 0;
+ *height = 0;
+
+ return FALSE;
+}
+
+/* Call update_func on the given rectangle, unless it is completely off-bounds */
+static void
+maybe_update (GifContext *context,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ if (clip_frame (context, &x, &y, &width, &height))
+ (*context->update_func) (context->frame->pixbuf,
+ x, y, width, height,
+ context->user_data);
+}
+
+static int
+gif_get_lzw (GifContext *context)
+{
+ guchar *dest, *temp;
+ gint lower_bound, upper_bound; /* bounds for emitting the area_updated signal */
+ gboolean bound_flag;
+ gint first_pass; /* bounds for emitting the area_updated signal */
+ gint v;
+
+ if (context->frame == NULL) {
+ context->frame = g_new (GdkPixbufFrame, 1);
+
+ context->frame->composited = NULL;
+ context->frame->revert = NULL;
+
+ if (context->frame_len == 0 || context->frame_height == 0) {
+ /* An empty frame, we just output a single transparent
+ * pixel at (0, 0).
+ */
+ context->x_offset = 0;
+ context->y_offset = 0;
+ context->frame_len = 1;
+ context->frame_height = 1;
+ context->frame->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 1, 1);
+ if (context->frame->pixbuf) {
+ guchar *pixels;
+
+ pixels = gdk_pixbuf_get_pixels (context->frame->pixbuf);
+ pixels[0] = 0;
+ pixels[1] = 0;
+ pixels[2] = 0;
+ pixels[3] = 0;
+ }
+ } else
+ context->frame->pixbuf =
+ gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+ TRUE,
+ 8,
+ context->frame_len,
+ context->frame_height);
+ if (!context->frame->pixbuf) {
+ g_free (context->frame);
+ g_set_error_literal (context->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Not enough memory to load GIF file"));
+ return -2;
+ }
+
+ context->frame->x_offset = context->x_offset;
+ context->frame->y_offset = context->y_offset;
+ context->frame->need_recomposite = TRUE;
+
+ /* GIF delay is in hundredths, we want thousandths */
+ context->frame->delay_time = context->gif89.delay_time * 10;
+
+ /* GIFs with delay time 0 are mostly broken, but they
+ * just want a default, "not that fast" delay.
+ */
+ if (context->frame->delay_time == 0)
+ context->frame->delay_time = 100;
+
+ /* No GIFs gets to play faster than 50 fps. They just
+ * lock up poor gtk.
+ */
+ if (context->frame->delay_time < 20)
+ context->frame->delay_time = 20; /* 20 = "fast" */
+
+ context->frame->elapsed = context->animation->total_time;
+ context->animation->total_time += context->frame->delay_time;
+
+ switch (context->gif89.disposal) {
+ case 0:
+ case 1:
+ context->frame->action = GDK_PIXBUF_FRAME_RETAIN;
+ break;
+ case 2:
+ context->frame->action = GDK_PIXBUF_FRAME_DISPOSE;
+ break;
+ case 3:
+ context->frame->action = GDK_PIXBUF_FRAME_REVERT;
+ break;
+ default:
+ context->frame->action = GDK_PIXBUF_FRAME_RETAIN;
+ break;
+ }
+
+ context->frame->bg_transparent = (context->gif89.transparent == context->background_index);
+
+ context->animation->n_frames ++;
+ context->animation->frames = g_list_append (context->animation->frames, context->frame);
+
+ /* Only call prepare_func for the first frame */
+ if (context->animation->frames->next == NULL) {
+ if (context->animation->width == 0 )
+ context->animation->width = gdk_pixbuf_get_width(context->frame->pixbuf);
+ if (context->animation->height == 0)
+ context->animation->height = gdk_pixbuf_get_height (context->frame->pixbuf);
+
+ if (context->prepare_func)
+ (* context->prepare_func) (context->frame->pixbuf,
+ GDK_PIXBUF_ANIMATION (context->animation),
+ context->user_data);
+ } else {
+ /* Otherwise init frame with last frame */
+ GList *link;
+ GdkPixbufFrame *prev_frame;
+ gint x, y, w, h;
+
+ link = g_list_find (context->animation->frames, context->frame);
+
+ prev_frame = link->prev->data;
+
+ gdk_pixbuf_gif_anim_frame_composite (context->animation, prev_frame);
+
+ /* Composite failed */
+ if (prev_frame->composited == NULL) {
+ GdkPixbufFrame *frame = NULL;
+ link = g_list_first (context->animation->frames);
+ while (link != NULL) {
+ frame = (GdkPixbufFrame *)link->data;
+ if (frame != NULL) {
+ if (frame->pixbuf != NULL)
+ g_object_unref (frame->pixbuf);
+ if (frame->composited != NULL)
+ g_object_unref (frame->composited);
+ if (frame->revert != NULL)
+ g_object_unref (frame->revert);
+ g_free (frame);
+ }
+ link = link->next;
+ }
+
+ g_list_free (context->animation->frames);
+ context->animation->frames = NULL;
+
+ g_set_error_literal (context->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Not enough memory to composite a frame in GIF file"));
+ return -2;
+ }
+
+ x = context->frame->x_offset;
+ y = context->frame->y_offset;
+ w = gdk_pixbuf_get_width (context->frame->pixbuf);
+ h = gdk_pixbuf_get_height (context->frame->pixbuf);
+ if (clip_frame (context, &x, &y, &w, &h))
+ gdk_pixbuf_copy_area (prev_frame->composited,
+ x, y, w, h,
+ context->frame->pixbuf,
+ 0, 0);
+ }
+ }
+
+ dest = gdk_pixbuf_get_pixels (context->frame->pixbuf);
+
+ bound_flag = FALSE;
+ lower_bound = upper_bound = context->draw_ypos;
+ first_pass = context->draw_pass;
+
+ while (TRUE) {
+ guchar (*cmap)[MAXCOLORMAPSIZE];
+
+ if (context->frame_cmap_active)
+ cmap = context->frame_color_map;
+ else
+ cmap = context->global_color_map;
+
+ v = lzw_read_byte (context);
+ if (v < 0) {
+ goto finished_data;
+ }
+ bound_flag = TRUE;
+
+ g_assert (gdk_pixbuf_get_has_alpha (context->frame->pixbuf));
+
+ temp = dest + context->draw_ypos * gdk_pixbuf_get_rowstride (context->frame->pixbuf) + context->draw_xpos * 4;
+ *temp = cmap [0][(guchar) v];
+ *(temp+1) = cmap [1][(guchar) v];
+ *(temp+2) = cmap [2][(guchar) v];
+ *(temp+3) = (guchar) ((v == context->gif89.transparent) ? 0 : 255);
+
+ if (context->prepare_func && context->frame_interlace)
+ gif_fill_in_lines (context, dest, v);
+
+ context->draw_xpos++;
+
+ if (context->draw_xpos == context->frame_len) {
+ context->draw_xpos = 0;
+ if (context->frame_interlace) {
+ switch (context->draw_pass) {
+ case 0:
+ case 1:
+ context->draw_ypos += 8;
+ break;
+ case 2:
+ context->draw_ypos += 4;
+ break;
+ case 3:
+ context->draw_ypos += 2;
+ break;
+ }
+
+ if (context->draw_ypos >= context->frame_height) {
+ context->draw_pass++;
+ switch (context->draw_pass) {
+ case 1:
+ context->draw_ypos = 4;
+ break;
+ case 2:
+ context->draw_ypos = 2;
+ break;
+ case 3:
+ context->draw_ypos = 1;
+ break;
+ default:
+ goto done;
+ }
+ }
+ } else {
+ context->draw_ypos++;
+ }
+ if (context->draw_pass != first_pass) {
+ if (context->draw_ypos > lower_bound) {
+ lower_bound = 0;
+ upper_bound = context->frame_height;
+ } else {
+
+ }
+ } else
+ upper_bound = context->draw_ypos;
+ }
+ if (context->draw_ypos >= context->frame_height)
+ break;
+ }
+
+ done:
+
+ context->state = GIF_GET_NEXT_STEP;
+
+ v = 0;
+
+ finished_data:
+
+ if (bound_flag)
+ context->frame->need_recomposite = TRUE;
+
+ if (bound_flag && context->update_func) {
+ if (lower_bound <= upper_bound && first_pass == context->draw_pass) {
+ maybe_update (context,
+ context->frame->x_offset,
+ context->frame->y_offset + lower_bound,
+ gdk_pixbuf_get_width (context->frame->pixbuf),
+ upper_bound - lower_bound);
+ } else {
+ if (lower_bound <= upper_bound) {
+ maybe_update (context,
+ context->frame->x_offset,
+ context->frame->y_offset,
+ gdk_pixbuf_get_width (context->frame->pixbuf),
+ gdk_pixbuf_get_height (context->frame->pixbuf));
+ } else {
+ maybe_update (context,
+ context->frame->x_offset,
+ context->frame->y_offset,
+ gdk_pixbuf_get_width (context->frame->pixbuf),
+ upper_bound);
+ maybe_update (context,
+ context->frame->x_offset,
+ context->frame->y_offset + lower_bound,
+ gdk_pixbuf_get_width (context->frame->pixbuf),
+ gdk_pixbuf_get_height (context->frame->pixbuf) - lower_bound);
+ }
+ }
+ }
+
+ if (context->state == GIF_GET_NEXT_STEP) {
+ /* Will be freed with context->animation, we are just
+ * marking that we're done with it (no current frame)
+ */
+ context->frame = NULL;
+ context->frame_cmap_active = FALSE;
+
+ if (context->stop_after_first_frame)
+ context->state = GIF_DONE;
+ }
+
+ return v;
+}
+
+static void
+gif_set_prepare_lzw (GifContext *context)
+{
+ context->state = GIF_PREPARE_LZW;
+ context->lzw_code_pending = -1;
+}
+static int
+gif_prepare_lzw (GifContext *context)
+{
+ gint i;
+
+ if (!gif_read (context, &(context->lzw_set_code_size), 1)) {
+ /*g_message (_("GIF: EOF / read error on image data\n"));*/
+ return -1;
+ }
+
+ if (context->lzw_set_code_size > MAX_LZW_BITS) {
+ g_set_error_literal (context->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ _("GIF image is corrupt (incorrect LZW compression)"));
+ return -2;
+ }
+
+ context->lzw_code_size = context->lzw_set_code_size + 1;
+ context->lzw_clear_code = 1 << context->lzw_set_code_size;
+ context->lzw_end_code = context->lzw_clear_code + 1;
+ context->lzw_max_code_size = 2 * context->lzw_clear_code;
+ context->lzw_max_code = context->lzw_clear_code + 2;
+ context->lzw_fresh = TRUE;
+ context->code_curbit = 0;
+ context->code_lastbit = 0;
+ context->code_last_byte = 0;
+ context->code_done = FALSE;
+
+ g_assert (context->lzw_clear_code <=
+ G_N_ELEMENTS (context->lzw_table[0]));
+
+ for (i = 0; i < context->lzw_clear_code; ++i) {
+ context->lzw_table[0][i] = 0;
+ context->lzw_table[1][i] = i;
+ }
+ for (; i < (1 << MAX_LZW_BITS); ++i)
+ context->lzw_table[0][i] = context->lzw_table[1][0] = 0;
+
+ context->lzw_sp = context->lzw_stack;
+ gif_set_get_lzw (context);
+
+ return 0;
+}
+
+/* needs 13 bytes to proceed. */
+static gint
+gif_init (GifContext *context)
+{
+ unsigned char buf[16];
+ char version[4];
+
+ if (!gif_read (context, buf, 6)) {
+ /* Unable to read magic number,
+ * gif_read() should have set error
+ */
+ return -1;
+ }
+
+ if (strncmp ((char *) buf, "GIF", 3) != 0) {
+ /* Not a GIF file */
+ g_set_error_literal (context->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ _("File does not appear to be a GIF file"));
+ return -2;
+ }
+
+ strncpy (version, (char *) buf + 3, 3);
+ version[3] = '\0';
+
+ if ((strcmp (version, "87a") != 0) && (strcmp (version, "89a") != 0)) {
+ /* bad version number, not '87a' or '89a' */
+ g_set_error (context->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ _("Version %s of the GIF file format is not supported"),
+ version);
+ return -2;
+ }
+
+ /* read the screen descriptor */
+ if (!gif_read (context, buf, 7)) {
+ /* Failed to read screen descriptor, error set */
+ return -1;
+ }
+
+ context->width = LM_to_uint (buf[0], buf[1]);
+ context->height = LM_to_uint (buf[2], buf[3]);
+ /* The 4th byte is
+ * high bit: whether to use the background index
+ * next 3: color resolution
+ * next: whether colormap is sorted by priority of allocation
+ * last 3: size of colormap
+ */
+ context->global_bit_pixel = 2 << (buf[4] & 0x07);
+ context->global_color_resolution = (((buf[4] & 0x70) >> 3) + 1);
+ context->has_global_cmap = (buf[4] & 0x80) != 0;
+ context->background_index = buf[5];
+ context->aspect_ratio = buf[6];
+
+ /* Use background of transparent black as default, though if
+ * one isn't set explicitly no one should ever use it.
+ */
+ context->animation->bg_red = 0;
+ context->animation->bg_green = 0;
+ context->animation->bg_blue = 0;
+
+ context->animation->width = context->width;
+ context->animation->height = context->height;
+
+ if (context->has_global_cmap) {
+ gif_set_get_colormap (context);
+ } else {
+ context->state = GIF_GET_NEXT_STEP;
+ }
+
+#ifdef DUMP_IMAGE_DETAILS
+ g_print (">Image width: %d height: %d global_cmap: %d background: %d\n",
+ context->width, context->height, context->has_global_cmap, context->background_index);
+#endif
+
+ return 0;
+}
+
+static void
+gif_set_get_frame_info (GifContext *context)
+{
+ context->state = GIF_GET_FRAME_INFO;
+}
+
+static gint
+gif_get_frame_info (GifContext *context)
+{
+ unsigned char buf[9];
+
+ if (!gif_read (context, buf, 9)) {
+ return -1;
+ }
+
+ /* Okay, we got all the info we need. Lets record it */
+ context->frame_len = LM_to_uint (buf[4], buf[5]);
+ context->frame_height = LM_to_uint (buf[6], buf[7]);
+ context->x_offset = LM_to_uint (buf[0], buf[1]);
+ context->y_offset = LM_to_uint (buf[2], buf[3]);
+
+ if (context->animation->frames == NULL &&
+ context->gif89.disposal == 3) {
+ /* First frame can't have "revert to previous" as its
+ * dispose mode. Silently use "retain" instead.
+ */
+ context->gif89.disposal = 0;
+ }
+
+ context->frame_interlace = BitSet (buf[8], INTERLACE);
+
+#ifdef DUMP_IMAGE_DETAILS
+ g_print (">width: %d height: %d xoffset: %d yoffset: %d disposal: %d delay: %d transparent: %d interlace: %d\n",
+ context->frame_len, context->frame_height, context->x_offset, context->y_offset,
+ context->gif89.disposal, context->gif89.delay_time, context->gif89.transparent, context->frame_interlace);
+#endif
+
+ if (BitSet (buf[8], LOCALCOLORMAP)) {
+
+#ifdef DUMP_IMAGE_DETAILS
+ g_print (">has local colormap\n");
+#endif
+
+ /* Does this frame have it's own colormap. */
+ /* really only relevant when looking at the first frame
+ * of an animated gif. */
+ /* if it does, we need to re-read in the colormap,
+ * the gray_scale, and the bit_pixel */
+ context->frame_cmap_active = TRUE;
+ context->frame_bit_pixel = 1 << ((buf[8] & 0x07) + 1);
+ gif_set_get_colormap2 (context);
+ return 0;
+ }
+
+ if (!context->has_global_cmap) {
+ context->state = GIF_DONE;
+
+ g_set_error_literal (context->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ _("GIF image has no global colormap, and a frame inside it has no local colormap."));
+
+ return -2;
+ }
+
+ gif_set_prepare_lzw (context);
+ return 0;
+
+}
+
+static gint
+gif_get_next_step (GifContext *context)
+{
+ unsigned char c;
+ while (TRUE) {
+ if (!gif_read (context, &c, 1)) {
+ return -1;
+ }
+ if (c == ';') {
+ /* GIF terminator */
+ /* hmm. Not 100% sure what to do about this. Should
+ * i try to return a blank image instead? */
+ context->state = GIF_DONE;
+ return 0;
+ }
+
+ if (c == '!') {
+ /* Check the extension */
+ gif_set_get_extension (context);
+ return 0;
+ }
+
+ /* look for frame */
+ if (c != ',') {
+ /* Not a valid start character */
+ continue;
+ }
+ /* load the frame */
+ gif_set_get_frame_info (context);
+ return 0;
+ }
+}
+
+
+#define LOG(x) /* g_print ("%s: %s\n", G_STRLOC, x); */
+
+static gint
+gif_main_loop (GifContext *context)
+{
+ gint retval = 0;
+
+ do {
+ switch (context->state) {
+ case GIF_START:
+ LOG("start\n");
+ retval = gif_init (context);
+ break;
+
+ case GIF_GET_COLORMAP:
+ LOG("get_colormap\n");
+ retval = gif_get_colormap (context);
+ if (retval == 0)
+ context->state = GIF_GET_NEXT_STEP;
+ break;
+
+ case GIF_GET_NEXT_STEP:
+ LOG("next_step\n");
+ retval = gif_get_next_step (context);
+ break;
+
+ case GIF_GET_FRAME_INFO:
+ LOG("frame_info\n");
+ retval = gif_get_frame_info (context);
+ break;
+
+ case GIF_GET_EXTENSION:
+ LOG("get_extension\n");
+ retval = gif_get_extension (context);
+ if (retval == 0)
+ context->state = GIF_GET_NEXT_STEP;
+ break;
+
+ case GIF_GET_COLORMAP2:
+ LOG("get_colormap2\n");
+ retval = gif_get_colormap2 (context);
+ if (retval == 0)
+ gif_set_prepare_lzw (context);
+ break;
+
+ case GIF_PREPARE_LZW:
+ LOG("prepare_lzw\n");
+ retval = gif_prepare_lzw (context);
+ break;
+
+ case GIF_LZW_FILL_BUFFER:
+ LOG("fill_buffer\n");
+ retval = gif_lzw_fill_buffer (context);
+ break;
+
+ case GIF_LZW_CLEAR_CODE:
+ LOG("clear_code\n");
+ retval = gif_lzw_clear_code (context);
+ break;
+
+ case GIF_GET_LZW:
+ LOG("get_lzw\n");
+ retval = gif_get_lzw (context);
+ break;
+
+ case GIF_DONE:
+ LOG("done\n");
+ default:
+ retval = 0;
+ goto done;
+ };
+ } while ((retval == 0) || (retval == -3));
+ done:
+ return retval;
+}
+
+static GifContext *
+new_context (void)
+{
+ GifContext *context;
+
+ context = g_try_malloc (sizeof (GifContext));
+ if (context == NULL)
+ return NULL;
+
+ memset (context, 0, sizeof (GifContext));
+
+ context->animation = g_object_new (GDK_TYPE_PIXBUF_GIF_ANIM, NULL);
+ context->frame = NULL;
+ context->file = NULL;
+ context->state = GIF_START;
+ context->prepare_func = NULL;
+ context->update_func = NULL;
+ context->user_data = NULL;
+ context->buf = NULL;
+ context->amount_needed = 0;
+ context->gif89.transparent = -1;
+ context->gif89.delay_time = -1;
+ context->gif89.input_flag = -1;
+ context->gif89.disposal = -1;
+ context->animation->loop = 1;
+ context->in_loop_extension = FALSE;
+ context->stop_after_first_frame = FALSE;
+
+ return context;
+}