/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */

/* GdkPixbuf library - GIF image loader

 *

 * Copyright (C) 1999 Mark Crichton

 * Copyright (C) 1999 The Free Software Foundation

 *

 * Authors: Jonathan Blandford <jrb@redhat.com>

 *          Adapted from the gimp gif filter written by Adam Moss <adam@gimp.org>

 *          Gimp work based on earlier work.

 *          Permission to relicense under the LGPL obtained.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

/* This loader is very hairy code.

 *

 * The main loop was not designed for incremental loading, so when it was hacked

 * in it got a bit messy.  Basically, every function is written to expect a failed

 * read_gif, and lets you call it again assuming that the bytes are there.

 *

 * Return vals.

 * Unless otherwise specified, these are the return vals for most functions:

 *

 *  0 -> success

 * -1 -> more bytes needed.

 * -2 -> failure; abort the load

 * -3 -> control needs to be passed back to the main loop

 *        \_ (most of the time returning 0 will get this, but not always)

 *

 * >1 -> for functions that get a guchar, the char will be returned.

 *

 * -jrb (11/03/1999)

 */

/*

 * If you have any images that crash this code, please, please let me know and

 * send them to me.

 *                                            <jrb@redhat.com>

 */

#include "config.h"

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include "gdk-pixbuf-private.h"

#include "io-gif-animation.h"

#undef DUMP_IMAGE_DETAILS 

#undef IO_GIFDEBUG

#define MAXCOLORMAPSIZE  256

#define MAX_LZW_BITS     12

#define INTERLACE          0x40

#define LOCALCOLORMAP      0x80

#define BitSet(byte, bit)  (((byte) & (bit)) == (bit))

#define LM_to_uint(a,b)         (((b)<<8)|(a))

typedef unsigned char CMap[3][MAXCOLORMAPSIZE];

/* Possible states we can be in. */

enum {

	GIF_START,

	GIF_GET_COLORMAP,

	GIF_GET_NEXT_STEP,

	GIF_GET_FRAME_INFO,

	GIF_GET_EXTENSION,

	GIF_GET_COLORMAP2,

	GIF_PREPARE_LZW,

	GIF_LZW_FILL_BUFFER,

	GIF_LZW_CLEAR_CODE,

	GIF_GET_LZW,

	GIF_DONE

};

typedef struct _Gif89 Gif89;

struct _Gif89

{

	int transparent;

	int delay_time;

	int input_flag;

	int disposal;

};

typedef struct _GifContext GifContext;

struct _GifContext

{

	int state; /* really only relevant for progressive loading */

	unsigned int width;

	unsigned int height;

        gboolean has_global_cmap;

        CMap global_color_map;

        gint global_colormap_size;

        unsigned int global_bit_pixel;

	unsigned int global_color_resolution;

        unsigned int background_index;

        gboolean stop_after_first_frame;

        gboolean frame_cmap_active;

        CMap frame_color_map;

        gint frame_colormap_size;

        unsigned int frame_bit_pixel;

	unsigned int aspect_ratio;

	GdkPixbufGifAnim *animation;

	GdkPixbufFrame *frame;

	Gif89 gif89;

	/* stuff per frame. */

	int frame_len;

	int frame_height;

	int frame_interlace;

	int x_offset;

	int y_offset;

	/* Static read only */

	FILE *file;

	/* progressive read, only. */

	GdkPixbufModuleSizeFunc size_func;

	GdkPixbufModulePreparedFunc prepare_func;

	GdkPixbufModuleUpdatedFunc update_func;

	gpointer user_data;

        guchar *buf;

	gsize ptr;

	gsize size;

	gsize amount_needed;

	/* extension context */

	guchar extension_label;

	guchar extension_flag;

        gboolean in_loop_extension;

	/* get block context */

	guchar block_count;

	guchar block_buf[280];

	gint block_ptr;

	int old_state; /* used by lzw_fill buffer */

	/* get_code context */

	int code_curbit;

	int code_lastbit;

	int code_done;

	int code_last_byte;

	int lzw_code_pending;

	/* lzw context */

	gint lzw_fresh;

	gint lzw_code_size;

	guchar lzw_set_code_size;

	gint lzw_max_code;

	gint lzw_max_code_size;

	gint lzw_firstcode;

	gint lzw_oldcode;

	gint lzw_clear_code;

	gint lzw_end_code;

	gint *lzw_sp;

	gint lzw_table[2][(1 << MAX_LZW_BITS)];

	gint lzw_stack[(1 << (MAX_LZW_BITS)) * 2 + 1];

	/* painting context */

	gint draw_xpos;

	gint draw_ypos;

	gint draw_pass;

        /* error pointer */

        GError **error;

};

/* The buffer must be at least 255 bytes long. */

static int GetDataBlock (GifContext *, unsigned char *);

#ifdef IO_GIFDEBUG

static int count = 0;

#endif

/* Returns TRUE if read is OK,

 * FALSE if more memory is needed. */

static gboolean

gif_read (GifContext *context, guchar *buffer, size_t len)

{

	gboolean retval;

#ifdef IO_GIFDEBUG

	gint i;

#endif

	if (context->file) {

#ifdef IO_GIFDEBUG

		count += len;

		g_print ("Fsize :%d\tcount :%d\t", len, count);

#endif

		retval = (fread (buffer, 1, len, context->file) == len);

                if (!retval && ferror (context->file)) {

                        gint save_errno = errno;

                        g_set_error (context->error,

                                     G_FILE_ERROR,

                                     g_file_error_from_errno (save_errno),

                                     _("Failure reading GIF: %s"), 

                                     g_strerror (save_errno));

                }

#ifdef IO_GIFDEBUG

		if (len < 100) {

			for (i = 0; i < len; i++)

				g_print ("%d ", buffer[i]);

		}

		g_print ("\n");

#endif

		return retval;

	} else {

#ifdef IO_GIFDEBUG

/*  		g_print ("\tlooking for %d bytes.  size == %d, ptr == %d\n", len, context->size, context->ptr); */

#endif

		if ((context->size - context->ptr) >= len) {

#ifdef IO_GIFDEBUG

			count += len;

#endif

			memcpy (buffer, context->buf + context->ptr, len);

			context->ptr += len;

			context->amount_needed = 0;

#ifdef IO_GIFDEBUG

			g_print ("Psize :%d\tcount :%d\t", len, count);

			if (len < 100) {

				for (i = 0; i < len; i++)

					g_print ("%d ", buffer[i]);

			}

			g_print ("\n");

#endif

			return TRUE;

		}

		context->amount_needed = len - (context->size - context->ptr);

	}

	return FALSE;

}

/* Changes the stage to be GIF_GET_COLORMAP */

static void

gif_set_get_colormap (GifContext *context)

{

	context->global_colormap_size = 0;

	context->state = GIF_GET_COLORMAP;

}

static void

gif_set_get_colormap2 (GifContext *context)

{

	context->frame_colormap_size = 0;

	context->state = GIF_GET_COLORMAP2;

}

static gint

gif_get_colormap (GifContext *context)

{

	unsigned char rgb[3];

	while (context->global_colormap_size < context->global_bit_pixel) {

		if (!gif_read (context, rgb, sizeof (rgb))) {

			return -1;

		}

		context->global_color_map[0][context->global_colormap_size] = rgb[0];

		context->global_color_map[1][context->global_colormap_size] = rgb[1];

		context->global_color_map[2][context->global_colormap_size] = rgb[2];

                if (context->global_colormap_size == context->background_index) {

                        context->animation->bg_red = rgb[0];

                        context->animation->bg_green = rgb[1];

                        context->animation->bg_blue = rgb[2];

                }

		context->global_colormap_size ++;

	}

	return 0;

}

static gint

gif_get_colormap2 (GifContext *context)

{

	unsigned char rgb[3];

	while (context->frame_colormap_size < context->frame_bit_pixel) {

		if (!gif_read (context, rgb, sizeof (rgb))) {

			return -1;

		}

		context->frame_color_map[0][context->frame_colormap_size] = rgb[0];

		context->frame_color_map[1][context->frame_colormap_size] = rgb[1];

		context->frame_color_map[2][context->frame_colormap_size] = rgb[2];

		context->frame_colormap_size ++;

	}

	return 0;

}

/*

 * in order for this function to work, we need to perform some black magic.

 * We want to return -1 to let the calling function know, as before, that it needs

 * more bytes.  If we return 0, we were able to successfully read all block->count bytes.

 * Problem is, we don't want to reread block_count every time, so we check to see if

 * context->block_count is 0 before we read in the function.

 *

 * As a result, context->block_count MUST be 0 the first time the get_data_block is called

 * within a context, and cannot be 0 the second time it's called.

 */

static int

get_data_block (GifContext *context,

		unsigned char *buf,

		gint *empty_block)

{

	if (context->block_count == 0) {

		if (!gif_read (context, &context->block_count, 1)) {

			return -1;

		}

	}

	if (context->block_count == 0)

		if (empty_block) {

			*empty_block = TRUE;

			return 0;

		}

	if (!gif_read (context, buf, context->block_count)) {

		return -1;

	}

	return 0;

}

static void

gif_set_get_extension (GifContext *context)

{

	context->state = GIF_GET_EXTENSION;

	context->extension_flag = TRUE;

	context->extension_label = 0;

	context->block_count = 0;

	context->block_ptr = 0;

}

static int

gif_get_extension (GifContext *context)

{

	gint retval;

	gint empty_block = FALSE;

	if (context->extension_flag) {

		if (context->extension_label == 0) {

			/* I guess bad things can happen if we have an extension of 0 )-: */

			/* I should look into this sometime */

			if (!gif_read (context, & context->extension_label , 1)) {

				return -1;

			}

		}

		switch (context->extension_label) {

                case 0xf9:			/* Graphic Control Extension */

                        retval = get_data_block (context, (unsigned char *) context->block_buf, NULL);

			if (retval != 0)

				return retval;

			if (context->frame == NULL) {

				/* I only want to set the transparency if I haven't

				 * created the frame yet.

                                 */

				context->gif89.disposal = (context->block_buf[0] >> 2) & 0x7;

				context->gif89.input_flag = (context->block_buf[0] >> 1) & 0x1;

				context->gif89.delay_time = LM_to_uint (context->block_buf[1], context->block_buf[2]);

				if ((context->block_buf[0] & 0x1) != 0) {

					context->gif89.transparent = context->block_buf[3];

				} else {

					context->gif89.transparent = -1;

				}

			}

			/* Now we've successfully loaded this one, we continue on our way */

			context->block_count = 0;

			context->extension_flag = FALSE;

			break;

                case 0xff: /* application extension */

                        if (!context->in_loop_extension) { 

                                retval = get_data_block (context, (unsigned char *) context->block_buf, NULL);

                                if (retval != 0)

                                        return retval;

                                if (!strncmp ((gchar *)context->block_buf, "NETSCAPE2.0", 11) ||

                                    !strncmp ((gchar *)context->block_buf, "ANIMEXTS1.0", 11)) {

                                        context->in_loop_extension = TRUE;

                                }

                                context->block_count = 0;

                        }

                        if (context->in_loop_extension) {

                                do {

                                        retval = get_data_block (context, (unsigned char *) context->block_buf, &empty_block);

                                        if (retval != 0)

                                                return retval;

                                        if (context->block_buf[0] == 0x01) {

                                                context->animation->loop = context->block_buf[1] + (context->block_buf[2] << 8);

                                                if (context->animation->loop != 0) 

                                                        context->animation->loop++;

                                        }

                                        context->block_count = 0;

                                }

                                while (!empty_block);

                                context->in_loop_extension = FALSE;

                                context->extension_flag = FALSE;

                                return 0;

                        }

			break;                          

		default:

			/* Unhandled extension */

			break;

		}

	}

	/* read all blocks, until I get an empty block, in case there was an extension I didn't know about. */

	do {

		retval = get_data_block (context, (unsigned char *) context->block_buf, &empty_block);

		if (retval != 0)

			return retval;

		context->block_count = 0;

	} while (!empty_block);

	return 0;

}

static int ZeroDataBlock = FALSE;

/* @buf must be at least 255 bytes long. */

static int

GetDataBlock (GifContext *context,

	      unsigned char *buf)

{

/*  	unsigned char count; */

	if (!gif_read (context, &context->block_count, 1)) {

		/*g_message (_("GIF: error in getting DataBlock size\n"));*/

		return -1;

	}

	ZeroDataBlock = context->block_count == 0;

	if ((context->block_count != 0) && (!gif_read (context, buf, context->block_count))) {

		/*g_message (_("GIF: error in reading DataBlock\n"));*/

		return -1;

	}

	return context->block_count;

}

static void

gif_set_lzw_fill_buffer (GifContext *context)

{

	context->block_count = 0;

	context->old_state = context->state;

	context->state = GIF_LZW_FILL_BUFFER;

}

static int

gif_lzw_fill_buffer (GifContext *context)

{

	gint retval;

	if (context->code_done) {

		if (context->code_curbit >= context->code_lastbit) {

                        g_set_error_literal (context->error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                             _("GIF file was missing some data (perhaps it was truncated somehow?)"));

			return -2;

		}

                /* Is this supposed to be an error or what? */

		/* g_message ("trying to read more data after we've done stuff\n"); */

                g_set_error (context->error,

                             GDK_PIXBUF_ERROR,

                             GDK_PIXBUF_ERROR_FAILED,

                             _("Internal error in the GIF loader (%s)"),

                             G_STRLOC);

		return -2;

	}

	context->block_buf[0] = context->block_buf[context->code_last_byte - 2];

	context->block_buf[1] = context->block_buf[context->code_last_byte - 1];

	retval = get_data_block (context, &context->block_buf[2], NULL);

	if (retval == -1)

		return -1;

	if (context->block_count == 0)

		context->code_done = TRUE;

	context->code_last_byte = 2 + context->block_count;

	context->code_curbit = (context->code_curbit - context->code_lastbit) + 16;

	context->code_lastbit = (2 + context->block_count) * 8;

	context->state = context->old_state;

	return 0;

}

static int

get_code (GifContext *context,

	  int   code_size)

{

	int i, j, ret;

	if ((context->code_curbit + code_size) >= context->code_lastbit){

		gif_set_lzw_fill_buffer (context);

		return -3;

	}

	ret = 0;

	for (i = context->code_curbit, j = 0; j < code_size; ++i, ++j)

		ret |= ((context->block_buf[i / 8] & (1 << (i % 8))) != 0) << j;

	context->code_curbit += code_size;

	return ret;

}

static void

set_gif_lzw_clear_code (GifContext *context)

{

	context->state = GIF_LZW_CLEAR_CODE;

	context->lzw_code_pending = -1;

}

static int

gif_lzw_clear_code (GifContext *context)

{

	gint code;

	code = get_code (context, context->lzw_code_size);

	if (code == -3)

		return -0;

	context->lzw_firstcode = context->lzw_oldcode = code;

	context->lzw_code_pending = code;

	context->state = GIF_GET_LZW;

	return 0;

}

#define CHECK_LZW_SP() G_STMT_START {                                           \

        if ((guchar *)context->lzw_sp >=                                        \

            (guchar *)context->lzw_stack + sizeof (context->lzw_stack)) {       \

                 g_set_error_literal (context->error,                           \

                                      GDK_PIXBUF_ERROR,                         \

                                      GDK_PIXBUF_ERROR_CORRUPT_IMAGE,           \

                                      _("Stack overflow"));                     \

                return -2;                                                      \

        }                                                                       \

} G_STMT_END

static int

lzw_read_byte (GifContext *context)

{

	int code, incode;

	gint retval;

	gint my_retval;

	register int i;

	if (context->lzw_code_pending != -1) {

		retval = context->lzw_code_pending;

		context->lzw_code_pending = -1;

		return retval;

	}

	if (context->lzw_fresh) {

		context->lzw_fresh = FALSE;

		do {

			retval = get_code (context, context->lzw_code_size);

			if (retval < 0) {

				return retval;

			}

			context->lzw_firstcode = context->lzw_oldcode = retval;

		} while (context->lzw_firstcode == context->lzw_clear_code);

		return context->lzw_firstcode;

	}

	if (context->lzw_sp > context->lzw_stack) {

		my_retval = *--(context->lzw_sp);

		return my_retval;

	}

	while ((code = get_code (context, context->lzw_code_size)) >= 0) {

		if (code == context->lzw_clear_code) {

			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][i] = 0;

			context->lzw_code_size = context->lzw_set_code_size + 1;

			context->lzw_max_code_size = 2 * context->lzw_clear_code;

			context->lzw_max_code = context->lzw_clear_code + 2;

			context->lzw_sp = context->lzw_stack;

			set_gif_lzw_clear_code (context);

			return -3;

		} else if (code == context->lzw_end_code) {

			int count;

			unsigned char buf[260];

                        /*  FIXME - we should handle this case */

                        g_set_error_literal (context->error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_FAILED,

                                             _("GIF image loader cannot understand this image."));

                        return -2;

			if (ZeroDataBlock) {

				return -2;

			}

			while ((count = GetDataBlock (context, buf)) > 0)

				;

			if (count != 0) {

				/*g_print (_("GIF: missing EOD in data stream (common occurence)"));*/

				return -2;

			}

		}

		incode = code;

		if (code >= context->lzw_max_code) {

                        CHECK_LZW_SP ();

			*(context->lzw_sp)++ = context->lzw_firstcode;

			code = context->lzw_oldcode;

		}

		while (code >= context->lzw_clear_code) {

                        if (code >= (1 << MAX_LZW_BITS)) {

                                g_set_error_literal (context->error,

                                                     GDK_PIXBUF_ERROR,

                                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                                     _("Bad code encountered"));

				return -2;

                        }

                        CHECK_LZW_SP ();

			*(context->lzw_sp)++ = context->lzw_table[1][code];

			if (code == context->lzw_table[0][code]) {

                                g_set_error_literal (context->error,

                                                     GDK_PIXBUF_ERROR,

                                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                                     _("Circular table entry in GIF file"));

				return -2;

			}

			code = context->lzw_table[0][code];

		}

                CHECK_LZW_SP ();

		*(context->lzw_sp)++ = context->lzw_firstcode = context->lzw_table[1][code];

		if ((code = context->lzw_max_code) < (1 << MAX_LZW_BITS)) {

			context->lzw_table[0][code] = context->lzw_oldcode;

			context->lzw_table[1][code] = context->lzw_firstcode;

			++context->lzw_max_code;

			if ((context->lzw_max_code >= context->lzw_max_code_size) &&

			    (context->lzw_max_code_size < (1 << MAX_LZW_BITS))) {

				context->lzw_max_code_size *= 2;

				++context->lzw_code_size;

			}

		}

		context->lzw_oldcode = incode;

		if (context->lzw_sp > context->lzw_stack) {

			my_retval = *--(context->lzw_sp);

			return my_retval;

		}

	}

	return code;

}

static void

gif_set_get_lzw (GifContext *context)

{

	context->state = GIF_GET_LZW;

	context->draw_xpos = 0;

	context->draw_ypos = 0;

	context->draw_pass = 0;

}

static void

gif_fill_in_pixels (GifContext *context, guchar *dest, gint offset, guchar v)

{

	guchar *pixel = NULL;

        guchar (*cmap)[MAXCOLORMAPSIZE];

        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 {

                        int rowstride;

                        guint64 len;

                        rowstride = gdk_pixbuf_calculate_rowstride (GDK_COLORSPACE_RGB,

                                                                    TRUE,

                                                                    8,

                                                                    context->frame_len,

                                                                    context->frame_height);

                        if (rowstride > 0 &&

                            g_uint64_checked_mul (&len, rowstride, context->frame_height) &&

                            len <= G_MAXINT) {

                                context->frame->pixbuf =

                                        gdk_pixbuf_new (GDK_COLORSPACE_RGB,

                                                        TRUE,

                                                        8,

                                                        context->frame_len,

                                                        context->frame_height);

                        } else {

                                context->frame->pixbuf = NULL;

                        }

                }

                if (!context->frame->pixbuf) {

                        g_free (context->frame);

                        g_set_error_literal (context->error,

                                             GDK_PIXBUF_ERROR,