sync/ports
1
0
Fork 0
mirror of https://git.freebsd.org/ports.git synced 2025-06-17 10:40:46 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
ports/lang/php5/files/gd_gif_out.diff
Norikatsu Shigemura e7a14dfeef 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)
2003-06-23 13:06:55 +00:00

1418 lines
40 KiB
Diff
Raw Blame History

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
/* */
Reference in a new issue View git blame Copy permalink