/*
 * The Python Imaging Library.
 * $Id$
 *
 * encoder for uncompressed GIF data
 *
 * history:
 * 97-01-05 fl created (writes uncompressed data)
 * 97-08-27 fl fixed off-by-one error in buffer size test
 * 98-07-09 fl added interlace write support
 * 99-02-07 fl rewritten, now uses a run-length encoding strategy
 * 99-02-08 fl improved run-length encoding for long runs
 *
 * Copyright (c) Secret Labs AB 1997-99.
 * Copyright (c) Fredrik Lundh 1997.
 *
 * See the README file for information on usage and redistribution.
 */

#include "Imaging.h"

#include "Gif.h"

/* codes from 0 to 255 are literals */
#define CLEAR_CODE 256
#define EOF_CODE 257
#define FIRST_CODE 258
#define LAST_CODE 511

enum { INIT, ENCODE, ENCODE_EOF, FLUSH, EXIT };

/* to make things a little less complicated, we use a simple output
   queue to hold completed blocks.  the following inlined function
   adds a byte to the current block.  it allocates a new block if
   necessary. */

static inline int
emit(GIFENCODERSTATE *context, int byte)
{
    /* write a byte to the output buffer */

    if (!context->block || context->block->size == 255) {
        GIFENCODERBLOCK* block;

        /* no room in the current block (or no current block);
           allocate a new one */

        /* add current block to end of flush queue */
        if (context->block) {
            block = context->flush;
            while (block && block->next) {
                block = block->next;
            }
            if (block) {
                block->next = context->block;
            } else {
                context->flush = context->block;
            }
        }

        /* get a new block */
        if (context->free) {
            block = context->free;
            context->free = NULL;
        } else {
            /* malloc check ok, small constant allocation */
            block = malloc(sizeof(GIFENCODERBLOCK));
            if (!block) {
                return 0;
            }
        }

        block->size = 0;
        block->next = NULL;

        context->block = block;

    }

    /* write new byte to block */
    context->block->data[context->block->size++] = byte;

    return 1;
}

/* write a code word to the current block.  this is a macro to make
   sure it's inlined on all platforms */

#define EMIT(code) {\
    context->bitbuffer |= ((INT32) (code)) << context->bitcount;\
    context->bitcount += 9;\
    while (context->bitcount >= 8) {\
        if (!emit(context, (UINT8) context->bitbuffer)) {\
            state->errcode = IMAGING_CODEC_MEMORY;\
            return 0;\
        }\
        context->bitbuffer >>= 8;\
        context->bitcount -= 8;\
    }\
}

/* write a run.  we use a combination of literals and combinations of
   literals.  this can give quite decent compression for images with
   long stretches of identical pixels.  but remember: if you want
   really good compression, use another file format. */

#define EMIT_RUN(label) {\
label:\
    while (context->count > 0) {\
        int run = 2;\
        EMIT(context->last);\
        context->count--;\
        if (state->count++ == LAST_CODE) {\
            EMIT(CLEAR_CODE);\
            state->count = FIRST_CODE;\
            goto label;\
        }\
        while (context->count >= run) {\
            EMIT(state->count - 1);\
            context->count -= run;\
            run++;\
            if (state->count++ == LAST_CODE) {\
                EMIT(CLEAR_CODE);\
                state->count = FIRST_CODE;\
                goto label;\
            }\
        }\
        if (context->count > 1) {\
            EMIT(state->count - 1 - (run - context->count));\
            context->count = 0;\
            if (state->count++ == LAST_CODE) {\
                EMIT(CLEAR_CODE);\
                state->count = FIRST_CODE;\
            }\
            break;\
        }\
    }\
}

int
ImagingGifEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
    UINT8* ptr;
    int this;

    GIFENCODERBLOCK* block;
    GIFENCODERSTATE *context = (GIFENCODERSTATE*) state->context;

    if (!state->state) {

        /* place a clear code in the output buffer */
        context->bitbuffer = CLEAR_CODE;
        context->bitcount = 9;

        state->count = FIRST_CODE;

        if (context->interlace) {
            context->interlace = 1;
            context->step = 8;
        } else {
            context->step = 1;
        }

        context->last = -1;

        /* sanity check */
        if (state->xsize <= 0 || state->ysize <= 0) {
            state->state = ENCODE_EOF;
        }

    }

    ptr = buf;

    for (;;)

        switch (state->state) {

            case INIT:
            case ENCODE:

                /* identify and store a run of pixels */

                if (state->x == 0 || state->x >= state->xsize) {

                    if (!context->interlace && state->y >= state->ysize) {
                        state->state = ENCODE_EOF;
                        break;
                    }

                    if (context->flush) {
                        state->state = FLUSH;
                        break;
                    }

                    /* get another line of data */
                    state->shuffle(
                        state->buffer,
                        (UINT8*) im->image[state->y + state->yoff] +
                        state->xoff * im->pixelsize, state->xsize
                    );

                    state->x = 0;

                    if (state->state == INIT) {
                        /* preload the run-length buffer and get going */
                        context->last = state->buffer[0];
                        context->count = state->x = 1;
                        state->state = ENCODE;
                    }

                    /* step forward, according to the interlace settings */
                    state->y += context->step;
                    while (context->interlace && state->y >= state->ysize)
                        switch (context->interlace) {
                            case 1:
                                state->y = 4;
                                context->interlace = 2;
                                break;
                            case 2:
                                context->step = 4;
                                state->y = 2;
                                context->interlace = 3;
                                break;
                            case 3:
                                context->step = 2;
                                state->y = 1;
                                context->interlace = 0;
                                break;
                            default:
                                /* just make sure we don't loop forever */
                                context->interlace = 0;
                        }

                }

                this = state->buffer[state->x++];

                if (this == context->last) {
                    context->count++;
                } else {
                    EMIT_RUN(label1);
                    context->last = this;
                    context->count = 1;
                }
                break;


            case ENCODE_EOF:

                /* write the final run */
                EMIT_RUN(label2);

                /* write an end of image marker */
                EMIT(EOF_CODE);

                /* empty the bit buffer */
                while (context->bitcount > 0) {
                    if (!emit(context, (UINT8) context->bitbuffer)) {
                        state->errcode = IMAGING_CODEC_MEMORY;
                        return 0;
                    }
                    context->bitbuffer >>= 8;
                    context->bitcount -= 8;
                }

                /* flush the last block, and exit */
                if (context->block) {
                    GIFENCODERBLOCK* block;
                    block = context->flush;
                    while (block && block->next) {
                        block = block->next;
                    }
                    if (block) {
                        block->next = context->block;
                    } else {
                        context->flush = context->block;
                    }
                    context->block = NULL;
                }

                state->state = EXIT;

                /* fall through... */

            case EXIT:
            case FLUSH:

                    while (context->flush) {

                        /* get a block from the flush queue */
                        block = context->flush;

                        if (block->size > 0) {

                            /* make sure it fits into the output buffer */
                            if (bytes < block->size+1) {
                                return ptr - buf;
                            }

                            ptr[0] = block->size;
                            memcpy(ptr+1, block->data, block->size);

                            ptr += block->size+1;
                            bytes -= block->size+1;

                        }

                        context->flush = block->next;

                        if (context->free) {
                            free(context->free);
                        }
                        context->free = block;

                    }

                    if (state->state == EXIT) {
                        /* this was the last block! */
                        if (context->free) {
                            free(context->free);
                        }
                        state->errcode = IMAGING_CODEC_END;
                        return ptr - buf;
                    }

                    state->state = ENCODE;
                    break;
    }
}