summaryrefslogtreecommitdiffstats
path: root/graphics/php4-gd
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/php4-gd')
-rw-r--r--graphics/php4-gd/Makefile14
-rw-r--r--graphics/php4-gd/files/patch-config.m480
-rw-r--r--graphics/php4-gd/files/patch-gd.c50
-rw-r--r--graphics/php4-gd/files/patch-gd_ctx.c158
-rw-r--r--graphics/php4-gd/files/patch-libgd::gd.h45
-rw-r--r--graphics/php4-gd/files/patch-libgd::gd_biggif_out.c1087
-rw-r--r--graphics/php4-gd/files/patch-libgd::gd_gif_out.c73
-rw-r--r--graphics/php4-gd/files/patch-libgd::gd_lzw_out.c939
-rw-r--r--graphics/php4-gd/files/patch-php_gd.h21
9 files changed, 2467 insertions, 0 deletions
diff --git a/graphics/php4-gd/Makefile b/graphics/php4-gd/Makefile
new file mode 100644
index 0000000..4e1f0b8
--- /dev/null
+++ b/graphics/php4-gd/Makefile
@@ -0,0 +1,14 @@
+# New ports collection makefile for: php4-gd
+# Date created: 7 Jul 2004
+# Whom: Alex Dupre <ale@FreeBSD.org>
+#
+# $FreeBSD$
+#
+
+CATEGORIES= graphics
+
+MASTERDIR= ${.CURDIR}/../../lang/php4
+
+PKGNAMESUFFIX= -gd
+
+.include "${MASTERDIR}/Makefile"
diff --git a/graphics/php4-gd/files/patch-config.m4 b/graphics/php4-gd/files/patch-config.m4
new file mode 100644
index 0000000..4d79567
--- /dev/null
+++ b/graphics/php4-gd/files/patch-config.m4
@@ -0,0 +1,80 @@
+--- config.m4.orig Thu Dec 25 23:33:02 2003
++++ config.m4 Wed Jul 7 14:37:18 2004
+@@ -43,6 +43,9 @@
+ PHP_ARG_ENABLE(gd-jis-conv, whether to enable JIS-mapped Japanese font support in GD,
+ [ --enable-gd-jis-conv GD: Enable JIS-mapped Japanese font support.], no, no)
+
++PHP_ARG_ENABLE(gd-lzw-gif, whether to enable LZW-compressed GIF support in GD,
++[ --enable-gd-lzw-gif GD: Enable LZW-compressed GIF support.], no, no)
++
+ dnl
+ dnl Checks for the configure options
+ dnl
+@@ -219,7 +222,7 @@
+ ],[
+ AC_MSG_ERROR([Problem with libt1.(a|so). Please check config.log for more information.])
+ ],[
+- -L$GD_T1_DIR/lib
++ -L$GD_T1_DIR/lib -lm
+ ])
+ fi
+ ])
+@@ -236,6 +239,12 @@
+ fi
+ ])
+
++AC_DEFUN(PHP_GD_LZW,[
++ if test "$PHP_GD_LZW_GIF" = "yes"; then
++ USE_GD_LZW_GIF=1
++ fi
++])
++
+ AC_DEFUN(PHP_GD_CHECK_VERSION,[
+ PHP_CHECK_LIBRARY(gd, gdImageString16, [AC_DEFINE(HAVE_LIBGD13, 1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+ PHP_CHECK_LIBRARY(gd, gdImagePaletteCopy, [AC_DEFINE(HAVE_LIBGD15, 1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+@@ -256,6 +265,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 ])
+ PHP_CHECK_LIBRARY(gd, gdFontCacheShutdown, [AC_DEFINE(HAVE_GD_THREAD_SAFE, 1, [ ])], [], [ -L$GD_LIB $GD_SHARED_LIBADD ])
+ ])
+@@ -271,6 +281,7 @@
+ 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/gd_biggif_out.c libgd/gd_lzw_out.c libgd/gd_gif_out.c \
+ libgd/xbm.c"
+
+ dnl check for fabsf and floorf which are available since C99
+@@ -282,6 +293,7 @@
+ dnl Various checks for GD features
+ PHP_GD_TTSTR
+ PHP_GD_JISX0208
++ PHP_GD_LZW
+ PHP_GD_JPEG
+ PHP_GD_PNG
+ PHP_GD_XPM
+@@ -305,6 +317,9 @@
+ AC_DEFINE(HAVE_GD_XBM, 1, [ ])
+ AC_DEFINE(HAVE_GD_BUNDLED, 1, [ ])
+ AC_DEFINE(HAVE_GD_GIF_READ, 1, [ ])
++ AC_DEFINE(HAVE_GD_GIF_CREATE, 1, [ ])
++ AC_DEFINE(HAVE_GD_GIF_CTX, 1, [ ])
++ AC_DEFINE(HAVE_GD_GIF_ANIM, 1, [ ])
+ AC_DEFINE(HAVE_GD_IMAGEELLIPSE, 1, [ ])
+
+ dnl Make sure the libgd/ is first in the include path
+@@ -336,6 +351,11 @@
+ if test -n "$USE_GD_JIS_CONV"; then
+ AC_DEFINE(USE_GD_JISX0208, 1, [ ])
+ GDLIB_CFLAGS="$GDLIB_CFLAGS -DJISX0208"
++ fi
++
++ if test -n "$USE_GD_LZW_GIF"; then
++ AC_DEFINE(USE_GD_LZW, 1, [ ])
++ GDLIB_CFLAGS="$GDLIB_CFLAGS -DLZW_LICENCED"
+ fi
+
+ else
diff --git a/graphics/php4-gd/files/patch-gd.c b/graphics/php4-gd/files/patch-gd.c
new file mode 100644
index 0000000..3faf7bb
--- /dev/null
+++ b/graphics/php4-gd/files/patch-gd.c
@@ -0,0 +1,50 @@
+--- gd.c.orig Wed Jun 4 02:22:30 2003
++++ gd.c Sat Jun 28 15:47:56 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 --git a/graphics/php4-gd/files/patch-gd_ctx.c b/graphics/php4-gd/files/patch-gd_ctx.c
new file mode 100644
index 0000000..a3f9a88
--- /dev/null
+++ b/graphics/php4-gd/files/patch-gd_ctx.c
@@ -0,0 +1,158 @@
+--- gd_ctx.c.orig Wed Mar 12 05:16:31 2003
++++ gd_ctx.c Sat Jun 28 15:47:56 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)) {
+@@ -56,7 +79,7 @@
+ RETURN_FALSE;
+ }
+
+- fp = VCWD_FOPEN(fn, "wb");
++ fp = VCWD_FOPEN(fn, PHP_GDIMG_TYPE_GIFANIMADD == image_type ? "ab" : "wb");
+ if (!fp) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' for writing", fn);
+ RETURN_FALSE;
+@@ -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, "ab");
++ 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 --git a/graphics/php4-gd/files/patch-libgd::gd.h b/graphics/php4-gd/files/patch-libgd::gd.h
new file mode 100644
index 0000000..7d15f41
--- /dev/null
+++ b/graphics/php4-gd/files/patch-libgd::gd.h
@@ -0,0 +1,45 @@
+--- libgd/gd.h.orig Wed Apr 9 03:55:56 2003
++++ libgd/gd.h Sat Jun 28 15:47:56 2003
+@@ -446,6 +446,30 @@
+ gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr in);
+ gdImagePtr gdImageCreateFromGifSource(gdSourcePtr in);
+
++void gdImageLzw(gdImagePtr im, FILE *out);
++void* gdImageLzwPtr(gdImagePtr im, int *size);
++void gdImageLzwCtx(gdImagePtr im, gdIOCtxPtr out);
++
++void gdImageBigGif(gdImagePtr im, FILE *out);
++void* gdImageBigGifPtr(gdImagePtr im, int *size);
++void gdImageBigGifCtx(gdImagePtr im, gdIOCtxPtr out);
++
++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 gdImageLzwAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void gdImageBigGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void gdImageGifAnimEnd(FILE *outFile);
++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 gdImageLzwAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void gdImageBigGifAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void gdImageGifAnimEndCtx(gdIOCtx *out);
++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 *gdImageLzwAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal);
++void *gdImageBigGifAnimAddPtr(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. */
+ /* The sink function must return -1 on error, otherwise the number
+@@ -457,6 +481,11 @@
+ } gdSink, *gdSinkPtr;
+
+ void gdImagePngToSink(gdImagePtr im, gdSinkPtr out);
++
++void gdImageGif (gdImagePtr im, FILE *out);
++void* gdImageGifPtr (gdImagePtr im, int *size);
++void gdImageGifCtx (gdImagePtr im, gdIOCtxPtr out);
++void gdImageGifToSink (gdImagePtr im, gdSinkPtr out);
+
+ void gdImageGd(gdImagePtr im, FILE *out);
+ void gdImageGd2(gdImagePtr im, FILE *out, int cs, int fmt);
diff --git a/graphics/php4-gd/files/patch-libgd::gd_biggif_out.c b/graphics/php4-gd/files/patch-libgd::gd_biggif_out.c
new file mode 100644
index 0000000..efa29dc
--- /dev/null
+++ b/graphics/php4-gd/files/patch-libgd::gd_biggif_out.c
@@ -0,0 +1,1087 @@
+--- libgd/gd_biggif_out.c.orig Sat Jun 28 15:47:56 2003
++++ libgd/gd_biggif_out.c Sat Jun 28 15:47:56 2003
+@@ -0,0 +1,1084 @@
++#include <stdio.h>
++#include <math.h>
++#include <string.h>
++#include <stdlib.h>
++#include "gd.h"
++#include "gdhelpers.h"
++
++/*
++** Wrapper functions for this module.
++*/
++
++void gdImageBigGif(gdImagePtr im, FILE *outFile)
++{
++ gdIOCtx *out = gdNewFileCtx(outFile);
++ gdImageBigGifCtx(im, out);
++ out->gd_free(out);
++}
++
++void* gdImageBigGifPtr(gdImagePtr im, int *size)
++{
++ void *rv;
++ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
++ gdImageBigGifCtx(im, out);
++ rv = gdDPExtractData(out,size);
++ out->gd_free(out);
++ return rv;
++}
++
++void gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops)
++{
++ gdIOCtx *out = gdNewFileCtx(outFile);
++ gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
++ out->gd_free(out);
++}
++
++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 gdImageBigGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++ gdIOCtx *out = gdNewFileCtx(outFile);
++ gdImageBigGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++ out->gd_free(out);
++}
++
++void *gdImageBigGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++ void *rv;
++ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
++ gdImageBigGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++ rv = gdDPExtractData(out,size);
++ out->gd_free(out);
++ return rv;
++}
++
++void gdImageGifAnimEnd(FILE *outFile)
++{
++#if 1
++ putc (';', outFile);
++#else
++ gdIOCtx *out = gdNewFileCtx(outFile);
++ gdImageGifAnimEndCtx(out);
++ out->gd_free(out);
++#endif
++}
++
++void* gdImageGifAnimEndPtr(int *size)
++{
++ char *rv = (char *) gdMalloc (1);
++ *rv = ';';
++ *size = 1;
++ return (void *)rv;
++}
++
++
++/* 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.
++*
++* Heavily modified by Mouse, 1998-02-12.
++* Remove LZW compression.
++* Added miGIF run length compression.
++*
++*/
++
++/*
++ * a code_int must be able to hold 2**GIFBITS values of type int, and also -1
++ */
++typedef int code_int;
++
++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 GIFcompress (int, gdIOCtx *, gdImagePtr);
++static void output (code_int code);
++
++/* UNUSED
++* static void char_init (void);
++* static void char_out (int c);
++*/
++
++/* Allows for reuse */
++static void init_statics(void);
++
++void gdImageBigGifCtx(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 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 gdImageBigGifAnimAddCtx(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 );
++}
++
++
++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
++ */
++ GIFcompress( 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
++ */
++ GIFcompress( 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, gdIOCtx *fp) */
++/*{ */
++/* fputc( w & 0xff, fp ); */
++/* fputc( (w / 256) & 0xff, fp ); */
++/*} */
++
++#define GIFBITS 12
++
++/*-----------------------------------------------------------------------
++ *
++ * miGIF Compression - mouse and ivo's GIF-compatible compression
++ *
++ * -run length encoding compression routines-
++ *
++ * Copyright (C) 1998 Hutchison Avenue Software Corporation
++ * http://www.hasc.com
++ * info@hasc.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." 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.
++ *
++ */
++
++static int rl_pixel;
++static int rl_basecode;
++static int rl_count;
++static int rl_table_pixel;
++static int rl_table_max;
++static int just_cleared;
++static int out_bits;
++static int out_bits_init;
++static int out_count;
++static int out_bump;
++static int out_bump_init;
++static int out_clear;
++static int out_clear_init;
++static int max_ocodes;
++static int code_clear;
++static int code_eof;
++static unsigned int obuf;
++static int obits;
++static gdIOCtx *ofile;
++static unsigned char oblock[256];
++static int oblen;
++
++/* Used only when debugging GIF compression code */
++/* #define DEBUGGING_ENVARS */
++
++#ifdef DEBUGGING_ENVARS
++
++static int verbose_set = 0;
++static int verbose;
++#define VERBOSE (verbose_set?verbose:set_verbose())
++
++static int set_verbose(void)
++{
++ verbose = !!getenv("GIF_VERBOSE");
++ verbose_set = 1;
++ return(verbose);
++}
++
++#else
++
++#define VERBOSE 0
++
++#endif
++
++
++static const char *binformat(unsigned int v, int nbits)
++{
++ 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=1U<<bno;bno>=0;bno--,bit>>=1)
++ { *bp++ = (v & bit) ? '1' : '0';
++ if (((bno&3) == 0) && (bno != 0)) *bp++ = '.';
++ }
++ *bp = '\0';
++ return(&bufs[bhand][0]);
++}
++
++static void write_block(void)
++{
++ int i;
++
++ if (VERBOSE)
++ { printf("write_block %d:",oblen);
++ for (i=0;i<oblen;i++) printf(" %02x",oblock[i]);
++ printf("\n");
++ }
++ gdPutC(oblen,ofile);
++ gdPutBuf(&oblock[0],oblen,ofile);
++ oblen = 0;
++}
++
++static void block_out(unsigned char c)
++{
++ if (VERBOSE) printf("block_out %s\n",binformat(c,8));
++ oblock[oblen++] = c;
++ if (oblen >= 255) write_block();
++}
++
++static void block_flush(void)
++{
++ if (VERBOSE) printf("block_flush\n");
++ if (oblen > 0) write_block();
++}
++
++static void output(int val)
++{
++ if (VERBOSE) printf("output %s [%s %d %d]\n",binformat(val,out_bits),binformat(obuf,obits),obits,out_bits);
++ obuf |= val << obits;
++ obits += out_bits;
++ while (obits >= 8)
++ { block_out(obuf&0xff);
++ obuf >>= 8;
++ obits -= 8;
++ }
++ if (VERBOSE) printf("output leaving [%s %d]\n",binformat(obuf,obits),obits);
++}
++
++static void output_flush(void)
++{
++ if (VERBOSE) printf("output_flush\n");
++ if (obits > 0) block_out(obuf);
++ block_flush();
++}
++
++static void did_clear(void)
++{
++ if (VERBOSE) printf("did_clear\n");
++ out_bits = out_bits_init;
++ out_bump = out_bump_init;
++ out_clear = out_clear_init;
++ out_count = 0;
++ rl_table_max = 0;
++ just_cleared = 1;
++}
++
++static void output_plain(int c)
++{
++ if (VERBOSE) printf("output_plain %s\n",binformat(c,out_bits));
++ just_cleared = 0;
++ output(c);
++ out_count ++;
++ if (out_count >= out_bump)
++ { out_bits ++;
++ out_bump += 1 << (out_bits - 1);
++ }
++ if (out_count >= out_clear)
++ { output(code_clear);
++ did_clear();
++ }
++}
++
++static unsigned int isqrt(unsigned int x)
++{
++ unsigned int r;
++ unsigned int v;
++
++ 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;
++ }
++}
++
++static unsigned int compute_triangle_count(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;
++ }
++ if (count > 0)
++ { unsigned int n;
++ n = isqrt(count);
++ while ((n*(n+1)) >= 2*count) n --;
++ while ((n*(n+1)) < 2*count) n ++;
++ cost += n;
++ }
++ return(cost);
++}
++
++static void max_out_clear(void)
++{
++ out_clear = max_ocodes;
++}
++
++static void reset_out_clear(void)
++{
++ out_clear = out_clear_init;
++ if (out_count >= out_clear)
++ { output(code_clear);
++ did_clear();
++ }
++}
++
++static void rl_flush_fromclear(int count)
++{
++ int n;
++
++ if (VERBOSE) printf("rl_flush_fromclear %d\n",count);
++ max_out_clear();
++ rl_table_pixel = rl_pixel;
++ n = 1;
++ while (count > 0)
++ { if (n == 1)
++ { rl_table_max = 1;
++ output_plain(rl_pixel);
++ count --;
++ }
++ else if (count >= n)
++ { rl_table_max = n;
++ output_plain(rl_basecode+n-2);
++ count -= n;
++ }
++ else if (count == 1)
++ { rl_table_max ++;
++ output_plain(rl_pixel);
++ count = 0;
++ }
++ else
++ { rl_table_max ++;
++ output_plain(rl_basecode+count-2);
++ count = 0;
++ }
++ if (out_count == 0) n = 1; else n ++;
++ }
++ reset_out_clear();
++ if (VERBOSE) printf("rl_flush_fromclear leaving table_max=%d\n",rl_table_max);
++}
++
++static void rl_flush_clearorrep(int count)
++{
++ int withclr;
++
++ if (VERBOSE) printf("rl_flush_clearorrep %d\n",count);
++ withclr = 1 + compute_triangle_count(count,max_ocodes);
++ if (withclr < count)
++ { output(code_clear);
++ did_clear();
++ rl_flush_fromclear(count);
++ }
++ else
++ { for (;count>0;count--) output_plain(rl_pixel);
++ }
++}
++
++static void rl_flush_withtable(int count)
++{
++ int repmax;
++ int repleft;
++ int leftover;
++
++ if (VERBOSE) printf("rl_flush_withtable %d\n",count);
++ repmax = count / rl_table_max;
++ leftover = count % rl_table_max;
++ repleft = (leftover ? 1 : 0);
++ if (out_count+repmax+repleft > max_ocodes)
++ { repmax = max_ocodes - out_count;
++ leftover = count - (repmax * rl_table_max);
++ repleft = 1 + compute_triangle_count(leftover,max_ocodes);
++ }
++ if (VERBOSE) printf("rl_flush_withtable repmax=%d leftover=%d repleft=%d\n",repmax,leftover,repleft);
++ if (1+compute_triangle_count(count,max_ocodes) < repmax+repleft)
++ { output(code_clear);
++ did_clear();
++ rl_flush_fromclear(count);
++ return;
++ }
++ max_out_clear();
++ for (;repmax>0;repmax--) output_plain(rl_basecode+rl_table_max-2);
++ if (leftover)
++ { if (just_cleared)
++ { rl_flush_fromclear(leftover);
++ }
++ else if (leftover == 1)
++ { output_plain(rl_pixel);
++ }
++ else
++ { output_plain(rl_basecode+leftover-2);
++ }
++ }
++ reset_out_clear();
++}
++
++static void rl_flush(void)
++{
++ /* UNUSED int table_reps; */
++ /* UNUSED int table_extra; */
++
++ if (VERBOSE) printf("rl_flush [ %d %d\n",rl_count,rl_pixel);
++ if (rl_count == 1)
++ { output_plain(rl_pixel);
++ rl_count = 0;
++ if (VERBOSE) printf("rl_flush ]\n");
++ return;
++ }
++ if (just_cleared)
++ { rl_flush_fromclear(rl_count);
++ }
++ else if ((rl_table_max < 2) || (rl_table_pixel != rl_pixel))
++ { rl_flush_clearorrep(rl_count);
++ }
++ else
++ { rl_flush_withtable(rl_count);
++ }
++ if (VERBOSE) printf("rl_flush ]\n");
++ rl_count = 0;
++}
++
++static void GIFcompress(int init_bits, gdIOCtx *outfile, gdImagePtr im)
++{
++ int c;
++
++ ofile = outfile;
++ obuf = 0;
++ obits = 0;
++ oblen = 0;
++ code_clear = 1 << (init_bits - 1);
++ code_eof = code_clear + 1;
++ rl_basecode = code_eof + 1;
++ out_bump_init = (1 << (init_bits - 1)) - 1;
++ /* for images with a lot of runs, making out_clear_init larger will
++ give better compression. */
++ out_clear_init = (init_bits <= 3) ? 9 : (out_bump_init-1);
++#ifdef DEBUGGING_ENVARS
++ { const char *ocienv;
++ ocienv = getenv("GIF_OUT_CLEAR_INIT");
++ if (ocienv)
++ { out_clear_init = atoi(ocienv);
++ if (VERBOSE) printf("[overriding out_clear_init to %d]\n",out_clear_init);
++ }
++ }
++#endif
++ out_bits_init = init_bits;
++ max_ocodes = (1 << GIFBITS) - ((1 << (out_bits_init - 1)) + 3);
++ did_clear();
++ output(code_clear);
++ rl_count = 0;
++ while (1)
++ { c = GIFNextPixel(im);
++ if ((rl_count > 0) && (c != rl_pixel)) rl_flush();
++ if (c == EOF) break;
++ if (rl_pixel == c)
++ { rl_count ++;
++ }
++ else
++ { rl_pixel = c;
++ rl_count = 1;
++ }
++ }
++ output(code_eof);
++ output_flush();
++}
++
++/*-----------------------------------------------------------------------
++ *
++ * End of miGIF section - See copyright notice at start of section.
++ *
++ *-----------------------------------------------------------------------
++*/
++
++/******************************************************************************
++ *
++ * GIF Specific routines
++ *
++ ******************************************************************************/
++
++/*
++ * Number of characters so far in this 'packet'
++ */
++static int a_count;
++
++/*
++ * Set up the 'byte output' routine
++ */
++
++/* UNUSED
++* static void
++* char_init(void)
++* {
++* a_count = 0;
++* }
++*/
++
++/*
++ * Define the storage for the packet accumulator
++ */
++
++/* UNUSED static char accum[ 256 ]; */
++
++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;
++}
++
++
++/* +-------------------------------------------------------------------+ */
++/* | 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 --git a/graphics/php4-gd/files/patch-libgd::gd_gif_out.c b/graphics/php4-gd/files/patch-libgd::gd_gif_out.c
new file mode 100644
index 0000000..6823e9d
--- /dev/null
+++ b/graphics/php4-gd/files/patch-libgd::gd_gif_out.c
@@ -0,0 +1,73 @@
+--- libgd/gd_gif_out.c.orig Sat Jun 28 15:47:56 2003
++++ libgd/gd_gif_out.c Sat Jun 28 16:07:33 2003
+@@ -0,0 +1,70 @@
++#include <stdio.h>
++#include <math.h>
++#include <string.h>
++#include <stdlib.h>
++#include "gd.h"
++
++/*
++** Wrapper functions for GIF output.
++*/
++
++void gdImageGifToSink(gdImagePtr im, gdSinkPtr outSink)
++{
++ gdIOCtx *out = gdNewSSCtx(NULL,outSink);
++ gdImageGifCtx(im, out);
++ out->gd_free(out);
++}
++
++void gdImageGifCtx(gdImagePtr im, gdIOCtx *out)
++{
++#ifdef LZW_LICENCED
++ gdImageLzwCtx(im, out);
++#else
++ gdImageBigGifCtx(im, out);
++#endif
++}
++
++void gdImageGif(gdImagePtr im, FILE *outFile)
++{
++#ifdef LZW_LICENCED
++ gdImageLzw(im, outFile);
++#else
++ gdImageBigGif(im, outFile);
++#endif
++}
++
++void* gdImageGifPtr(gdImagePtr im, int *size)
++{
++#ifdef LZW_LICENCED
++ return gdImageLzwPtr(im, size);
++#else
++ return gdImageBigGifPtr(im, size);
++#endif
++}
++
++void gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++#ifdef LZW_LICENCED
++ gdImageLzwAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++#else
++ gdImageBigGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++#endif
++}
++
++void gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++#ifdef LZW_LICENCED
++ gdImageLzwAnimAdd(im, outFile, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++#else
++ gdImageBigGifAnimAdd(im, outFile, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++#endif
++}
++
++void *gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++#ifdef LZW_LICENCED
++ return gdImageLzwAnimAddPtr(im, size, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++#else
++ return gdImageBigGifAnimAddPtr(im, size, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++#endif
++}
diff --git a/graphics/php4-gd/files/patch-libgd::gd_lzw_out.c b/graphics/php4-gd/files/patch-libgd::gd_lzw_out.c
new file mode 100644
index 0000000..ffe1470
--- /dev/null
+++ b/graphics/php4-gd/files/patch-libgd::gd_lzw_out.c
@@ -0,0 +1,939 @@
+--- libgd/gd_lzw_out.c.orig Sat Jun 28 15:47:56 2003
++++ libgd/gd_lzw_out.c Sat Jun 28 16:01:04 2003
+@@ -0,0 +1,936 @@
++#ifdef HAVE_MALLOC_H
++ #include <malloc.h>
++#endif
++#include <stdio.h>
++#include <math.h>
++#include <string.h>
++#include <stdlib.h>
++#include "gd.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 gdImageLzwCtx(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 gdImageLzw(gdImagePtr im, FILE *outFile)
++{
++ gdIOCtx *out = gdNewFileCtx(outFile);
++ gdImageLzwCtx(im, out);
++ out->gd_free(out);
++}
++
++void* gdImageLzwPtr(gdImagePtr im, int *size)
++{
++ void *rv;
++ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
++ gdImageLzwCtx(im, out);
++ rv = gdDPExtractData(out,size);
++ out->gd_free(out);
++ return rv;
++}
++
++void gdImageLzwAnimAddCtx(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 gdImageLzwAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++ gdIOCtx *out = gdNewFileCtx(outFile);
++ gdImageLzwAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++ out->gd_free(out);
++}
++
++void* gdImageLzwAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal)
++{
++ void *rv;
++ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
++ gdImageLzwAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal);
++ rv = gdDPExtractData(out,size);
++ out->gd_free(out);
++ return 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 --git a/graphics/php4-gd/files/patch-php_gd.h b/graphics/php4-gd/files/patch-php_gd.h
new file mode 100644
index 0000000..1b3e4f4
--- /dev/null
+++ b/graphics/php4-gd/files/patch-php_gd.h
@@ -0,0 +1,21 @@
+--- php_gd.h.orig Mon Mar 31 10:49:30 2003
++++ php_gd.h Sat Jun 28 15:47:56 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);
OpenPOWER on IntegriCloud