/**

 * File: GIF Input

 *

 * Read GIF images.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <math.h>

#include <string.h>

#include <stdlib.h>

#include "gd.h"

/* Used only when debugging GIF compression code */

/* #define DEBUGGING_ENVARS */

#ifdef DEBUGGING_ENVARS

static int verbose_set = 0;

static int verbose;

#define VERBOSE (verbose_set ? verbose : set_verbose())

static int set_verbose(void)

{

	verbose = !!getenv("GIF_VERBOSE");

	verbose_set = 1;

	return(verbose);

}

#else

#define VERBOSE	0

#endif

#define MAXCOLORMAPSIZE	256

#define TRUE	1

#define FALSE	0

#define CM_RED		0

#define CM_GREEN	1

#define CM_BLUE		2

#define MAX_LWZ_BITS	12

#define INTERLACE		0x40

#define LOCALCOLORMAP	0x80

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

#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) > 0)

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

/* We may eventually want to use this information, but def it out for now */

#if 0

static struct {

	unsigned int    Width;

	unsigned int    Height;

	unsigned char   ColorMap[3][MAXCOLORMAPSIZE];

	unsigned int    BitPixel;

	unsigned int    ColorResolution;

	unsigned int    Background;

	unsigned int    AspectRatio;

} GifScreen;

#endif

#if 0

static struct {

	int     transparent;

	int     delayTime;

	int     inputFlag;

	int     disposal;

} Gif89 = { -1, -1, -1, 0 };

#endif

#define STACK_SIZE ((1<<(MAX_LWZ_BITS))*2)

#define CSD_BUF_SIZE 280

typedef struct {

	unsigned char buf[CSD_BUF_SIZE];

	int curbit;

	int lastbit;

	int done;

	int last_byte;

} CODE_STATIC_DATA;

typedef struct {

	int fresh;

	int code_size, set_code_size;

	int max_code, max_code_size;

	int firstcode, oldcode;

	int clear_code, end_code;

	int table[2][(1<< MAX_LWZ_BITS)];

	int stack[STACK_SIZE], *sp;

	CODE_STATIC_DATA scd;

} LZW_STATIC_DATA;

static int ReadColorMap (gdIOCtx *fd, int number, unsigned char (*buffer)[256]);

static int DoExtension (gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP);

static int GetDataBlock (gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP);

static int GetCode (gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP);

static int LWZReadByte (gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP);

static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace, int *ZeroDataBlockP); /*1.4//, int ignore); */

/*

  Function: gdImageCreateFromGif

    <gdImageCreateFromGif> is called to load images from GIF format

    files. Invoke <gdImageCreateFromGif> with an already opened

    pointer to a file containing the desired

    image.

    <gdImageCreateFromGif> returns a <gdImagePtr> to the new image, or

    NULL if unable to load the image (most often because the file is

    corrupt or does not contain a GIF image). <gdImageCreateFromGif>

    does not close the file. You can inspect the sx and sy members of

    the image to determine its size. The image must eventually be

    destroyed using <gdImageDestroy>.

  Variants:

    <gdImageCreateFromGifPtr> creates an image from GIF data (i.e. the

    contents of a GIF file) already in memory.

    <gdImageCreateFromGifCtx> reads in an image using the functions in

    a <gdIOCtx> struct.

  Parameters:

    infile - The input FILE pointer

  Returns:

    A pointer to the new image or NULL if an error occurred.

  Example:

    > gdImagePtr im;

    > ... inside a function ...

    > FILE *in;

    > in = fopen("mygif.gif", "rb");

    > im = gdImageCreateFromGif(in);

    > fclose(in);

    > // ... Use the image ... 

    > gdImageDestroy(im);

*/

BGD_DECLARE(gdImagePtr) gdImageCreateFromGif(FILE *fdFile)

{

	gdIOCtx *fd = gdNewFileCtx(fdFile);

	gdImagePtr im;

	if (fd == NULL) return NULL;

	im = gdImageCreateFromGifCtx(fd);

	fd->gd_free(fd);

	return im;

}

/*

  Function: gdImageCreateFromGifPtr

  Parameters:

    size - size of GIF data in bytes.

    data - GIF data (i.e. contents of a GIF file).

  See <gdImageCreateFromGif>.

*/

BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr (int size, void *data)

{

	gdImagePtr im;

	gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);

	if(!in) {

		return 0;

	}

	im = gdImageCreateFromGifCtx(in);

	in->gd_free(in);

	return im;

}

/*

  Function: gdImageCreateFromGifCtx

  See <gdImageCreateFromGif>.

*/

BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx(gdIOCtxPtr fd)

{

	int BitPixel;

#if 0

	int ColorResolution;

	int Background;

	int AspectRatio;

#endif

	int Transparent = (-1);

	unsigned char buf[16];

	unsigned char c;

	unsigned char ColorMap[3][MAXCOLORMAPSIZE];

	unsigned char localColorMap[3][MAXCOLORMAPSIZE];

	int imw, imh, screen_width, screen_height;

	int useGlobalColormap;

	int bitPixel, i;

	/*1.4//int             imageCount = 0; */

	/* 2.0.28: threadsafe storage */

	int ZeroDataBlock = FALSE;

	int haveGlobalColormap;

	gdImagePtr im = 0;

	memset(ColorMap, 0, 3 * MAXCOLORMAPSIZE);

	memset(localColorMap, 0, 3 * MAXCOLORMAPSIZE);

	if(!ReadOK(fd, buf, 6)) {

		return 0;

	}

	if(strncmp((char *)buf, "GIF", 3) != 0) {

		return 0;

	}

	if(memcmp((char *)buf + 3, "87a", 3) == 0) {

		/* GIF87a */

	} else if(memcmp((char *)buf + 3, "89a", 3) == 0) {

		/* GIF89a */

	} else {

		return 0;

	}

	if(!ReadOK(fd, buf, 7)) {

		return 0;

	}

	BitPixel = 2 << (buf[4] & 0x07);

#if 0

	ColorResolution = (int) (((buf[4]&0x70)>>3)+1);

	Background = buf[5];

	AspectRatio = buf[6];

#endif

	screen_width = imw = LM_to_uint(buf[0], buf[1]);

	screen_height = imh = LM_to_uint(buf[2], buf[3]);

	haveGlobalColormap = BitSet(buf[4], LOCALCOLORMAP); /* Global Colormap */

	if(haveGlobalColormap) {

		if(ReadColorMap(fd, BitPixel, ColorMap)) {

			return 0;

		}

	}

	for (;;) {

		int top, left;

		int width, height;

		if(!ReadOK(fd, &c, 1)) {

			return 0;

		}

		if (c == ';') { /* GIF terminator */

			goto terminated;

		}

		if(c == '!') { /* Extension */

			if(!ReadOK(fd, &c, 1)) {

				return 0;

			}

			DoExtension(fd, c, &Transparent, &ZeroDataBlock);

			continue;

		}

		if(c != ',') { /* Not a valid start character */

			continue;

		}

		/*1.4//++imageCount; */

		if(!ReadOK(fd, buf, 9)) {

			return 0;

		}

		useGlobalColormap = !BitSet(buf[8], LOCALCOLORMAP);

		bitPixel = 1 << ((buf[8] & 0x07) + 1);

		left = LM_to_uint(buf[0], buf[1]);

		top = LM_to_uint(buf[2], buf[3]);

		width = LM_to_uint(buf[4], buf[5]);

		height = LM_to_uint(buf[6], buf[7]);

		if(((left + width) > screen_width) || ((top + height) > screen_height)) {

			if(VERBOSE) {

				printf("Frame is not confined to screen dimension.\n");

			}

			return 0;

		}

		if(!(im = gdImageCreate(width, height))) {

			return 0;

		}

		im->interlace = BitSet(buf[8], INTERLACE);

		if(!useGlobalColormap) {

			if(ReadColorMap(fd, bitPixel, localColorMap)) {

				gdImageDestroy(im);

				return 0;

			}

			ReadImage(im, fd, width, height, localColorMap, BitSet(buf[8], INTERLACE), &ZeroDataBlock);

		} else {

			if(!haveGlobalColormap) {

				gdImageDestroy(im);

				return 0;

			}

			ReadImage(im, fd, width, height, ColorMap, BitSet(buf[8], INTERLACE), &ZeroDataBlock);

		}

		if(Transparent != (-1)) {

			gdImageColorTransparent(im, Transparent);

		}

		goto terminated;

	}

terminated:

	/* Terminator before any image was declared! */

	if(!im) {

		return 0;

	}

	/* Check for open colors at the end, so

	 * we can reduce colorsTotal and ultimately

	 * BitsPerPixel */

	for(i = im->colorsTotal - 1; i >= 0; i--) {

		if(im->open[i]) {

			im->colorsTotal--;

		} else {

			break;

		}

	}

	if(!im->colorsTotal) {

		gdImageDestroy(im);

		return 0;

	}

	return im;

}

static int

ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256])

{

	int i;

	unsigned char rgb[3];

	for(i = 0; i < number; ++i) {

		if(!ReadOK(fd, rgb, sizeof(rgb))) {

			return TRUE;

		}

		buffer[CM_RED][i] = rgb[0];

		buffer[CM_GREEN][i] = rgb[1];

		buffer[CM_BLUE][i] = rgb[2];

	}

	return FALSE;

}

static int

DoExtension(gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP)

{

	unsigned char buf[256];

	switch(label) {

	case 0xf9: /* Graphic Control Extension */

		memset(buf, 0, 4); /* initialize a few bytes in the case the next function fails */

		(void) GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP);

#if 0

		Gif89.disposal  = (buf[0] >> 2) & 0x7;

		Gif89.inputFlag = (buf[0] >> 1) & 0x1;

		Gif89.delayTime = LM_to_uint(buf[1], buf[2]);

#endif

		if((buf[0] & 0x1) != 0) {

			*Transparent = buf[3];

		}

		while(GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) > 0);

		return FALSE;

	default:

		break;

	}

	while(GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) > 0);

	return FALSE;

}

static int

GetDataBlock_(gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP)

{

	unsigned char count;

	if(!ReadOK(fd, &count, 1)) {

		return -1;

	}

	*ZeroDataBlockP = count == 0;

	if((count != 0) && (!ReadOK(fd, buf, count))) {

		return -1;

	}

	return count;

}

static int

GetDataBlock(gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP)

{

	int rv, i;

	rv = GetDataBlock_(fd,buf, ZeroDataBlockP);

	if(VERBOSE) {

		printf("[GetDataBlock returning %d",rv);

		if(rv > 0) {

			printf(":");

			for(i = 0; i < rv; i++) {

				printf(" %02x",buf[i]);

			}

		}

		printf("]\n");

	}

	return rv;

}

static int

GetCode_(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP)

{

	int i, j, ret;

	int count;

	if(flag) {

		scd->curbit = 0;

		scd->lastbit = 0;

		scd->last_byte = 2;

		scd->done = FALSE;

		return 0;

	}

	if((scd->curbit + code_size) >= scd->lastbit) {

		if(scd->done) {

			if(scd->curbit >= scd->lastbit) {

				/* Oh well */

			}

			return -1;

		}

		scd->buf[0] = scd->buf[scd->last_byte - 2];

		scd->buf[1] = scd->buf[scd->last_byte - 1];

		if((count = GetDataBlock(fd, &scd->buf[2], ZeroDataBlockP)) <= 0) {

			scd->done = TRUE;

		}

		scd->last_byte = 2 + count;

		scd->curbit = (scd->curbit - scd->lastbit) + 16;

		scd->lastbit = (2 + count) * 8;

	}

	if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) {

		ret = -1;

	} else {

		ret = 0;

		for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) {

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

		}

	}

	scd->curbit += code_size;

	return ret;

}

static int

GetCode(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP)

{

	int rv;

	rv = GetCode_(fd, scd, code_size,flag, ZeroDataBlockP);

	if(VERBOSE) {

		printf("[GetCode(,%d,%d) returning %d]\n",code_size,flag,rv);

	}

	return rv;

}

static int

LWZReadByte_(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP)

{

	int code, incode, i;

	if(flag) {

		sd->set_code_size = input_code_size;

		sd->code_size = sd->set_code_size + 1;

		sd->clear_code = 1 << sd->set_code_size;

		sd->end_code = sd->clear_code + 1;

		sd->max_code_size = 2 * sd->clear_code;

		sd->max_code = sd->clear_code + 2;

		GetCode(fd, &sd->scd, 0, TRUE, ZeroDataBlockP);

		sd->fresh = TRUE;

		for(i = 0; i < sd->clear_code; ++i) {

			sd->table[0][i] = 0;

			sd->table[1][i] = i;

		}

		for(; i < (1 << MAX_LWZ_BITS); ++i) {

			sd->table[0][i] = sd->table[1][0] = 0;

		}

		sd->sp = sd->stack;

		return 0;

	} else if(sd->fresh) {

		sd->fresh = FALSE;

		do {

			sd->firstcode = sd->oldcode =

			                    GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);

		} while(sd->firstcode == sd->clear_code);

		return sd->firstcode;

	}

	if(sd->sp > sd->stack) {

		return *--sd->sp;

	}

	while((code = GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP)) >= 0) {

		if(code == sd->clear_code) {

			for(i = 0; i < sd->clear_code; ++i) {

				sd->table[0][i] = 0;

				sd->table[1][i] = i;

			}

			for (; i < (1 << MAX_LWZ_BITS); ++i) {

				sd->table[0][i] = sd->table[1][i] = 0;

			}

			sd->code_size = sd->set_code_size + 1;

			sd->max_code_size = 2 * sd->clear_code;

			sd->max_code = sd->clear_code + 2;

			sd->sp = sd->stack;

			sd->firstcode = sd->oldcode =

			                    GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);

			return sd->firstcode;

		} else if(code == sd->end_code) {

			int count;

			unsigned char buf[260];

			if(*ZeroDataBlockP) {

				return -2;

			}

			while((count = GetDataBlock(fd, buf, ZeroDataBlockP)) > 0);

			if(count != 0) {

				return -2;

			}

		}

		incode = code;

		if(sd->sp == (sd->stack + STACK_SIZE)) {

			/* Bad compressed data stream */

			return -1;

		}

		if(code >= sd->max_code) {

			*sd->sp++ = sd->firstcode;

			code = sd->oldcode;

		}

		while(code >= sd->clear_code) {

			if(sd->sp == (sd->stack + STACK_SIZE)) {

				/* Bad compressed data stream */

				return -1;

			}

			*sd->sp++ = sd->table[1][code];

			if(code == sd->table[0][code]) {

				/* Oh well */

			}

			code = sd->table[0][code];

		}

		*sd->sp++ = sd->firstcode = sd->table[1][code];

		if((code = sd->max_code) < (1 << MAX_LWZ_BITS)) {

			sd->table[0][code] = sd->oldcode;

			sd->table[1][code] = sd->firstcode;

			++sd->max_code;

			if((sd->max_code >= sd->max_code_size) && (sd->max_code_size < (1<

				sd->max_code_size *= 2;

				++sd->code_size;

			}

		}

		sd->oldcode = incode;

		if(sd->sp > sd->stack) {

			return *--sd->sp;

		}

	}

	return code;

}

static int

LWZReadByte(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP)

{

	int rv;

	rv = LWZReadByte_(fd, sd, flag, input_code_size, ZeroDataBlockP);

	if(VERBOSE) {

		printf("[LWZReadByte(,%d,%d) returning %d]\n",flag,input_code_size,rv);

	}

	return rv;

}

static void

ReadImage(gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace, int *ZeroDataBlockP) /*1.4//, int ignore) */

{

	unsigned char c;

	int xpos = 0, ypos = 0, pass = 0;

	int v, i;

	LZW_STATIC_DATA sd;

	/* Initialize the Compression routines */

	if(!ReadOK(fd, &c, 1)) {

		return;

	}

	if(c > MAX_LWZ_BITS) {

		return;

	}

	/* Stash the color map into the image */

	for(i=0; (i < gdMaxColors); i++) {

		im->red[i] = cmap[CM_RED][i];

		im->green[i] = cmap[CM_GREEN][i];

		im->blue[i] = cmap[CM_BLUE][i];

		im->open[i] = 1;

	}

	/* Many (perhaps most) of these colors will remain marked open. */

	im->colorsTotal = gdMaxColors;

	if(LWZReadByte(fd, &sd, TRUE, c, ZeroDataBlockP) < 0) {

		return;

	}

	/*

	**  If this is an "uninteresting picture" ignore it.

	**  REMOVED For 1.4

	*/

	/*if (ignore) { */

	/*        while (LWZReadByte(fd, &sd, FALSE, c) >= 0) */

	/*                ; */

	/*        return; */

	/*} */

	while((v = LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP)) >= 0 ) {

		if(v >= gdMaxColors) {

			v = 0;

		}

		/* This how we recognize which colors are actually used. */

		if(im->open[v]) {

			im->open[v] = 0;

		}

		gdImageSetPixel(im, xpos, ypos, 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(ypos >= height) {

			break;

		}

	}

fini:

	if(LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP) >=0) {

		/* Ignore extra */

	}

}