/*
 * The Python Imaging Library.
 * $Id$
 *
 * a fast, suspendable GIF decoder
 *
 * history:
 * 95-09-03 fl	Created
 * 95-09-05 fl	Fixed sign problem on 16-bit platforms
 * 95-09-13 fl	Added some storage shortcuts
 * 96-03-28 fl	Revised API, integrated with PIL
 * 96-12-10 fl	Added interlace support
 * 96-12-16 fl	Fixed premature termination bug introduced by last fix
 * 97-01-05 fl	Don't mess up on bogus configuration
 * 97-01-17 fl	Don't mess up on very small, interlaced files
 * 99-02-07 fl	Minor speedups
 *
 * Copyright (c) Secret Labs AB 1997-99.
 * Copyright (c) Fredrik Lundh 1995-97.
 *
 * See the README file for information on usage and redistribution.
 */


#include "Imaging.h"

#include <stdio.h>
#include <memory.h>	/* memcpy() */

#include "Gif.h"


#define NEWLINE(state, context) {\
    state->x = 0;\
    state->y += context->step;\
    while (state->y >= state->ysize)\
	switch (context->interlace) {\
	case 1:\
	    context->repeat = state->y = 4;\
	    context->interlace = 2;\
	    break;\
	case 2:\
	    context->step = 4;\
	    context->repeat = state->y = 2;\
	    context->interlace = 3;\
	    break;\
	case 3:\
	    context->step = 2;\
	    context->repeat = state->y = 1;\
	    context->interlace = 0;\
	    break;\
	default:\
	    return -1;\
        }\
    if (state->y < state->ysize)\
        out = im->image8[state->y + state->yoff] + state->xoff;\
}


int
ImagingGifDecode(Imaging im, ImagingCodecState state, UINT8* buffer, int bytes)
{
    UINT8* p;
    UINT8* out;
    int c, i;
    int thiscode;
    GIFDECODERSTATE *context = (GIFDECODERSTATE*) state->context;

    UINT8 *ptr = buffer;

    if (!state->state) {

	/* Initialise state */
	if (context->bits < 0 || context->bits > 8) {
	    state->errcode = IMAGING_CODEC_CONFIG;
	    return -1;
	}
					
	/* Clear code */
	context->clear = 1 << context->bits;

	/* End code */
	context->end = context->clear + 1;

	/* Interlace */
	if (context->interlace) {
	    context->interlace = 1;
	    context->step = context->repeat = 8;
	} else
	    context->step = 1;

	state->state = 1;
    }

    out = im->image8[state->y + state->yoff] + state->xoff + state->x;

    for (;;) {

	if (state->state == 1) {

	    /* First free entry in table */
	    context->next = context->clear + 2;

	    /* Initial code size */
	    context->codesize = context->bits + 1;
	    context->codemask = (1 << context->codesize) - 1;

	    /* Buffer pointer.  We fill the buffer from right, which
	       allows us to return all of it in one operation. */
	    context->bufferindex = GIFBUFFER;

	    state->state = 2;
	}

	if (context->bufferindex < GIFBUFFER) {

	    /* Return whole buffer in one chunk */
	    i = GIFBUFFER - context->bufferindex;
	    p = &context->buffer[context->bufferindex];

	    context->bufferindex = GIFBUFFER;

	} else {

	    /* Get current symbol */

	    while (context->bitcount < context->codesize) {

		if (context->blocksize > 0) {

		    /* Read next byte */
		    c = *ptr++; bytes--;

		    context->blocksize--;

		    /* New bits are shifted in from from the left. */
		    context->bitbuffer |= (INT32) c << context->bitcount;
		    context->bitcount += 8;

		} else {

		    /* New GIF block */

		    /* We don't start decoding unless we have a full block */
		    if (bytes < 1)
			return ptr - buffer;
		    c = *ptr;
		    if (bytes < c+1)
			return ptr - buffer;

		    context->blocksize = c;

		    ptr++; bytes--;

		}
	    }

	    /* Extract current symbol from bit buffer. */
	    c = (int) context->bitbuffer & context->codemask;

	    /* Adjust buffer */
	    context->bitbuffer >>= context->codesize;
	    context->bitcount -= context->codesize;

	    /* If c is less than "clear", it's a data byte.  Otherwise,
	       it's either clear/end or a code symbol which should be
	       expanded. */

	    if (c == context->clear) {
		if (state->state != 2)
		    state->state = 1;
		continue;
	    }

	    if (c == context->end)
		break;

	    i = 1;
	    p = &context->lastdata;

	    if (state->state == 2) {

		/* First valid symbol after clear; use as is */
		if (c > context->clear) {
		    state->errcode = IMAGING_CODEC_BROKEN;
		    return -1;
		}

		context->lastdata = context->lastcode = c;
		state->state = 3;

	    } else {

		thiscode = c;

		if (c > context->next) {
		    state->errcode = IMAGING_CODEC_BROKEN;
		    return -1;
		}

		if (c == context->next) {

		    /* c == next is allowed. not sure why. */

		    if (context->bufferindex <= 0) {
			state->errcode = IMAGING_CODEC_BROKEN;
			return -1;
		    }

		    context->buffer[--context->bufferindex] =
			context->lastdata;

		    c = context->lastcode;

		}

		while (c >= context->clear) {

		    /* Copy data string to buffer (beginning from right) */

		    if (context->bufferindex <= 0 || c >= GIFTABLE) {
			state->errcode = IMAGING_CODEC_BROKEN;
			return -1;
		    }

		    context->buffer[--context->bufferindex] =
			context->data[c];

		    c = context->link[c];
		}

		context->lastdata = c;

		if (context->next < GIFTABLE) {

		    /* We'll only add this symbol if we have room
		       for it (take advise, Netscape!) */
		    context->data[context->next] = c;
		    context->link[context->next] = context->lastcode;

		    if (context->next == context->codemask &&
			context->codesize < GIFBITS) {

			/* Expand code size */
			context->codesize++;
			context->codemask = (1 << context->codesize) - 1;
		    }

		    context->next++;

		}

		context->lastcode = thiscode;

	    }
	}

	/* Copy the bytes into the image */
	if (state->y >= state->ysize) {
	    state->errcode = IMAGING_CODEC_OVERRUN;
	    return -1;
	}

	/* To squeeze some extra pixels out of this loop, we test for
	   some common cases and handle them separately. */

	/* FIXME: should we handle the transparency index in here??? */

	if (i == 1) {
	    if (state->x < state->xsize-1) {
		/* Single pixel, not at the end of the line. */
		*out++ = p[0];
		state->x++;
		continue;
	    }
	} else if (state->x + i <= state->xsize) {
	    /* This string fits into current line. */
	    memcpy(out, p, i);
            out += i;
	    state->x += i;
	    if (state->x == state->xsize) {
		NEWLINE(state, context);
	    }
	    continue;
	}

	/* No shortcut, copy pixel by pixel */
	for (c = 0; c < i; c++) {
	    *out++ = p[c];
	    if (++state->x >= state->xsize) {
		NEWLINE(state, context);
	    }
	}
    }

    return ptr - buffer;
}