Add gif and animated-gif write support to GD extension.

(enable with WITH_GD_GIF_OUT - not default due to LZW
patent in many countries)

PR:		ports/53631
Submitted by:	Alex Dupre <sysadmin@alexdupre.com> (maintainer)

2 files changed, 1421 insertions, 0 deletions

diff --git a/lang/php4/Makefile b/lang/php4/Makefile
index 200e554cf9e3..cfaf08447821 100644
--- a/lang/php4/Makefile
+++ b/lang/php4/Makefile
@@ -556,6 +556,9 @@ pre-patch:
 	@${SETENV} ${SCRIPTS_ENV} ${SH} ${SCRIPTDIR}/configure.php
 
 post-patch:
+.if defined(WITH_GD_GIF_OUT)
+	@${PATCH} -b .orig -d ${WRKSRC} -N -s -E -p1 -t < ${FILESDIR}/gd_gif_out.diff
+.endif
 	@${SED} "s|%%PREFIX%%|${PREFIX}|g" \
 		${WRKSRC}/pear/scripts/pearcmd.php > ${WRKSRC}/pear/scripts/pear
 
diff --git a/lang/php4/files/gd_gif_out.diff b/lang/php4/files/gd_gif_out.diff
new file mode 100644
index 000000000000..0ee29eb44db5
--- /dev/null
+++ b/lang/php4/files/gd_gif_out.diff
@@ -0,0 +1,1418 @@
+diff -ruN php-4.3.3RC1.orig/configure php-4.3.3RC1/configure
+--- php-4.3.3RC1.orig/configure	Mon Jun 23 10:06:05 2003
++++ php-4.3.3RC1/configure	Mon Jun 23 10:06:17 2003
+@@ -28248,7 +28248,7 @@
+                  libgd/gd_io_file.c libgd/gd_ss.c libgd/gd_io_ss.c libgd/gd_png.c libgd/gd_jpeg.c \
+                  libgd/gdxpm.c libgd/gdfontt.c libgd/gdfonts.c libgd/gdfontmb.c libgd/gdfontl.c \
+                  libgd/gdfontg.c libgd/gdtables.c libgd/gdft.c libgd/gdcache.c libgd/gdkanji.c \
+-                 libgd/wbmp.c libgd/gd_wbmp.c libgd/gdhelpers.c libgd/gd_topal.c libgd/gd_gif_in.c \
++                 libgd/wbmp.c libgd/gd_wbmp.c libgd/gdhelpers.c libgd/gd_topal.c libgd/gd_gif_in.c libgd/gd_gif_out.c \
+                  libgd/xbm.c"
+ 
+   for ac_func in fabsf floorf
+@@ -29724,6 +29724,9 @@
+ 
+   cat >> confdefs.h <<\EOF
+ #define HAVE_GD_BUNDLED 1
++#define HAVE_GD_GIF_CREATE 1
++#define HAVE_GD_GIF_CTX 1
++#define HAVE_GD_GIF_ANIM 1
+ EOF
+ 
+   cat >> confdefs.h <<\EOF
+@@ -32260,6 +32263,60 @@
+     LDFLAGS=$save_old_LDFLAGS
+     cat >> confdefs.h <<\EOF
+ #define HAVE_GD_GIF_CTX 1
++EOF
++
++  
++else
++  echo "$ac_t""no" 1>&6
++
++    LDFLAGS=$save_old_LDFLAGS
++    unset ac_cv_func_gd
++    
++  
++fi
++
++  
++  save_old_LDFLAGS=$LDFLAGS
++  LDFLAGS=" -L$GD_LIB $GD_SHARED_LIBADD  $LDFLAGS"
++  echo $ac_n "checking for gdImageGifAnimBegin in -lgd""... $ac_c" 1>&6
++echo "configure:32003: checking for gdImageGifAnimBegin in -lgd" >&5
++ac_lib_var=`echo gd'_'gdImageGifAnimBegin | sed 'y%./+-%__p_%'`
++if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
++  echo $ac_n "(cached) $ac_c" 1>&6
++else
++  ac_save_LIBS="$LIBS"
++LIBS="-lgd  $LIBS"
++cat > conftest.$ac_ext <<EOF
++#line 32011 "configure"
++#include "confdefs.h"
++/* Override any gcc2 internal prototype to avoid an error.  */
++/* We use char because int might match the return type of a gcc2
++    builtin and then its argument prototype would still apply.  */
++char gdImageGifAnimBegin();
++
++int main() {
++gdImageGifAnimBegin()
++; return 0; }
++EOF
++if { (eval echo configure:32022: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
++  rm -rf conftest*
++  eval "ac_cv_lib_$ac_lib_var=yes"
++else
++  echo "configure: failed program was:" >&5
++  cat conftest.$ac_ext >&5
++  rm -rf conftest*
++  eval "ac_cv_lib_$ac_lib_var=no"
++fi
++rm -f conftest*
++LIBS="$ac_save_LIBS"
++
++fi
++if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
++  echo "$ac_t""yes" 1>&6
++  
++    LDFLAGS=$save_old_LDFLAGS
++    cat >> confdefs.h <<\EOF
++#define HAVE_GD_GIF_ANIM 1
+ EOF
+ 
+   
+diff -ruN php-4.3.3RC1.orig/ext/gd/config.m4 php-4.3.3RC1/ext/gd/config.m4
+--- php-4.3.3RC1.orig/ext/gd/config.m4	Mon Jun 23 10:05:28 2003
++++ php-4.3.3RC1/ext/gd/config.m4	Mon Jun 23 10:06:17 2003
+@@ -254,6 +254,7 @@
+   PHP_CHECK_LIBRARY(gd, gdImageColorClosestHWB, [AC_DEFINE(HAVE_COLORCLOSESTHWB,     1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+   PHP_CHECK_LIBRARY(gd, gdImageColorResolve,    [AC_DEFINE(HAVE_GDIMAGECOLORRESOLVE, 1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+   PHP_CHECK_LIBRARY(gd, gdImageGifCtx,          [AC_DEFINE(HAVE_GD_GIF_CTX,          1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
++  PHP_CHECK_LIBRARY(gd, gdImageGifAnimBegin,    [AC_DEFINE(HAVE_GD_GIF_ANIM,         1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+   PHP_CHECK_LIBRARY(gd, gdCacheCreate,          [AC_DEFINE(HAVE_GD_CACHE_CREATE,     1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+ ])
+ 
+@@ -267,7 +268,7 @@
+                  libgd/gd_io_file.c libgd/gd_ss.c libgd/gd_io_ss.c libgd/gd_png.c libgd/gd_jpeg.c \
+                  libgd/gdxpm.c libgd/gdfontt.c libgd/gdfonts.c libgd/gdfontmb.c libgd/gdfontl.c \
+                  libgd/gdfontg.c libgd/gdtables.c libgd/gdft.c libgd/gdcache.c libgd/gdkanji.c \
+-                 libgd/wbmp.c libgd/gd_wbmp.c libgd/gdhelpers.c libgd/gd_topal.c libgd/gd_gif_in.c \
++                 libgd/wbmp.c libgd/gd_wbmp.c libgd/gdhelpers.c libgd/gd_topal.c libgd/gd_gif_in.c libgd/gd_gif_out.c \
+                  libgd/xbm.c"
+ 
+ dnl check for fabsf and floorf which are available since C99
+diff -ruN php-4.3.3RC1.orig/ext/gd/gd.c php-4.3.3RC1/ext/gd/gd.c
+--- php-4.3.3RC1.orig/ext/gd/gd.c	Mon Jun 23 10:05:28 2003
++++ php-4.3.3RC1/ext/gd/gd.c	Mon Jun 23 10:06:17 2003
+@@ -206,6 +206,11 @@
+ #ifdef HAVE_GD_GIF_CREATE
+ 	PHP_FE(imagegif,								NULL)
+ #endif
++#ifdef HAVE_GD_GIF_ANIM
++	PHP_FE(imagegifanimbegin,						NULL)
++	PHP_FE(imagegifanimadd,							NULL)
++	PHP_FE(imagegifanimend,							NULL)
++#endif
+ #ifdef HAVE_GD_JPG
+ 	PHP_FE(imagejpeg,								NULL)
+ #endif
+@@ -1707,11 +1712,35 @@
+ #ifdef HAVE_GD_GIF_CTX
+ 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GIF, "GIF", gdImageGifCtx);
+ #else
++
++#ifdef HAVE_GD_BUNDLED
++#error "I really think there should be ctx version of imagegif in the bundled GD library.  Fix the configuration."
++#endif
++
+ 	_php_image_output(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GIF, "GIF", gdImageGif);
+ #endif
+ }
+ /* }}} */
+ #endif /* HAVE_GD_GIF_CREATE */
++
++#ifdef HAVE_GD_GIF_ANIM
++/* {{{ proto int imagegifanimbegin(int im [, string filename [, int GlobalColormap [, int Loops]]])
++   Begin GIF animation.  Image parameter is only used for size and colormap,
++   all animation frames must be added separately. */
++PHP_FUNCTION(imagegifanimbegin)
++{
++	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GIFANIMBEGIN, "GIF", gdImageGifAnimBeginCtx);
++}
++/* }}} */
++
++/* {{{ proto int imagegifanimadd(int im [, string filename [, int LocalColormap [, LeftOfs [, int TopOfs [, int Delay [, int Disposal]]]]]])
++   Append GIF image to animation */
++PHP_FUNCTION(imagegifanimadd)
++{
++	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GIFANIMADD, "GIF", gdImageGifAnimAddCtx);
++}
++/* }}} */
++#endif /* HAVE_GD_GIF_ANIM */
+ 
+ #ifdef HAVE_GD_PNG
+ /* {{{ proto int imagepng(int im [, string filename])
+diff -ruN php-4.3.3RC1.orig/ext/gd/gd_ctx.c php-4.3.3RC1/ext/gd/gd_ctx.c
+--- php-4.3.3RC1.orig/ext/gd/gd_ctx.c	Mon Jun 23 10:05:28 2003
++++ php-4.3.3RC1/ext/gd/gd_ctx.c	Mon Jun 23 10:06:17 2003
+@@ -24,17 +24,22 @@
+ 	
+ static void _php_image_output_ctx(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, void (*func_p)()) 
+ {
+-	zval **imgind, **file, **quality;
++	zval **imgind, **file, **quality, **lo, **to, **del, **dis;
+ 	gdImagePtr im;
+ 	char *fn = NULL;
+ 	FILE *fp = NULL;
+ 	int argc = ZEND_NUM_ARGS();
+ 	int q = -1, i;
++#ifdef HAVE_GD_GIF_ANIM
++	int LeftOfs = -1, TopOfs = -1, Delay = -1, Disposal = -1;
++#endif /* HAVE_GD_GIF_ANIM */
+ 	gdIOCtx *ctx;
+ 
+ 	/* The quality parameter for Wbmp stands for the threshold when called from image2wbmp() */
++	/* The quality parameter for GIF animation stands for colormap inclusion. 1==include local/global colormap */
++	/* The LeftOfs parameter for GIF animation begin stands for NETSCAPE2.0 Loop count extension. */
+ 	
+-	if (argc < 1 || argc > 3 || zend_get_parameters_ex(argc, &imgind, &file, &quality) == FAILURE) 
++	if (argc < 1 || argc > 7 || zend_get_parameters_ex(argc, &imgind, &file, &quality, &lo, &to, &del, &dis) == FAILURE) 
+ 	{
+ 		WRONG_PARAM_COUNT;
+ 	}
+@@ -44,11 +49,29 @@
+ 	if (argc > 1) {
+ 		convert_to_string_ex(file);
+ 		fn = Z_STRVAL_PP(file);
+-		if (argc == 3) {
+-			convert_to_long_ex(quality);
+-			q = Z_LVAL_PP(quality);
+-		}
+ 	}
++	if (argc >= 3) {
++		convert_to_long_ex(quality);
++		q = Z_LVAL_PP(quality);
++	}
++#ifdef HAVE_GD_GIF_ANIM
++	if (argc >= 4) {
++		convert_to_long_ex(lo);
++		LeftOfs = Z_LVAL_PP(lo);
++	}
++	if (argc >= 5) {
++		convert_to_long_ex(to);
++		TopOfs = Z_LVAL_PP(to);
++	}
++	if (argc >= 6) {
++		convert_to_long_ex(del);
++		Delay = Z_LVAL_PP(del);
++	}
++	if (argc >= 7) {
++		convert_to_long_ex(dis);
++		Disposal = Z_LVAL_PP(dis);
++	}
++#endif /* HAVE_GD_GIF_ANIM */
+ 
+ 	if ((argc == 2) || (argc > 2 && Z_STRLEN_PP(file))) {
+ 		if (!fn || fn == empty_string || php_check_open_basedir(fn TSRMLS_CC)) {
+@@ -94,6 +117,14 @@
+ 			} 
+ 			(*func_p)(im, i, ctx);
+ 			break;
++#ifdef HAVE_GD_GIF_ANIM
++		case PHP_GDIMG_TYPE_GIFANIMBEGIN:
++			(*func_p)(im, ctx, q, LeftOfs);
++			break;
++		case PHP_GDIMG_TYPE_GIFANIMADD:
++			(*func_p)(im, ctx, q, LeftOfs, TopOfs, Delay, Disposal);
++			break;
++#endif /* HAVE_GD_GIF_ANIM */
+ 		default:
+ 			(*func_p)(im, ctx);
+ 			break;
+@@ -112,3 +143,72 @@
+ 	
+     RETURN_TRUE;
+ }
++
++#ifdef HAVE_GD_GIF_ANIM
++/* {{{ proto int imagegifanimend([string filename])
++   Write end mark to gif animation. */
++PHP_FUNCTION(imagegifanimend)
++{
++	zval **file;
++	char *fn = NULL;
++	FILE *fp = NULL;
++	int argc = ZEND_NUM_ARGS();
++	gdIOCtx *ctx;
++
++	if (argc < 0 || argc > 1 || zend_get_parameters_ex(argc, &file) == FAILURE) {
++		ZEND_WRONG_PARAM_COUNT();
++	}
++
++	if (argc >= 1) {
++		convert_to_string_ex(file);
++		fn = Z_STRVAL_PP(file);
++	}
++
++	if ((argc == 1) || (argc > 1 && Z_STRLEN_PP(file))) {
++		if (!fn || fn == empty_string || php_check_open_basedir(fn TSRMLS_CC)) {
++			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid filename '%s'", fn);
++			RETURN_FALSE;
++		}
++
++		fp = VCWD_FOPEN(fn, "wb");
++		if (!fp) {
++			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' for writing", fn);
++			RETURN_FALSE;
++		}
++
++		ctx = gdNewFileCtx(fp);
++	} else {
++		ctx = emalloc(sizeof(gdIOCtx));
++		ctx->putC = _php_image_output_putc;
++		ctx->putBuf = _php_image_output_putbuf;
++#if HAVE_LIBGD204
++		ctx->gd_free = _php_image_output_ctxfree;
++#else
++		ctx->free = _php_image_output_ctxfree;
++#endif		
++
++#if APACHE && defined(CHARSET_EBCDIC)
++		/* XXX this is unlikely to work any more thies@thieso.net */
++		/* This is a binary file already: avoid EBCDIC->ASCII conversion */
++		ap_bsetflag(php3_rqst->connection->client, B_EBCDIC2ASCII, 0);
++#endif
++	}
++
++	/* This could be coded in here, as it only outputs ';' */
++	gdImageGifAnimEndCtx(ctx);
++
++#if HAVE_LIBGD204	
++	ctx->gd_free(ctx);
++#else
++	ctx->free(ctx);
++#endif		
++
++	if(fp) {
++		fflush(fp);
++		fclose(fp);
++	}
++	
++    RETURN_TRUE;
++}
++/* }}} */
++#endif /* HAVE_GD_GIF_ANIM */
+diff -ruN php-4.3.3RC1.orig/ext/gd/libgd/gd.h php-4.3.3RC1/ext/gd/libgd/gd.h
+--- php-4.3.3RC1.orig/ext/gd/libgd/gd.h	Mon Jun 23 10:05:26 2003
++++ php-4.3.3RC1/ext/gd/libgd/gd.h	Mon Jun 23 10:06:17 2003
+@@ -445,6 +445,18 @@
+ gdImagePtr gdImageCreateFromGif(FILE *fd);
+ gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr in);
+ gdImagePtr gdImageCreateFromGifSource(gdSourcePtr in);
++void gdImageGif(gdImagePtr im, FILE *outFile);
++void gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops);
++void gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void gdImageGifAnimEnd(FILE *outFile);
++void gdImageGifCtx(gdImagePtr im, gdIOCtx *out);
++void gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtx *out, int GlobalCM, int Loops);
++void gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void gdImageGifAnimEndCtx(gdIOCtx *out);
++void *gdImageGifPtr(gdImagePtr im, int *size);
++void *gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops);
++void *gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void *gdImageGifAnimEndPtr(int *size);
+ 
+ /* A custom data sink. For backwards compatibility. Use
+ 	gdIOCtx instead. */
+diff -ruN php-4.3.3RC1.orig/ext/gd/libgd/gd_gif_out.c php-4.3.3RC1/ext/gd/libgd/gd_gif_out.c
+--- php-4.3.3RC1.orig/ext/gd/libgd/gd_gif_out.c	Thu Jan  1 01:00:00 1970
++++ php-4.3.3RC1/ext/gd/libgd/gd_gif_out.c	Mon Jun 23 13:22:13 2003
+@@ -0,0 +1,1053 @@
++#include <stdio.h>
++#include <math.h>
++#include <string.h>
++#include <stdlib.h>
++#include "gd.h"
++#include "gdhelpers.h"
++#include "php.h"
++
++/* Code drawn from ppmtogif.c, from the pbmplus package
++**
++** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>. A
++** Lempel-Zim compression based on "compress".
++**
++** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl>
++**
++** Copyright (C) 1989 by Jef Poskanzer.
++**
++** 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" without express or
++** implied warranty.
++**
++** The Graphics Interchange Format(c) is the Copyright property of
++** CompuServe Incorporated.  GIF(sm) is a Service Mark property of
++** CompuServe Incorporated.
++*/
++
++/*
++ * a code_int must be able to hold 2**GIFBITS values of type int, and also -1
++ */
++typedef int             code_int;
++
++#ifdef SIGNED_COMPARE_SLOW
++typedef unsigned long int count_int;
++typedef unsigned short int count_short;
++#else /*SIGNED_COMPARE_SLOW*/
++typedef long int          count_int;
++#endif /*SIGNED_COMPARE_SLOW*/
++
++static int colorstobpp(int colors);
++static void BumpPixel (void);
++static int GIFNextPixel (gdImagePtr im);
++static void GIFEncode (gdIOCtx *fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im);
++static void GIFAnimEncode(gdIOCtx *fp, int IWidth, int IHeight, int LeftOfs, int TopOfs, int GInterlace, int Transparent, int Delay, int Disposal, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im);
++/*static void Putword (int w, gdIOCtx *fp); */
++static void compress (int init_bits, gdIOCtx *outfile, gdImagePtr im);
++static void output (code_int code);
++static void cl_block (void);
++static void cl_hash (register count_int hsize);
++static void char_init (void);
++static void char_out (int c);
++static void flush_char (void);
++/* Allows for reuse */
++static void init_statics(void);
++
++void gdImageGifCtx(gdImagePtr im, gdIOCtx *out)
++{
++	int interlace, transparent, BitsPerPixel;
++
++	interlace = im->interlace;
++	transparent = im->transparent;
++
++	BitsPerPixel = colorstobpp(im->colorsTotal);
++	/* Clear any old values in statics strewn through the GIF code */
++	init_statics();
++	/* All set, let's do it. */
++	GIFEncode(
++		out, im->sx, im->sy, interlace, 0, transparent, BitsPerPixel,
++		im->red, im->green, im->blue, im);
++}
++
++void gdImageGif(gdImagePtr im, FILE *outFile)
++{
++        gdIOCtx   *out = gdNewFileCtx(outFile);
++        gdImageGifCtx(im, out);
++        out->gd_free(out);
++}
++
++void gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops)
++{
++        gdIOCtx   *out = gdNewFileCtx(outFile);
++        gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
++        out->gd_free(out);
++}
++
++void gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++        gdIOCtx   *out = gdNewFileCtx(outFile);
++        gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++        out->gd_free(out);
++}
++
++void gdImageGifAnimEnd(FILE *outFile)
++{
++#if 1
++	putc (';', outFile);
++#else
++        gdIOCtx   *out = gdNewFileCtx(outFile);
++        gdImageGifAnimEndCtx(out);
++        out->gd_free(out);
++#endif
++}
++
++void gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtx *out, int GlobalCM, int Loops)
++{
++        int B;
++        int RWidth, RHeight;
++        int Resolution;
++        int ColorMapSize;
++	int BitsPerPixel;
++	int Background = 0;
++        int i;
++
++	BitsPerPixel = colorstobpp(im->colorsTotal);
++        ColorMapSize = 1 << BitsPerPixel;
++
++        RWidth = im->sx;
++        RHeight = im->sy;
++
++        Resolution = BitsPerPixel;
++
++        /*
++         * Write the Magic header
++         */
++        gdPutBuf( "GIF89a", 6, out );
++
++        /*
++         * Write out the screen width and height
++         */
++        Putword( RWidth, out );
++        Putword( RHeight, out );
++
++        /*
++         * Indicate that there is a global colour map
++         */
++        B = GlobalCM > 0 ? 0x80 : 0;
++
++        /*
++         * OR in the resolution
++         */
++        B |= (Resolution - 1) << 5;
++
++        /*
++         * OR in the Bits per Pixel
++         */
++        B |= (BitsPerPixel - 1);
++
++        /*
++         * Write it out
++         */
++        gdPutC( B, out );
++
++        /*
++         * Write out the Background colour
++         */
++        gdPutC( Background, out );
++
++        /*
++         * Byte of 0's (future expansion)
++         */
++        gdPutC( 0, out );
++
++        /*
++         * Write out the Global Colour Map
++         */
++	if (GlobalCM > 0)
++		for( i=0; i<ColorMapSize; ++i ) {
++			gdPutC( im->red[i], out );
++			gdPutC( im->green[i], out );
++			gdPutC( im->blue[i], out );
++		}
++	if (Loops >= 0) {
++		gdPutBuf( "!\377\13NETSCAPE2.0\3\1", 16, out );
++		gdPutC( (unsigned char)(Loops & 255), out );
++		gdPutC( (unsigned char)((Loops >> 8) & 255), out );
++		gdPutC( 0, out );
++	}
++}
++
++void gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++	int interlace, transparent, BitsPerPixel;
++
++	interlace = im->interlace;
++	transparent = im->transparent;
++
++	BitsPerPixel = colorstobpp(im->colorsTotal);
++	/* Clear any old values in statics strewn through the GIF code */
++	init_statics();
++	/* All set, let's do it. */
++	GIFAnimEncode(
++		out, im->sx, im->sy, LeftOfs, TopOfs, interlace, transparent,
++		Delay, Disposal, BitsPerPixel,
++		LocalCM > 0 ? im->red : 0, im->green, im->blue, im);
++}
++
++void gdImageGifAnimEndCtx(gdIOCtx *out)
++{
++        /*
++         * Write the GIF file terminator
++         */
++        gdPutC( ';', out );
++}
++
++void* gdImageGifPtr(gdImagePtr im, int *size)
++{
++	void	*rv;
++        gdIOCtx   *out = gdNewDynamicCtx(2048, NULL);
++        gdImageGifCtx(im, out);
++        rv = gdDPExtractData(out,size);
++	out->gd_free(out);
++	return rv;
++}
++
++void *gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops)
++{
++	void	*rv;
++        gdIOCtx   *out = gdNewDynamicCtx(2048, NULL);
++        gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
++        rv = gdDPExtractData(out,size);
++	out->gd_free(out);
++	return rv;
++}
++
++void *gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++	void	*rv;
++        gdIOCtx   *out = gdNewDynamicCtx(2048, NULL);
++        gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++        rv = gdDPExtractData(out,size);
++	out->gd_free(out);
++	return rv;
++}
++
++void* gdImageGifAnimEndPtr(int *size)
++{
++	char *rv = (char *) gdMalloc (1);
++	*rv = ';';
++	*size = 1;
++	return (void *)rv;
++}
++
++static int
++colorstobpp(int colors)
++{
++    int bpp = 0;
++
++    if ( colors <= 2 )
++        bpp = 1;
++    else if ( colors <= 4 )
++        bpp = 2;
++    else if ( colors <= 8 )
++        bpp = 3;
++    else if ( colors <= 16 )
++        bpp = 4;
++    else if ( colors <= 32 )
++        bpp = 5;
++    else if ( colors <= 64 )
++        bpp = 6;
++    else if ( colors <= 128 )
++        bpp = 7;
++    else if ( colors <= 256 )
++        bpp = 8;
++    return bpp;
++    }
++
++/*****************************************************************************
++ *
++ * GIFENCODE.C    - GIF Image compression interface
++ *
++ * GIFEncode( FName, GHeight, GWidth, GInterlace, Background, Transparent,
++ *            BitsPerPixel, Red, Green, Blue, gdImagePtr )
++ *
++ *****************************************************************************/
++
++#define TRUE 1
++#define FALSE 0
++
++static int Width, Height;
++static int curx, cury;
++static long CountDown;
++static int Pass = 0;
++static int Interlace;
++
++/*
++ * Bump the 'curx' and 'cury' to point to the next pixel
++ */
++static void
++BumpPixel(void)
++{
++        /*
++         * Bump the current X position
++         */
++        ++curx;
++
++        /*
++         * If we are at the end of a scan line, set curx back to the beginning
++         * If we are interlaced, bump the cury to the appropriate spot,
++         * otherwise, just increment it.
++         */
++        if( curx == Width ) {
++                curx = 0;
++
++                if( !Interlace )
++                        ++cury;
++                else {
++                     switch( Pass ) {
++
++                       case 0:
++                          cury += 8;
++                          if( cury >= Height ) {
++                                ++Pass;
++                                cury = 4;
++                          }
++                          break;
++
++                       case 1:
++                          cury += 8;
++                          if( cury >= Height ) {
++                                ++Pass;
++                                cury = 2;
++                          }
++                          break;
++
++                       case 2:
++                          cury += 4;
++                          if( cury >= Height ) {
++                             ++Pass;
++                             cury = 1;
++                          }
++                          break;
++
++                       case 3:
++                          cury += 2;
++                          break;
++                        }
++                }
++        }
++}
++
++/*
++ * Return the next pixel from the image
++ */
++static int
++GIFNextPixel(gdImagePtr im)
++{
++        int r;
++
++        if( CountDown == 0 )
++                return EOF;
++
++        --CountDown;
++
++        r = gdImageGetPixel(im, curx, cury);
++
++        BumpPixel();
++
++        return r;
++}
++
++/* public */
++
++static void
++GIFEncode(gdIOCtx *fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
++{
++        int B;
++        int RWidth, RHeight;
++        int LeftOfs, TopOfs;
++        int Resolution;
++        int ColorMapSize;
++        int InitCodeSize;
++        int i;
++
++        Interlace = GInterlace;
++
++        ColorMapSize = 1 << BitsPerPixel;
++
++        RWidth = Width = GWidth;
++        RHeight = Height = GHeight;
++        LeftOfs = TopOfs = 0;
++
++        Resolution = BitsPerPixel;
++
++        /*
++         * Calculate number of bits we are expecting
++         */
++        CountDown = (long)Width * (long)Height;
++
++        /*
++         * Indicate which pass we are on (if interlace)
++         */
++        Pass = 0;
++
++        /*
++         * The initial code size
++         */
++        if( BitsPerPixel <= 1 )
++                InitCodeSize = 2;
++        else
++                InitCodeSize = BitsPerPixel;
++
++        /*
++         * Set up the current x and y position
++         */
++        curx = cury = 0;
++
++        /*
++         * Write the Magic header
++         */
++        gdPutBuf( Transparent < 0 ? "GIF87a" : "GIF89a", 6, fp );
++
++        /*
++         * Write out the screen width and height
++         */
++        Putword( RWidth, fp );
++        Putword( RHeight, fp );
++
++        /*
++         * Indicate that there is a global colour map
++         */
++        B = 0x80;       /* Yes, there is a color map */
++
++        /*
++         * OR in the resolution
++         */
++        B |= (Resolution - 1) << 5;
++
++        /*
++         * OR in the Bits per Pixel
++         */
++        B |= (BitsPerPixel - 1);
++
++        /*
++         * Write it out
++         */
++        gdPutC( B, fp );
++
++        /*
++         * Write out the Background colour
++         */
++        gdPutC( Background, fp );
++
++        /*
++         * Byte of 0's (future expansion)
++         */
++        gdPutC( 0, fp );
++
++        /*
++         * Write out the Global Colour Map
++         */
++        for( i=0; i<ColorMapSize; ++i ) {
++                gdPutC( Red[i], fp );
++                gdPutC( Green[i], fp );
++                gdPutC( Blue[i], fp );
++        }
++
++	/*
++	 * Write out extension for transparent colour index, if necessary.
++	 */
++	if ( Transparent >= 0 ) {
++	    gdPutC( '!', fp );
++	    gdPutC( 0xf9, fp );
++	    gdPutC( 4, fp );
++	    gdPutC( 1, fp );
++	    gdPutC( 0, fp );
++	    gdPutC( 0, fp );
++	    gdPutC( (unsigned char) Transparent, fp );
++	    gdPutC( 0, fp );
++	}
++
++        /*
++         * Write an Image separator
++         */
++        gdPutC( ',', fp );
++
++        /*
++         * Write the Image header
++         */
++
++        Putword( LeftOfs, fp );
++        Putword( TopOfs, fp );
++        Putword( Width, fp );
++        Putword( Height, fp );
++
++        /*
++         * Write out whether or not the image is interlaced
++         */
++        if( Interlace )
++                gdPutC( 0x40, fp );
++        else
++                gdPutC( 0x00, fp );
++
++        /*
++         * Write out the initial code size
++         */
++        gdPutC( InitCodeSize, fp );
++
++        /*
++         * Go and actually compress the data
++         */
++        compress( InitCodeSize+1, fp, im );
++
++        /*
++         * Write out a Zero-length packet (to end the series)
++         */
++        gdPutC( 0, fp );
++
++        /*
++         * Write the GIF file terminator
++         */
++        gdPutC( ';', fp );
++}
++
++static void
++GIFAnimEncode(gdIOCtx *fp, int IWidth, int IHeight, int LeftOfs, int TopOfs, int GInterlace, int Transparent, int Delay, int Disposal, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
++{
++        int ColorMapSize;
++        int InitCodeSize;
++        int i;
++
++	if (LeftOfs < 0) LeftOfs = 0;
++	if (TopOfs < 0) TopOfs = 0;
++	if (Delay < 0) Delay = 100;
++	if (Disposal < 0) Disposal = 2;
++
++        Interlace = GInterlace;
++
++        ColorMapSize = 1 << BitsPerPixel;
++
++	Width = IWidth;
++        Height = IHeight;
++
++        /*
++         * Calculate number of bits we are expecting
++         */
++        CountDown = (long)Width * (long)Height;
++
++        /*
++         * Indicate which pass we are on (if interlace)
++         */
++        Pass = 0;
++
++        /*
++         * The initial code size
++         */
++        if( BitsPerPixel <= 1 )
++                InitCodeSize = 2;
++        else
++                InitCodeSize = BitsPerPixel;
++
++        /*
++         * Set up the current x and y position
++         */
++        curx = cury = 0;
++
++	/*
++	 * Write out extension for image animation and looping
++	 */
++	gdPutC( '!', fp );
++	gdPutC( 0xf9, fp );
++	gdPutC( 4, fp );
++	gdPutC( (Transparent >= 0 ? 1 : 0)
++		| (Disposal << 2), fp );
++	gdPutC( (unsigned char)(Delay & 255), fp );
++	gdPutC( (unsigned char)((Delay >> 8) & 255), fp );
++	gdPutC( (unsigned char) Transparent, fp );
++	gdPutC( 0, fp );
++
++        /*
++         * Write an Image separator
++         */
++        gdPutC( ',', fp );
++
++        /*
++         * Write the Image header
++         */
++
++        Putword( LeftOfs, fp );
++        Putword( TopOfs, fp );
++        Putword( Width, fp );
++        Putword( Height, fp );
++
++        /*
++         * Write out whether or not the image is interlaced
++	 * and if it includes local colour map.
++         */
++	gdPutC( (Interlace ? 0x40 : 0)
++		| (Red ? 0x80 : 0)
++		| (Red ? BitsPerPixel - 1 : 0), fp );
++
++        /*
++         * Write out the Local Colour Map
++         */
++	if (Red)
++		for( i=0; i<ColorMapSize; ++i ) {
++			gdPutC( Red[i], fp );
++			gdPutC( Green[i], fp );
++			gdPutC( Blue[i], fp );
++		}
++
++        /*
++         * Write out the initial code size
++         */
++        gdPutC( InitCodeSize, fp );
++
++        /*
++         * Go and actually compress the data
++         */
++        compress( InitCodeSize+1, fp, im );
++
++        /*
++         * Write out a Zero-length packet (to end the series)
++         */
++        gdPutC( 0, fp );
++}
++
++/* */
++/* * Write out a word to the GIF file */
++/* */
++/*static void */
++/*Putword(int w, FILE *fp) */
++/*{ */
++/*        fputc( w & 0xff, fp ); */
++/*        fputc( (w / 256) & 0xff, fp ); */
++/*} */
++
++
++/***************************************************************************
++ *
++ *  GIFCOMPR.C       - GIF Image compression routines
++ *
++ *  Lempel-Ziv compression based on 'compress'.  GIF modifications by
++ *  David Rowley (mgardi@watdcsu.waterloo.edu)
++ *
++ ***************************************************************************/
++
++/*
++ * General DEFINEs
++ */
++
++#define GIFBITS    12
++
++#define HSIZE  5003            /* 80% occupancy */
++
++#ifdef NO_UCHAR
++ typedef char   char_type;
++#else /*NO_UCHAR*/
++ typedef        unsigned char   char_type;
++#endif /*NO_UCHAR*/
++
++/*
++ *
++ * GIF Image compression - modified 'compress'
++ *
++ * Based on: compress.c - File compression ala IEEE Computer, June 1984.
++ *
++ * 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)
++ *
++ */
++#include <ctype.h>
++
++#define ARGVAL() (*++(*argv) || (--argc && *++argv))
++
++static int n_bits;                        /* number of bits/code */
++static int maxbits = GIFBITS;                /* user settable max # bits/code */
++static code_int maxcode;                  /* maximum code, given n_bits */
++static code_int maxmaxcode = (code_int)1 << GIFBITS; /* should NEVER generate this code */
++#ifdef COMPATIBLE               /* But wrong! */
++# define MAXCODE(n_bits)        ((code_int) 1 << (n_bits) - 1)
++#else /*COMPATIBLE*/
++# define MAXCODE(n_bits)        (((code_int) 1 << (n_bits)) - 1)
++#endif /*COMPATIBLE*/
++
++static count_int htab [HSIZE];
++static unsigned short codetab [HSIZE];
++#define HashTabOf(i)       htab[i]
++#define CodeTabOf(i)    codetab[i]
++
++static code_int hsize = HSIZE;                 /* for dynamic table sizing */
++
++/*
++ * 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 tab_prefixof(i) CodeTabOf(i)
++#define tab_suffixof(i)        ((char_type*)(htab))[i]
++#define de_stack               ((char_type*)&tab_suffixof((code_int)1<<GIFBITS))
++
++static code_int free_ent = 0;                  /* first unused entry */
++
++/*
++ * block compression parameters -- after all codes are used up,
++ * and compression rate changes, start over.
++ */
++static int clear_flg = 0;
++
++static int offset;
++static long int in_count = 1;            /* length of input */
++static long int out_count = 0;           /* # of codes output (for debugging) */
++
++/*
++ * 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.
++ */
++
++static int g_init_bits;
++static gdIOCtx* g_outfile;
++
++static int ClearCode;
++static int EOFCode;
++
++static void
++compress(int init_bits, gdIOCtx *outfile, gdImagePtr im)
++{
++    register long fcode;
++    register code_int i /* = 0 */;
++    register int c;
++    register code_int ent;
++    register code_int disp;
++    register code_int hsize_reg;
++    register int hshift;
++
++    /*
++     * Set up the globals:  g_init_bits - initial number of bits
++     *                      g_outfile   - pointer to output file
++     */
++    g_init_bits = init_bits;
++    g_outfile = outfile;
++
++    /*
++     * Set up the necessary values
++     */
++    offset = 0;
++    out_count = 0;
++    clear_flg = 0;
++    in_count = 1;
++    maxcode = MAXCODE(n_bits = g_init_bits);
++
++    ClearCode = (1 << (init_bits - 1));
++    EOFCode = ClearCode + 1;
++    free_ent = ClearCode + 2;
++
++    char_init();
++
++    ent = GIFNextPixel( im );
++
++    hshift = 0;
++    for ( fcode = (long) hsize;  fcode < 65536L; fcode *= 2L )
++        ++hshift;
++    hshift = 8 - hshift;                /* set hash code range bound */
++
++    hsize_reg = hsize;
++    cl_hash( (count_int) hsize_reg);            /* clear hash table */
++
++    output( (code_int)ClearCode );
++
++#ifdef SIGNED_COMPARE_SLOW
++    while ( (c = GIFNextPixel( im )) != (unsigned) EOF ) {
++#else /*SIGNED_COMPARE_SLOW*/
++    while ( (c = GIFNextPixel( im )) != EOF ) {  /* } */
++#endif /*SIGNED_COMPARE_SLOW*/
++
++        ++in_count;
++
++        fcode = (long) (((long) c << maxbits) + ent);
++        i = (((code_int)c << hshift) ^ ent);    /* xor hashing */
++
++        if ( HashTabOf (i) == fcode ) {
++            ent = CodeTabOf (i);
++            continue;
++        } else if ( (long)HashTabOf (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 ( HashTabOf (i) == fcode ) {
++            ent = CodeTabOf (i);
++            continue;
++        }
++        if ( (long)HashTabOf (i) > 0 )
++            goto probe;
++nomatch:
++        output ( (code_int) ent );
++        ++out_count;
++        ent = c;
++#ifdef SIGNED_COMPARE_SLOW
++        if ( (unsigned) free_ent < (unsigned) maxmaxcode) {
++#else /*SIGNED_COMPARE_SLOW*/
++        if ( free_ent < maxmaxcode ) {  /* } */
++#endif /*SIGNED_COMPARE_SLOW*/
++            CodeTabOf (i) = free_ent++; /* code -> hashtable */
++            HashTabOf (i) = fcode;
++        } else
++                cl_block();
++    }
++    /*
++     * Put out the final code.
++     */
++    output( (code_int)ent );
++    ++out_count;
++    output( (code_int) EOFCode );
++}
++
++/*****************************************************************
++ * 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 unsigned long cur_accum = 0;
++static int cur_bits = 0;
++
++static unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
++                                  0x001F, 0x003F, 0x007F, 0x00FF,
++                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
++                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
++
++static void
++output(code_int code)
++{
++    cur_accum &= masks[ cur_bits ];
++
++    if( cur_bits > 0 )
++        cur_accum |= ((long)code << cur_bits);
++    else
++        cur_accum = code;
++
++    cur_bits += n_bits;
++
++    while( cur_bits >= 8 ) {
++        char_out( (unsigned int)(cur_accum & 0xff) );
++        cur_accum >>= 8;
++        cur_bits -= 8;
++    }
++
++    /*
++     * If the next entry is going to be too big for the code size,
++     * then increase it, if possible.
++     */
++   if ( free_ent > maxcode || clear_flg ) {
++
++            if( clear_flg ) {
++
++                maxcode = MAXCODE (n_bits = g_init_bits);
++                clear_flg = 0;
++
++            } else {
++
++                ++n_bits;
++                if ( n_bits == maxbits )
++                    maxcode = maxmaxcode;
++                else
++                    maxcode = MAXCODE(n_bits);
++            }
++        }
++
++    if( code == EOFCode ) {
++        /*
++         * At EOF, write the rest of the buffer.
++         */
++        while( cur_bits > 0 ) {
++                char_out( (unsigned int)(cur_accum & 0xff) );
++                cur_accum >>= 8;
++                cur_bits -= 8;
++        }
++
++        flush_char();
++
++/*        fflush( g_outfile ); */
++/* */
++/*        if( ferror( g_outfile ) ) */
++/*		return; */
++    }
++}
++
++/*
++ * Clear out the hash table
++ */
++static void
++cl_block (void)             /* table clear for block compress */
++{
++
++        cl_hash ( (count_int) hsize );
++        free_ent = ClearCode + 2;
++        clear_flg = 1;
++
++        output( (code_int)ClearCode );
++}
++
++static void
++cl_hash(register count_int hsize)          /* reset code table */
++                         
++{
++
++        register count_int *htab_p = 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
++ *
++ ******************************************************************************/
++
++/*
++ * Number of characters so far in this 'packet'
++ */
++static int a_count;
++
++/*
++ * Set up the 'byte output' routine
++ */
++static void
++char_init(void)
++{
++        a_count = 0;
++}
++
++/*
++ * Define the storage for the packet accumulator
++ */
++static char accum[ 256 ];
++
++/*
++ * Add a character to the end of the current packet, and if it is 254
++ * characters, flush the packet to disk.
++ */
++static void
++char_out(int c)
++{
++        accum[ a_count++ ] = c;
++        if( a_count >= 254 )
++                flush_char();
++}
++
++/*
++ * Flush the packet to disk, and reset the accumulator
++ */
++static void
++flush_char(void)
++{
++        if( a_count > 0 ) {
++                gdPutC( a_count, g_outfile );
++                gdPutBuf( accum, a_count, g_outfile );
++                a_count = 0;
++        }
++}
++
++static void init_statics(void) {
++	/* Some of these are properly initialized later. What I'm doing
++		here is making sure code that depends on C's initialization
++		of statics doesn't break when the code gets called more
++		than once. */
++	Width = 0;
++	Height = 0;
++	curx = 0;
++	cury = 0;
++	CountDown = 0;
++	Pass = 0;
++	Interlace = 0;
++	a_count = 0;
++	cur_accum = 0;
++	cur_bits = 0;
++	g_init_bits = 0;
++	g_outfile = 0;
++	ClearCode = 0;
++	EOFCode = 0;
++	free_ent = 0;
++	clear_flg = 0;
++	offset = 0;
++	in_count = 1;
++	out_count = 0;	
++	hsize = HSIZE;
++	n_bits = 0;
++	maxbits = GIFBITS;
++	maxcode = 0;
++	maxmaxcode = (code_int)1 << GIFBITS;
++}
++
++
++/* +-------------------------------------------------------------------+ */
++/* | Copyright 1990, 1991, 1993, David Koblas.  (koblas@netcom.com)    | */
++/* |   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" without express or implied warranty.           | */
++/* +-------------------------------------------------------------------+ */
+diff -ruN php-4.3.3RC1.orig/ext/gd/php_gd.h php-4.3.3RC1/ext/gd/php_gd.h
+--- php-4.3.3RC1.orig/ext/gd/php_gd.h	Mon Jun 23 10:05:28 2003
++++ php-4.3.3RC1/ext/gd/php_gd.h	Mon Jun 23 10:06:17 2003
+@@ -40,6 +40,8 @@
+ #define PHP_GDIMG_TYPE_GD       8
+ #define PHP_GDIMG_TYPE_GD2      9
+ #define PHP_GDIMG_TYPE_GD2PART 10
++#define PHP_GDIMG_TYPE_GIFANIMBEGIN 11
++#define PHP_GDIMG_TYPE_GIFANIMADD 12
+ 
+ #ifdef PHP_WIN32
+ #define PHP_GD_API __declspec(dllexport)
+@@ -137,6 +139,9 @@
+ PHP_FUNCTION(imagefontheight);
+ 
+ PHP_FUNCTION(imagegif );
++PHP_FUNCTION(imagegifanimbegin);
++PHP_FUNCTION(imagegifanimadd);
++PHP_FUNCTION(imagegifanimend);
+ PHP_FUNCTION(imagejpeg );
+ PHP_FUNCTION(imagepng);
+ PHP_FUNCTION(imagewbmp);
+diff -ruN php-4.3.3RC1.orig/main/php_config.h.in php-4.3.3RC1/main/php_config.h.in
+--- php-4.3.3RC1.orig/main/php_config.h.in	Mon Jun 23 10:05:59 2003
++++ php-4.3.3RC1/main/php_config.h.in	Mon Jun 23 10:06:17 2003
+@@ -1523,6 +1523,9 @@
+ #undef HAVE_GD_GIF_CREATE
+ 
+ /*   */
++#undef HAVE_GD_GIF_ANIM
++
++/*   */
+ #undef HAVE_GD_WBMP
+ 
+ /*   */