Let the GIF writer use a real LZW compressor.

2 files changed, 325 insertions, 444 deletions

diff --git a/ChangeLog b/ChangeLog
index 6d5578c..610e634 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2008-04-09  Jan Nijtmans  <nijtmans@users.sourceforge.net>
+
+	* generic/tkImgGIF.c:  Let the GIF writer use a real LZW compressor.
+
 2008-04-08  Pat Thoyts  <patthoyts@users.sourceforge.net>
 
 	* win/ttkWinXpTheme.c:  Provide a visual-styles API element engine
diff --git a/generic/tkImgGIF.c b/generic/tkImgGIF.c
index b2b337c..9a823bf 100644
--- a/generic/tkImgGIF.c
+++ b/generic/tkImgGIF.c
@@ -32,7 +32,7 @@
  * This file also contains code from miGIF. See lower down in file for the
  * applicable copyright notice for that portion.
  *
- * RCS: @(#) $Id: tkImgGIF.c,v 1.42 2008/04/09 20:52:16 nijtmans Exp $
+ * RCS: @(#) $Id: tkImgGIF.c,v 1.43 2008/04/09 21:00:54 nijtmans Exp $
  */
 
 #include "tkInt.h"
@@ -1739,501 +1739,378 @@ ReadValue(
 }
 
 /*
- *-----------------------------------------------------------------------
  *
- * miGIF Compression - mouse and ivo's GIF-compatible compression
+ * GIF Image compression - modified 'compress'
  *
- *		-run length encoding compression routines-
+ * Based on: compress.c - File compression ala IEEE Computer, June 1984.
  *
- * Copyright (C) 1998 Hutchison Avenue Software Corporation
- *		 http://www.hasc.com
- *		 info@hasc.com
+ * By Authors:  Spencer W. Thomas       (decvax!harpo!utah-cs!utah-gr!thomas)
+ *              Jim McKie               (decvax!mcvax!jim)
+ *              Steve Davies            (decvax!vax135!petsd!peora!srd)
+ *              Ken Turkowski           (decvax!decwrl!turtlevax!ken)
+ *              James A. Woods          (decvax!ihnp4!ames!jaw)
+ *              Joe Orost               (decvax!vax135!petsd!joe)
  *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose and without fee is hereby granted, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation. This software is provided "AS IS." The Hutchison Avenue
- * Software Corporation disclaims all warranties, either express or implied,
- * including but not limited to implied warranties of merchantability and
- * fitness for a particular purpose, with respect to this code and
- * accompanying documentation.
- *
- * The miGIF compression routines do not, strictly speaking, generate files
- * conforming to the GIF spec, since the image data is not LZW-compressed
- * (this is the point: in order to avoid transgression of the Unisys patent on
- * the LZW algorithm.) However, miGIF generates data streams that any
- * reasonably sane LZW decompresser will decompress to what we want.
- *
- * miGIF compression uses run length encoding. It compresses horizontal runs
- * of pixels of the same color. This type of compression gives good results on
- * images with many runs, for example images with lines, text and solid shapes
- * on a solid-colored background. It gives little or no compression on images
- * with few runs, for example digital or scanned photos.
- *
- *				 der Mouse
- *			mouse@rodents.montreal.qc.ca
- *	      7D C8 61 52 5D E7 2D 39  4E F1 31 3E E8 B3 27 4B
- *
- *			       ivo@hasc.com
- *
- * The Graphics Interchange Format(c) is the Copyright property of CompuServe
- * Incorporated. GIF(sm) is a Service Mark property of CompuServe Incorporated.
- *
- *-----------------------------------------------------------------------
  */
 
+#define MAXCODE(n_bits)		(((long) 1 << (n_bits)) - 1)
+
 typedef struct {
-    int runlengthPixel;
-    int runlengthBaseCode;
-    int runlengthCount;
-    int runlengthTablePixel;
-    int runlengthTableMax;
-    int justCleared;
-    int outputBits;
-    int outputBitsInit;
-    int outputCount;
-    int outputBump;
-    int outputBumpInit;
-    int outputClear;
-    int outputClearInit;
-    int maxOcodes;
-    int codeClear;
-    int codeEOF;
-    unsigned int obuf;
-    int obits;
-    Tcl_Channel ofile;
-    unsigned char oblock[256];
-    int oblen;
-} miGIFState_t;
-
+    int n_bits;		/* number of bits/code */
+    long maxcode;		/* maximum code, given n_bits */
+    int		htab[HSIZE];
+    unsigned int	codetab[HSIZE];
+
+    long hsize;	/* for dynamic table sizing */
+
 /*
- * Used only when debugging GIF compression code
+ * To save much memory, we overlay the table used by compress() with those
+ * used by decompress().  The tab_prefix table is the same size and type
+ * as the codetab.  The tab_suffix table needs 2**GIFBITS characters.  We
+ * get this from the beginning of htab.  The output stack uses the rest
+ * of htab, and contains characters.  There is plenty of room for any
+ * possible stack (stack used to be 8000 characters).
  */
-/* #define MIGIF_DEBUGGING_ENVARS */
 
-#ifdef MIGIF_DEBUGGING_ENVARS
+    int free_ent;  /* first unused entry */
 
 /*
- * This debugging code is _absolutely_ not thread-safe. It's also not normally
- * enabled either.
+ * block compression parameters -- after all codes are used up,
+ * and compression rate changes, start over.
  */
+    int clear_flg;
 
-static int verboseSet = 0;
-static int verbose;
-#define MIGIF_VERBOSE		(verboseSet?verbose:setVerbose())
-#define DEBUGMSG(printfArgs)	if (MIGIF_VERBOSE) { printf printfArgs; }
+    int offset;
+    unsigned int in_count;            /* length of input */
+    unsigned int out_count;           /* # of codes output (for debugging) */
 
-static int
-setVerbose(void)
-{
-    verbose = !!getenv("MIGIF_VERBOSE");
-    verboseSet = 1;
-    return verbose;
-}
+/*
+ * compress stdin to stdout
+ *
+ * Algorithm:  use open addressing double hashing (no chaining) on the
+ * prefix code / next character combination.  We do a variant of Knuth's
+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+ * secondary probe.  Here, the modular division first probe is gives way
+ * to a faster exclusive-or manipulation.  Also do block compression with
+ * an adaptive reset, whereby the code table is cleared when the compression
+ * ratio decreases, but after the table fills.  The variable-length output
+ * codes are re-sized at this point, and a special CLEAR code is generated
+ * for the decompressor.  Late addition:  construct the table according to
+ * file size for noticeable speed improvement on small files.  Please direct
+ * questions about this implementation to ames!jaw.
+ */
+
+    int g_init_bits;
+    Tcl_Channel g_outfile;
+
+    int ClearCode;
+    int EOFCode;
+
+    unsigned long cur_accum;
+    int  cur_bits;
+
+/*
+ * Number of characters so far in this 'packet'
+ */
+    int a_count;
+
+/*
+ * Define the storage for the packet accumulator
+ */
+    unsigned char accum[256];
+} GIFState_t;
+
+static void output _ANSI_ARGS_((GIFState_t *statePtr, long code));
+static void cl_block _ANSI_ARGS_((GIFState_t *statePtr));
+static void cl_hash _ANSI_ARGS_((GIFState_t *statePtr, int hsize));
+static void char_init _ANSI_ARGS_((GIFState_t *statePtr));
+static void char_out _ANSI_ARGS_((GIFState_t *statePtr, int c));
+static void flush_char _ANSI_ARGS_((GIFState_t *statePtr));
+
+static void		compress(int initBits, Tcl_Channel handle,
+			    ifunptr readValue, GifWriterState *statePtr);
 
-static const char *
-binformat(
-    unsigned int v,
-    int nbits)
+static void compress(init_bits, handle, readValue, statePtr)
+    int init_bits;
+    Tcl_Channel handle;
+    ifunptr readValue;
+    GifWriterState *statePtr;
 {
-    static char bufs[8][64];
-    static int bhand = 0;
-    unsigned int bit;
-    int bno;
-    char *bp;
-
-    bhand--;
-    if (bhand < 0) {
-	bhand = (sizeof(bufs) / sizeof(bufs[0])) - 1;
-    }
-    bp = &bufs[bhand][0];
-    for (bno=nbits-1,bit=((unsigned int)1)<<bno ; bno>=0 ; bno--,bit>>=1) {
-	*bp++ = (v & bit) ? '1' : '0';
-	if (((bno&3) == 0) && (bno != 0)) {
-	    *bp++ = '.';
-	}
-    }
-    *bp = '\0';
-    return &bufs[bhand][0];
-}
-#else /* !MIGIF_DEBUGGING_ENVARS */
-#define DEBUGMSG(printfArgs) /* do nothing */
+    register long fcode;
+    register long i = 0;
+    register int c;
+    register long ent;
+    register long disp;
+    register long hsize_reg;
+    register int hshift;
+    GIFState_t state;
+
+    memset(&state, 0, sizeof(state));
+    /*
+     * Set up the globals:  g_init_bits - initial number of bits
+     *                      g_outfile   - pointer to output file
+     */
+    state.g_init_bits = init_bits;
+    state.g_outfile = handle;
+
+    /*
+     * Set up the necessary values
+     */
+    state.offset = 0;
+    state.hsize = HSIZE;
+    state.out_count = 0;
+    state.clear_flg = 0;
+    state.in_count = 1;
+    state.maxcode = MAXCODE(state.n_bits = state.g_init_bits);
+
+    state.ClearCode = (1 << (init_bits - 1));
+    state.EOFCode = state.ClearCode + 1;
+    state.free_ent = state.ClearCode + 2;
+
+    char_init(&state);
+
+    ent = readValue(statePtr);
+
+    hshift = 0;
+    for ( fcode = (long) state.hsize;  fcode < 65536L; fcode *= 2L )
+        hshift++;
+    hshift = 8 - hshift;                /* set hash code range bound */
+
+    hsize_reg = state.hsize;
+    cl_hash(&state, (int) hsize_reg);            /* clear hash table */
+
+    output(&state, (long)state.ClearCode);
+
+#ifdef SIGNED_COMPARE_SLOW
+    while ( (c = readValue(statePtr) ) != (unsigned) EOF ) {
+#else
+    while ( (c = readValue(statePtr)) != EOF ) {
 #endif
-
-static void
-writeBlock(
-    miGIFState_t *statePtr)
-{
-    unsigned char c;
 
-#ifdef MIGIF_DEBUGGING_ENVARS
-    if (MIGIF_VERBOSE) {
-	int i;
-	printf("writeBlock %d:", statePtr->oblen);
-	for (i=0 ; i<statePtr->oblen ; i++) {
-	    printf(" %02x", statePtr->oblock[i]);
-	}
-	printf("\n");
-    }
+        state.in_count++;
+
+        fcode = (long) (((long) c << GIFBITS) + ent);
+        i = (((long)c << hshift) ^ ent);    /* xor hashing */
+
+        if (state.htab[i] == fcode) {
+            ent = state.codetab[i];
+            continue;
+        } else if ( (long) state.htab[i] < 0 )      /* empty slot */
+            goto nomatch;
+        disp = hsize_reg - i;           /* secondary hash (after G. Knott) */
+        if ( i == 0 )
+            disp = 1;
+probe:
+        if ( (i -= disp) < 0 )
+            i += hsize_reg;
+
+        if (state.htab[i] == fcode) {
+            ent = state.codetab[i];
+            continue;
+        }
+        if ( (long) state.htab[i] > 0 )
+            goto probe;
+nomatch:
+        output (&state, (long) ent);
+        state.out_count++;
+        ent = c;
+#ifdef SIGNED_COMPARE_SLOW
+        if ( (unsigned) free_ent < (unsigned) ((long)1 << GIFBITS)) {
+#else
+        if (state.free_ent < ((long)1 << GIFBITS)) {
 #endif
-    c = statePtr->oblen;
-    Tcl_Write(statePtr->ofile, (char *) &c, 1);
-    Tcl_Write(statePtr->ofile, (char *) &statePtr->oblock[0], statePtr->oblen);
-    statePtr->oblen = 0;
-}
-
-static void
-blockOut(
-    miGIFState_t *statePtr,
-    unsigned c)
-{
-    DEBUGMSG(("blockOut %s\n", binformat(c, 8)));
-    statePtr->oblock[statePtr->oblen++] = (unsigned char) c;
-    if (statePtr->oblen >= 255) {
-	writeBlock(statePtr);
+            state.codetab[i] = state.free_ent++; /* code -> hashtable */
+            state.htab[i] = fcode;
+        } else
+                cl_block(&state);
     }
+    /*
+     * Put out the final code.
+     */
+    output(&state, (long)ent);
+    state.out_count++;
+    output(&state, (long) state.EOFCode);
+
+    return;
 }
-
-static void
-blockFlush(
-    miGIFState_t *statePtr)
-{
-    DEBUGMSG(("blockFlush\n"));
-    if (statePtr->oblen > 0) {
-	writeBlock(statePtr);
-    }
-}
-
-static void
-output(
-    miGIFState_t *statePtr,
-    int val)
-{
-    DEBUGMSG(("output %s [%s %d %d]\n", binformat(val, statePtr->outputBits),
-	    binformat(statePtr->obuf, statePtr->obits), statePtr->obits,
-	    statePtr->outputBits));
-    statePtr->obuf |= val << statePtr->obits;
-    statePtr->obits += statePtr->outputBits;
-    while (statePtr->obits >= 8) {
-	blockOut(statePtr, statePtr->obuf & 0xff);
-	statePtr->obuf >>= 8;
-	statePtr->obits -= 8;
-    }
-    DEBUGMSG(("output leaving [%s %d]\n",
-	    binformat(statePtr->obuf, statePtr->obits), statePtr->obits));
-}
-
-static void
-outputFlush(
-    miGIFState_t *statePtr)
-{
-    DEBUGMSG(("outputFlush\n"));
-    if (statePtr->obits > 0) {
-	blockOut(statePtr, statePtr->obuf);
-    }
-    blockFlush(statePtr);
-}
-
-static void
-didClear(
-    miGIFState_t *statePtr)
-{
-    DEBUGMSG(("didClear\n"));
-    statePtr->outputBits = statePtr->outputBitsInit;
-    statePtr->outputBump = statePtr->outputBumpInit;
-    statePtr->outputClear = statePtr->outputClearInit;
-    statePtr->outputCount = 0;
-    statePtr->runlengthTableMax = 0;
-    statePtr->justCleared = 1;
-}
-
+
+/*****************************************************************
+ * TAG( output )
+ *
+ * Output the given code.
+ * Inputs:
+ *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
+ *              that n_bits =< (long) wordsize - 1.
+ * Outputs:
+ *      Outputs code to the file.
+ * Assumptions:
+ *      Chars are 8 bits long.
+ * Algorithm:
+ *      Maintain a GIFBITS character long buffer (so that 8 codes will
+ * fit in it exactly).  Use the VAX insv instruction to insert each
+ * code in turn.  When the buffer fills up empty it and start over.
+ */
+
+static const
+unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
+                                  0x001F, 0x003F, 0x007F, 0x00FF,
+                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
+                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
+
 static void
-outputPlain(
-    miGIFState_t *statePtr,
-    int c)
+output(statePtr, code)
+    GIFState_t *statePtr;
+    long  code;
 {
-    DEBUGMSG(("outputPlain %s\n", binformat(c, statePtr->outputBits)));
-    statePtr->justCleared = 0;
-    output(statePtr, c);
-    statePtr->outputCount++;
-    if (statePtr->outputCount >= statePtr->outputBump) {
-	statePtr->outputBits++;
-	statePtr->outputBump += 1 << (statePtr->outputBits - 1);
-    }
-    if (statePtr->outputCount >= statePtr->outputClear) {
-	output(statePtr, statePtr->codeClear);
-	didClear(statePtr);
-    }
-}
-
-static unsigned int
-isqrt(
-    unsigned int x)
-{
-    unsigned int r;
-    unsigned int v;
+    statePtr->cur_accum &= masks[statePtr->cur_bits];
 
-    if (x < 2) {
-	return x;
-    }
-    for (v=x,r=1 ; v ; v>>=2,r<<=1);
-    while (1) {
-	v = ((x / r) + r) / 2;
-	if (v==r || v==r+1) {
-	    return r;
-	}
-	r = v;
+    if (statePtr->cur_bits > 0) {
+	statePtr->cur_accum |= ((long) code << statePtr->cur_bits);
+    } else {
+	statePtr->cur_accum = code;
     }
-}
-
-static int
-computeTriangleCount(
-    unsigned int count,
-    unsigned int nrepcodes)
-{
-    unsigned int perrep;
-    unsigned int cost;
 
-    cost = 0;
-    perrep = (nrepcodes * (nrepcodes+1)) / 2;
-    while (count >= perrep) {
-	cost += nrepcodes;
-	count -= perrep;
+    statePtr->cur_bits += statePtr->n_bits;
+
+    while (statePtr->cur_bits >= 8 ) {
+	char_out(statePtr, (unsigned int)(statePtr->cur_accum & 0xff));
+	statePtr->cur_accum >>= 8;
+	statePtr->cur_bits -= 8;
     }
-    if (count > 0) {
-	unsigned int n = isqrt(count);
 
-	while (n*(n+1) >= 2*count) {
-	    n--;
-	}
-	while (n*(n+1) < 2*count) {
-	    n++;
+    /*
+     * If the next entry is going to be too big for the code size,
+     * then increase it, if possible.
+     */
+
+    if ((statePtr->free_ent > statePtr->maxcode)|| statePtr->clear_flg ) {
+	if (statePtr->clear_flg) {
+	    statePtr->maxcode = MAXCODE(statePtr->n_bits = statePtr->g_init_bits);
+	    statePtr->clear_flg = 0;
+	} else {
+	    statePtr->n_bits++;
+	    if (statePtr->n_bits == GIFBITS) {
+		statePtr->maxcode = (long)1 << GIFBITS;
+	    } else {
+		statePtr->maxcode = MAXCODE(statePtr->n_bits);
+	    }
 	}
-	cost += n;
     }
-    return (int) cost + 1;
-}
-
-static void
-maxOutputClear(
-    miGIFState_t *statePtr)
-{
-    statePtr->outputClear = statePtr->maxOcodes;
-}
-
-static void
-resetOutputClear(
-    miGIFState_t *statePtr)
-{
-    statePtr->outputClear = statePtr->outputClearInit;
-    if (statePtr->outputCount >= statePtr->outputClear) {
-	output(statePtr, statePtr->codeClear);
-	didClear(statePtr);
+
+    if (code == statePtr->EOFCode) {
+	/*
+	 * At EOF, write the rest of the buffer.
+	 */
+        while (statePtr->cur_bits > 0) {
+	    char_out(statePtr, (unsigned int)(statePtr->cur_accum & 0xff));
+	    statePtr->cur_accum >>= 8;
+	    statePtr->cur_bits -= 8;
+	}
+	flush_char(statePtr);
     }
 }
-
+
+/*
+ * Clear out the hash table
+ */
 static void
-runlengthFlushFromClear(
-    miGIFState_t *statePtr,
-    int count)
+cl_block(statePtr)             /* table clear for block compress */
+    GIFState_t *statePtr;
 {
-    int n;
-
-    DEBUGMSG(("runlengthFlushFromClear %d\n", count));
-    maxOutputClear(statePtr);
-    statePtr->runlengthTablePixel = statePtr->runlengthPixel;
-    n = 1;
-    while (count > 0) {
-	if (n == 1) {
-	    statePtr->runlengthTableMax = 1;
-	    outputPlain(statePtr, statePtr->runlengthPixel);
-	    count--;
-	} else if (count >= n) {
-	    statePtr->runlengthTableMax = n;
-	    outputPlain(statePtr, statePtr->runlengthBaseCode+n-2);
-	    count -= n;
-	} else if (count == 1) {
-	    statePtr->runlengthTableMax++;
-	    outputPlain(statePtr, statePtr->runlengthPixel);
-	    count = 0;
-	} else {
-	    statePtr->runlengthTableMax++;
-	    outputPlain(statePtr, statePtr->runlengthBaseCode+count-2);
-	    count = 0;
-	}
-	if (statePtr->outputCount == 0) {
-	    n = 1;
-	} else {
-	    n++;
-	}
-    }
-    resetOutputClear(statePtr);
-    DEBUGMSG(("runlengthFlushFromClear leaving tableMax=%d\n",
-	    statePtr->runlengthTableMax));
+
+        cl_hash (statePtr, (int) statePtr->hsize);
+        statePtr->free_ent = statePtr->ClearCode + 2;
+        statePtr->clear_flg = 1;
+
+        output(statePtr, (long) statePtr->ClearCode);
 }
-
+
 static void
-runlengthFlushClearOrRep(
-    miGIFState_t *statePtr,
-    int count)
+cl_hash(statePtr, hsize)          /* reset code table */
+    GIFState_t *statePtr;
+    int hsize;
 {
-    int withclr;
-
-    DEBUGMSG(("runlengthFlushClearOrRep %d\n", count));
-    withclr = computeTriangleCount((unsigned) count,
-	    (unsigned) statePtr->maxOcodes);
-    if (withclr < count) {
-	output(statePtr, statePtr->codeClear);
-	didClear(statePtr);
-	runlengthFlushFromClear(statePtr, count);
-    } else {
-	for (; count>0 ; count--) {
-	    outputPlain(statePtr, statePtr->runlengthPixel);
-	}
+    register int *htab_p = statePtr->htab+hsize;
+    register long i;
+    register long m1 = -1;
+
+    i = hsize - 16;
+    do {                            /* might use Sys V memset(3) here */
+	*(htab_p-16) = m1;
+	*(htab_p-15) = m1;
+	*(htab_p-14) = m1;
+	*(htab_p-13) = m1;
+	*(htab_p-12) = m1;
+	*(htab_p-11) = m1;
+	*(htab_p-10) = m1;
+	*(htab_p-9) = m1;
+	*(htab_p-8) = m1;
+	*(htab_p-7) = m1;
+	*(htab_p-6) = m1;
+	*(htab_p-5) = m1;
+	*(htab_p-4) = m1;
+	*(htab_p-3) = m1;
+	*(htab_p-2) = m1;
+	*(htab_p-1) = m1;
+	htab_p -= 16;
+    } while ((i -= 16) >= 0);
+
+    for (i += 16; i > 0; i--) {
+	*--htab_p = m1;
     }
 }
-
+
+
+/******************************************************************************
+ *
+ * GIF Specific routines
+ *
+ ******************************************************************************/
+
+/*
+ * Set up the 'byte output' routine
+ */
 static void
-runlengthFlushWithTable(
-    miGIFState_t *statePtr,
-    int count)
+char_init(statePtr)
+    GIFState_t *statePtr;
 {
-    int repmax;
-    int repleft;
-    int leftover;
-
-    DEBUGMSG(("runlengthFlushWithTable %d\n", count));
-    repmax = count / statePtr->runlengthTableMax;
-    leftover = count % statePtr->runlengthTableMax;
-    repleft = (leftover ? 1 : 0);
-    if (statePtr->outputCount+repmax+repleft > statePtr->maxOcodes) {
-	repmax = statePtr->maxOcodes - statePtr->outputCount;
-	leftover = count - (repmax * statePtr->runlengthTableMax);
-	repleft = computeTriangleCount((unsigned) leftover,
-		(unsigned) statePtr->maxOcodes);
-    }
-    DEBUGMSG(("runlengthFlushWithTable repmax=%d leftover=%d repleft=%d\n",
-	    repmax, leftover, repleft));
-    if (computeTriangleCount((unsigned) count, (unsigned) statePtr->maxOcodes)
-	    < repmax+repleft) {
-	output(statePtr, statePtr->codeClear);
-	didClear(statePtr);
-	runlengthFlushFromClear(statePtr, count);
-	return;
-    }
-    maxOutputClear(statePtr);
-    for (; repmax>0 ; repmax--) {
-	outputPlain(statePtr,
-		statePtr->runlengthBaseCode + statePtr->runlengthTableMax - 2);
-    }
-    if (leftover) {
-	if (statePtr->justCleared) {
-	    runlengthFlushFromClear(statePtr, leftover);
-	} else if (leftover == 1) {
-	    outputPlain(statePtr, statePtr->runlengthPixel);
-	} else {
-	    outputPlain(statePtr, statePtr->runlengthBaseCode + leftover - 2);
-	}
-    }
-    resetOutputClear(statePtr);
+    statePtr->a_count = 0;
+    statePtr->cur_accum = 0;
+    statePtr->cur_bits = 0;
 }
-
+
+/*
+ * Add a character to the end of the current packet, and if it is 254
+ * characters, flush the packet to disk.
+ */
 static void
-runlengthFlush(
-    miGIFState_t *statePtr)
+char_out(statePtr, c)
+    GIFState_t *statePtr;
+    int c;
 {
-    DEBUGMSG(("runlengthFlush [ %d %d\n", statePtr->runlengthCount,
-	    statePtr->runlengthPixel));
-    if (statePtr->runlengthCount == 1) {
-	outputPlain(statePtr, statePtr->runlengthPixel);
-	statePtr->runlengthCount = 0;
-	DEBUGMSG(("runlengthFlush ]\n"));
-	return;
-    }
-    if (statePtr->justCleared) {
-	runlengthFlushFromClear(statePtr, statePtr->runlengthCount);
-    } else if ((statePtr->runlengthTableMax < 2)
-	    || (statePtr->runlengthTablePixel != statePtr->runlengthPixel)) {
-	runlengthFlushClearOrRep(statePtr, statePtr->runlengthCount);
-    } else {
-	runlengthFlushWithTable(statePtr, statePtr->runlengthCount);
+    statePtr->accum[statePtr->a_count++] = c;
+    if (statePtr->a_count >= 254) {
+	flush_char(statePtr);
     }
-    DEBUGMSG(("runlengthFlush ]\n"));
-    statePtr->runlengthCount = 0;
 }
-
+
+/*
+ * Flush the packet to disk, and reset the accumulator
+ */
 static void
-compress(
-    int initBits,
-    Tcl_Channel handle,
-    ifunptr readValue,
-    GifWriterState *statePtr)
+flush_char(statePtr)
+    GIFState_t *statePtr;
 {
-    int c;
-    miGIFState_t state;
-
-    memset(&state, 0, sizeof(state));
-
-    state.ofile = handle;
-    state.obuf = 0;
-    state.obits = 0;
-    state.oblen = 0;
-    state.codeClear = 1 << (initBits - 1);
-    state.codeEOF = state.codeClear + 1;
-    state.runlengthBaseCode = state.codeEOF + 1;
-    state.outputBumpInit = (1 << (initBits - 1)) - 1;
-
-    /*
-     * For images with a lot of runs, making outputClearInit larger will give
-     * better compression.
-     */
-
-    state.outputClearInit =
-	    (initBits <= 3) ? 9 : (state.outputBumpInit-1);
-#ifdef MIGIF_DEBUGGING_ENVARS
-    {
-	const char *ocienv = getenv("MIGIF_OUT_CLEAR_INIT");
-
-	if (ocienv) {
-	    state.outputClearInit = atoi(ocienv);
-	    DEBUGMSG(("[overriding outputClearInit to %d]\n",
-		    state.outputClearInit));
-	}
-    }
-#endif
-    state.outputBitsInit = initBits;
-    state.maxOcodes =
-	    (1 << GIFBITS) - ((1 << (state.outputBitsInit - 1)) + 3);
-    didClear(&state);
-    output(&state, state.codeClear);
-    state.runlengthCount = 0;
-    while (1) {
-	c = readValue(statePtr);
-	if (state.runlengthCount>0 && state.runlengthPixel!=c) {
-	    runlengthFlush(&state);
-	}
-	if (c == EOF) {
-	    break;
-	}
-	if (state.runlengthPixel == c) {
-	    state.runlengthCount++;
-	} else {
-	    state.runlengthPixel = c;
-	    state.runlengthCount = 1;
-	}
+    unsigned char c;
+    if (statePtr->a_count > 0) {
+	c = statePtr->a_count;
+	Tcl_Write(statePtr->g_outfile, (CONST char *) &c, 1);
+	Tcl_Write(statePtr->g_outfile, (CONST char *) statePtr->accum, statePtr->a_count);
+	statePtr->a_count = 0;
     }
-    output(&state, state.codeEOF);
-    outputFlush(&state);
 }
 
-/*
- *-----------------------------------------------------------------------
- *
- * End of miGIF section - See copyright notice at start of section.
- *
- *-----------------------------------------------------------------------
- */
+/* The End */
 
 /*
  * Local Variables: