diff -Nur gd-2.0.17.orig/gd2togif.c gd-2.0.17/gd2togif.c --- gd-2.0.17.orig/gd2togif.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/gd2togif.c 2003-12-26 15:35:52.279572344 +0100 @@ -0,0 +1,40 @@ +#include +#include "gd.h" + +/* A short program which converts a .gif file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int main(int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + if (argc != 3) { + fprintf(stderr, "Usage: gd2togif filename.gd2 filename.gif\n"); + exit(1); + } + in = fopen(argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit(1); + } + im = gdImageCreateFromGd2(in); + fclose(in); + if (!im) { + fprintf(stderr, "Input is not in GIF format!\n"); + exit(1); + } + out = fopen(argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy(im); + exit(1); + } + gdImageGif(im, out); + fclose(out); + gdImageDestroy(im); + + return 0; +} + diff -Nur gd-2.0.17.orig/gd_biggif_out.c gd-2.0.17/gd_biggif_out.c --- gd-2.0.17.orig/gd_biggif_out.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/gd_biggif_out.c 2003-12-26 15:35:52.285571432 +0100 @@ -0,0 +1,823 @@ +#include +#include +#include +#include +#include "gd.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; +} + +/* Code drawn from ppmtogif.c, from the pbmplus package +** +** Based on GIFENCOD by David Rowley . A +** Lempel-Zim compression based on "compress". +** +** Modified by Marcel Wijkstra +** +** 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 Putword (int w, gdIOCtx *fp); */ +static void GIFcompress (int, gdIOCtx *, gdImagePtr, int); +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); +} + +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) << 4; + + /* + * 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= 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, Background ); + + /* + * Write out a Zero-length packet (to end the series) + */ + gdPutC( 0, fp ); + + /* + * Write the GIF file terminator + */ + gdPutC( ';', 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<=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= 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 background) +{ + 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 -Nur gd-2.0.17.orig/gd.c gd-2.0.17/gd.c --- gd-2.0.17.orig/gd.c 2003-12-24 22:43:06.000000000 +0100 +++ gd-2.0.17/gd.c 2003-12-26 15:35:52.264574624 +0100 @@ -2695,7 +2695,17 @@ } void -gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c) +gdImagePolygon(gdImagePtr im, gdPointPtr p, int n, int c) +{ + if (!n) { + return; + } + gdImageLine(im, p->x, p->y, p[n-1].x, p[n-1].y, c); + gdImageOpenPolygon(im, p, n, c); +} + +void +gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c) { int i; int lx, ly; @@ -2711,7 +2721,6 @@ lx = p->x; ly = p->y; - gdImageLine (im, lx, ly, p[n - 1].x, p[n - 1].y, c); for (i = 1; (i < n); i++) { p++; diff -Nur gd-2.0.17.orig/gdcmpgif.c gd-2.0.17/gdcmpgif.c --- gd-2.0.17.orig/gdcmpgif.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/gdcmpgif.c 2003-12-26 15:35:52.303568696 +0100 @@ -0,0 +1,85 @@ +#include +#include /* For unlink function */ +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2); + + +int main(int argc, char **argv) +{ + gdImagePtr im1, im2; + FILE *in; + + if (argc != 3) { + fprintf(stderr, "Usage: gdcmpgif filename.gif filename.gif\n"); + exit(1); + } + in = fopen(argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit(1); + } + im1 = gdImageCreateFromGif(in); + fclose(in); + + if (!im1) { + fprintf(stderr, "Input is not in GIF format!\n"); + exit(1); + } + + in = fopen(argv[2], "rb"); + if (!in) { + fprintf(stderr, "Input file 2 does not exist!\n"); + exit(1); + } + im2 = gdImageCreateFromGif(in); + fclose(in); + + if (!im2) { + fprintf(stderr, "Input 2 is not in GIF format!\n"); + exit(1); + } + + CompareImages("gdcmpgif", im1, im2); + + gdImageDestroy(im1); + gdImageDestroy(im2); + + return 0; +} + +void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2) +{ + int cmpRes; + + cmpRes = gdImageCompare(im1, im2); + + if (cmpRes & GD_CMP_IMAGE) { + printf("%%%s: ERROR images differ: BAD\n",msg); + } else if (cmpRes != 0) { + printf("%%%s: WARNING images differ: WARNING - Probably OK\n",msg); + } else { + printf("%%%s: OK\n",msg); + return; + } + + if (cmpRes & (GD_CMP_SIZE_X + GD_CMP_SIZE_Y)) { + printf("-%s: INFO image sizes differ\n",msg); + } + + if (cmpRes & GD_CMP_NUM_COLORS) { + printf("-%s: INFO number of pallette entries differ %d Vs. %d\n",msg, + im1->colorsTotal, im2->colorsTotal); + } + + if (cmpRes & GD_CMP_COLOR) { + printf("-%s: INFO actual colours of pixels differ\n",msg); + } +} + + diff -Nur gd-2.0.17.orig/gd_gif_in.c gd-2.0.17/gd_gif_in.c --- gd-2.0.17.orig/gd_gif_in.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/gd_gif_in.c 2003-12-26 15:35:52.291570520 +0100 @@ -0,0 +1,573 @@ +#include +#include +#include +#include +#include "gd.h" + +/* 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 + + +#define MAXCOLORMAPSIZE 256 + +#define TRUE 1 +#define FALSE 0 + +#define CM_RED 0 +#define CM_GREEN 1 +#define CM_BLUE 2 + +#define MAX_LWZ_BITS 12 + +#define INTERLACE 0x40 +#define LOCALCOLORMAP 0x80 +#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) + +#define ReadOK(file,buffer,len) (gdGetBuf(buffer, len, file) != 0) + +#define LM_to_uint(a,b) (((b)<<8)|(a)) + +/* We may eventually want to use this information, but def it out for now */ +#if 0 +static struct { + unsigned int Width; + unsigned int Height; + unsigned char ColorMap[3][MAXCOLORMAPSIZE]; + unsigned int BitPixel; + unsigned int ColorResolution; + unsigned int Background; + unsigned int AspectRatio; +} GifScreen; +#endif + +static struct { + int transparent; + int delayTime; + int inputFlag; + int disposal; +} Gif89 = { -1, -1, -1, 0 }; + +static int ReadColorMap (gdIOCtx *fd, int number, unsigned char (*buffer)[256]); +static int DoExtension (gdIOCtx *fd, int label, int *Transparent); +static int GetDataBlock (gdIOCtx *fd, unsigned char *buf); +static int GetCode (gdIOCtx *fd, int code_size, int flag); +static int LWZReadByte (gdIOCtx *fd, int flag, int input_code_size); + +static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace); /*1.4//, int ignore); */ + +int ZeroDataBlock; + +gdImagePtr gdImageCreateFromGifSource(gdSourcePtr inSource) +{ + gdIOCtx *in = gdNewSSCtx(inSource, NULL); + gdImagePtr im; + + im = gdImageCreateFromGifCtx(in); + + in->gd_free(in); + + return im; +} + +gdImagePtr +gdImageCreateFromGif(FILE *fdFile) +{ + gdIOCtx *fd = gdNewFileCtx(fdFile); + gdImagePtr im = 0; + + im = gdImageCreateFromGifCtx(fd); + + fd->gd_free(fd); + + return im; +} + +gdImagePtr +gdImageCreateFromGifCtx(gdIOCtxPtr fd) +{ +/* 1.4 int imageNumber; */ + int BitPixel; + int ColorResolution; + int Background; + int AspectRatio; + int Transparent = (-1); + unsigned char buf[16]; + unsigned char c; + unsigned char ColorMap[3][MAXCOLORMAPSIZE]; + unsigned char localColorMap[3][MAXCOLORMAPSIZE]; + int imw, imh; + int useGlobalColormap; + int bitPixel; + int i; + /*1.4//int imageCount = 0; */ + char version[4]; + + gdImagePtr im = 0; + ZeroDataBlock = FALSE; + + /*1.4//imageNumber = 1; */ + if (! ReadOK(fd,buf,6)) { + return 0; + } + if (strncmp((char *)buf,"GIF",3) != 0) { + return 0; + } + strncpy(version, (char *)buf + 3, 3); + version[3] = '\0'; + + if ((strcmp(version, "87a") != 0) && (strcmp(version, "89a") != 0)) { + return 0; + } + if (! ReadOK(fd,buf,7)) { + return 0; + } + BitPixel = 2<<(buf[4]&0x07); + ColorResolution = (int) (((buf[4]&0x70)>>3)+1); + Background = buf[5]; + AspectRatio = buf[6]; + + if (BitSet(buf[4], LOCALCOLORMAP)) { /* Global Colormap */ + if (ReadColorMap(fd, BitPixel, ColorMap)) { + return 0; + } + } + for (;;) { + if (! ReadOK(fd,&c,1)) { + return 0; + } + if (c == ';') { /* GIF terminator */ + goto terminated; + } + + if (c == '!') { /* Extension */ + if (! ReadOK(fd,&c,1)) { + return 0; + } + DoExtension(fd, c, &Transparent); + continue; + } + + if (c != ',') { /* Not a valid start character */ + continue; + } + + /*1.4//++imageCount; */ + + if (! ReadOK(fd,buf,9)) { + return 0; + } + + useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP); + + bitPixel = 1<<((buf[8]&0x07)+1); + + imw = LM_to_uint(buf[4],buf[5]); + imh = LM_to_uint(buf[6],buf[7]); + if (!(im = gdImageCreate(imw, imh))) { + return 0; + } + im->interlace = BitSet(buf[8], INTERLACE); + if (! useGlobalColormap) { + if (ReadColorMap(fd, bitPixel, localColorMap)) { + return 0; + } + ReadImage(im, fd, imw, imh, localColorMap, + BitSet(buf[8], INTERLACE)); + /*1.4//imageCount != imageNumber); */ + } else { + ReadImage(im, fd, imw, imh, + ColorMap, + BitSet(buf[8], INTERLACE)); + /*1.4//imageCount != imageNumber); */ + } + if (Transparent != (-1)) { + gdImageColorTransparent(im, Transparent); + } + goto terminated; + } + +terminated: + /* Terminator before any image was declared! */ + if (!im) { + return 0; + } + /* Check for open colors at the end, so + we can reduce colorsTotal and ultimately + BitsPerPixel */ + for (i=((im->colorsTotal-1)); (i>=0); i--) { + if (im->open[i]) { + im->colorsTotal--; + } else { + break; + } + } + return im; +} + +static int +ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256]) +{ + int i; + unsigned char rgb[3]; + + + for (i = 0; i < number; ++i) { + if (! ReadOK(fd, rgb, sizeof(rgb))) { + return TRUE; + } + buffer[CM_RED][i] = rgb[0] ; + buffer[CM_GREEN][i] = rgb[1] ; + buffer[CM_BLUE][i] = rgb[2] ; + } + + + return FALSE; +} + +static int +DoExtension(gdIOCtx *fd, int label, int *Transparent) +{ + static unsigned char buf[256]; + + switch (label) { + case 0xf9: /* Graphic Control Extension */ + (void) GetDataBlock(fd, (unsigned char*) buf); + Gif89.disposal = (buf[0] >> 2) & 0x7; + Gif89.inputFlag = (buf[0] >> 1) & 0x1; + Gif89.delayTime = LM_to_uint(buf[1],buf[2]); + if ((buf[0] & 0x1) != 0) + *Transparent = buf[3]; + + while (GetDataBlock(fd, (unsigned char*) buf) != 0) + ; + return FALSE; + default: + break; + } + while (GetDataBlock(fd, (unsigned char*) buf) != 0) + ; + + return FALSE; +} + +static int +GetDataBlock_(gdIOCtx *fd, unsigned char *buf) +{ + unsigned char count; + + if (! ReadOK(fd,&count,1)) { + return -1; + } + + ZeroDataBlock = count == 0; + + if ((count != 0) && (! ReadOK(fd, buf, count))) { + return -1; + } + + return count; +} + +static int +GetDataBlock(gdIOCtx *fd, unsigned char *buf) +{ + int rv; + int i; + + rv = GetDataBlock_(fd,buf); + if (VERBOSE) + { printf("[GetDataBlock returning %d",rv); + if (rv > 0) + { printf(":"); + for (i=0;i= lastbit) { + if (done) { + if (curbit >= lastbit) { + /* Oh well */ + } + return -1; + } + buf[0] = buf[last_byte-2]; + buf[1] = buf[last_byte-1]; + + if ((count = GetDataBlock(fd, &buf[2])) == 0) + done = TRUE; + + last_byte = 2 + count; + curbit = (curbit - lastbit) + 16; + lastbit = (2+count)*8 ; + } + + ret = 0; + for (i = curbit, j = 0; j < code_size; ++i, ++j) + ret |= ((buf[ i / 8 ] & (1 << (i % 8))) != 0) << j; + + curbit += code_size; + return ret; +} + +static int +GetCode(gdIOCtx *fd, int code_size, int flag) +{ + int rv; + + rv = GetCode_(fd,code_size,flag); + if (VERBOSE) printf("[GetCode(,%d,%d) returning %d]\n",code_size,flag,rv); + return(rv); +} + +#define STACK_SIZE ((1<<(MAX_LWZ_BITS))*2) +static int +LWZReadByte_(gdIOCtx *fd, int flag, int input_code_size) +{ + static int fresh = FALSE; + int code, incode; + static int code_size, set_code_size; + static int max_code, max_code_size; + static int firstcode, oldcode; + static int clear_code, end_code; + static int table[2][(1<< MAX_LWZ_BITS)]; + static int stack[STACK_SIZE], *sp; + register int i; + + if (flag) { + set_code_size = input_code_size; + code_size = set_code_size+1; + clear_code = 1 << set_code_size ; + end_code = clear_code + 1; + max_code_size = 2*clear_code; + max_code = clear_code+2; + + GetCode(fd, 0, TRUE); + + fresh = TRUE; + + for (i = 0; i < clear_code; ++i) { + table[0][i] = 0; + table[1][i] = i; + } + for (; i < (1< stack) + return *--sp; + + while ((code = GetCode(fd, code_size, FALSE)) >= 0) { + if (code == clear_code) { + for (i = 0; i < clear_code; ++i) { + table[0][i] = 0; + table[1][i] = i; + } + for (; i < (1< 0) + ; + + if (count != 0) + return -2; + } + + incode = code; + + if (sp == (stack + STACK_SIZE)) { + /* Bad compressed data stream */ + return -1; + } + + if (code >= max_code) { + *sp++ = firstcode; + code = oldcode; + } + + while (code >= clear_code) { + if (sp == (stack + STACK_SIZE)) { + /* Bad compressed data stream */ + return -1; + } + *sp++ = table[1][code]; + if (code == table[0][code]) { + /* Oh well */ + } + code = table[0][code]; + } + + *sp++ = firstcode = table[1][code]; + + if ((code = max_code) <(1<= max_code_size) && + (max_code_size < (1< stack) + return *--sp; + } + return code; +} + +static int +LWZReadByte(gdIOCtx *fd, int flag, int input_code_size) +{ + int rv; + + rv = LWZReadByte_(fd,flag,input_code_size); + if (VERBOSE) printf("[LWZReadByte(,%d,%d) returning %d]\n",flag,input_code_size,rv); + return(rv); +} + +static void +ReadImage(gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace) /*1.4//, int ignore) */ +{ + unsigned char c; + int v; + int xpos = 0, ypos = 0, pass = 0; + int i; + /* Stash the color map into the image */ + for (i=0; (ired[i] = cmap[CM_RED][i]; + im->green[i] = cmap[CM_GREEN][i]; + im->blue[i] = cmap[CM_BLUE][i]; + im->open[i] = 1; + } + /* Many (perhaps most) of these colors will remain marked open. */ + im->colorsTotal = gdMaxColors; + /* + ** Initialize the Compression routines + */ + if (! ReadOK(fd,&c,1)) { + return; + } + if (LWZReadByte(fd, TRUE, c) < 0) { + return; + } + + /* + ** If this is an "uninteresting picture" ignore it. + ** REMOVED For 1.4 + */ + /*if (ignore) { */ + /* while (LWZReadByte(fd, FALSE, c) >= 0) */ + /* ; */ + /* return; */ + /*} */ + + while ((v = LWZReadByte(fd,FALSE,c)) >= 0 ) { + /* This how we recognize which colors are actually used. */ + if (im->open[v]) { + im->open[v] = 0; + } + gdImageSetPixel(im, xpos, ypos, v); + ++xpos; + if (xpos == len) { + xpos = 0; + if (interlace) { + switch (pass) { + case 0: + case 1: + ypos += 8; break; + case 2: + ypos += 4; break; + case 3: + ypos += 2; break; + } + + if (ypos >= height) { + ++pass; + switch (pass) { + case 1: + ypos = 4; break; + case 2: + ypos = 2; break; + case 3: + ypos = 1; break; + default: + goto fini; + } + } + } else { + ++ypos; + } + } + if (ypos >= height) + break; + } + +fini: + if (LWZReadByte(fd,FALSE,c)>=0) { + /* Ignore extra */ + } +} + diff -Nur gd-2.0.17.orig/gd_gif_out.c gd-2.0.17/gd_gif_out.c --- gd-2.0.17.orig/gd_gif_out.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/gd_gif_out.c 2003-12-26 15:35:52.294570064 +0100 @@ -0,0 +1,46 @@ +#include +#include +#include +#include +#include "gd.h" + +/* +** Wrapper functions for GIF output. +*/ + +#define LZW_LICENCED + +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 +} + diff -Nur gd-2.0.17.orig/gd.h gd-2.0.17/gd.h --- gd-2.0.17.orig/gd.h 2003-12-24 20:55:14.000000000 +0100 +++ gd-2.0.17/gd.h 2003-12-26 15:35:52.276572800 +0100 @@ -240,6 +240,10 @@ gdImagePtr gdImageCreateFromPngSource (gdSourcePtr in); + gdImagePtr gdImageCreateFromGif (FILE *fd); + gdImagePtr gdImageCreateFromGifCtx (gdIOCtxPtr in); + gdImagePtr gdImageCreateFromGifSource (gdSourcePtr in); + gdImagePtr gdImageCreateFromGd (FILE * in); gdImagePtr gdImageCreateFromGdCtx (gdIOCtxPtr in); @@ -354,6 +358,7 @@ gdPoint, *gdPointPtr; void gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c); + void gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c); void gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c); /* These functions still work with truecolor images, @@ -455,6 +460,14 @@ /* Best to free this memory with gdFree(), not free() */ void *gdImageJpegPtr (gdImagePtr im, int *size, int quality); +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); + /* A custom data sink. For backwards compatibility. Use gdIOCtx instead. */ /* The sink function must return -1 on error, otherwise the number @@ -469,6 +482,11 @@ 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 -Nur gd-2.0.17.orig/gd_lzw_out.c gd-2.0.17/gd_lzw_out.c --- gd-2.0.17.orig/gd_lzw_out.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/gd_lzw_out.c 2003-12-26 15:35:52.300569152 +0100 @@ -0,0 +1,796 @@ +#include +#include +#include +#include +#include +#include "gd.h" + +/* Code drawn from ppmtogif.c, from the pbmplus package +** +** Based on GIFENCOD by David Rowley . A +** Lempel-Zim compression based on "compress". +** +** Modified by Marcel Wijkstra +** +** 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 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; +} + + + +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= 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 ); +} + +/* */ +/* * 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 + +#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< 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 -Nur gd-2.0.17.orig/gdtest.c gd-2.0.17/gdtest.c --- gd-2.0.17.orig/gdtest.c 2003-03-29 16:46:35.000000000 +0100 +++ gd-2.0.17/gdtest.c 2003-12-26 15:35:52.313567176 +0100 @@ -91,6 +91,59 @@ gdImageDestroy (im2); ctx->gd_free (ctx); + /* */ + /* Send to GIF File then Ptr */ + /* */ + sprintf(of, "%s.gif", argv[1]); + out = fopen(of, "wb"); + gdImageGif(im, out); + fclose(out); + + in = fopen(of, "rb"); + if (!in) { + fprintf(stderr, "GIF Output file does not exist!\n"); + exit(1); + } + im2 = gdImageCreateFromGif(in); + fclose(in); + + CompareImages("GD->GIF File->GD", ref, im2); + + gdImageDestroy(im2); + + /* + ** Test gdImageCreateFromGifSource + **/ + + in = fopen(of, "rb"); + + if (!in) + { + fprintf (stderr, "GD Source: ERROR - GD Source input file does not exist - Sink may have failed!\n"); + }; + + imgsrc.source = freadWrapper; + imgsrc.context = in; + im2 = gdImageCreateFromGifSource(&imgsrc); + fclose(in); + + if (im2 == NULL) { + printf("GD Source (GIF): ERROR Null returned by gdImageCreateFromGifSource\n"); + } else { + CompareImages("GD Source (GIF)", ref, im2); + gdImageDestroy(im2); + }; + + unlink(of); + + iptr = gdImageGifPtr(im,&sz); + ctx = gdNewDynamicCtx(sz,iptr); + im2 = gdImageCreateFromGifCtx(ctx); + + CompareImages("GD->GIF ptr->GD", ref, im2); + + gdImageDestroy(im2); + ctx->gd_free(ctx); /* */ /* Send to GD2 File then Ptr */ @@ -209,8 +262,6 @@ gdImageDestroy (im2); }; - unlink (of); - /* */ /* Test Extraction */ /* */ @@ -277,6 +328,10 @@ printf ("[Merged Image has %d colours]\n", im2->colorsTotal); CompareImages ("Merged (gdtest.png, gdtest_merge.png)", im2, im3); + out = fopen ("test/gdtest_merge_out.png", "wb"); + gdImagePng(im2, out); + close(out); + gdImageDestroy (im2); gdImageDestroy (im3); diff -Nur gd-2.0.17.orig/gdtestft.c gd-2.0.17/gdtestft.c --- gd-2.0.17.orig/gdtestft.c 2003-03-29 16:46:35.000000000 +0100 +++ gd-2.0.17/gdtestft.c 2003-12-26 15:35:52.316566720 +0100 @@ -23,6 +23,8 @@ #define MAXY(x) MAX4(x[1],x[3],x[5],x[7]) #define MINY(x) MIN4(x[1],x[3],x[5],x[7]) +void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2); + int main (int argc, char *argv[]) { diff -Nur gd-2.0.17.orig/giftogd2.c gd-2.0.17/giftogd2.c --- gd-2.0.17.orig/giftogd2.c 1970-01-01 01:00:00.000000000 +0100 +++ gd-2.0.17/giftogd2.c 2003-12-26 15:35:52.319566264 +0100 @@ -0,0 +1,48 @@ +#include +#include + +#include "gd.h" + +/* A short program which converts a .gif file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int main(int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + int cs, fmt; + + if (argc != 5) { + fprintf(stderr, "Usage: giftogd2 filename.gif filename.gd2 cs fmt\n"); + fprintf(stderr, " where cs is the chunk size\n"); + fprintf(stderr, " fmt is 1 for raw, 2 for compressed\n"); + exit(1); + } + in = fopen(argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit(1); + } + im = gdImageCreateFromGif(in); + fclose(in); + if (!im) { + fprintf(stderr, "Input is not in GIF format!\n"); + exit(1); + } + out = fopen(argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy(im); + exit(1); + } + cs = atoi(argv[3]); + fmt = atoi(argv[4]); + gdImageGd2(im, out, cs, fmt); + fclose(out); + gdImageDestroy(im); + + return 0; +} + diff -Nur gd-2.0.17.orig/index.html gd-2.0.17/index.html --- gd-2.0.17.orig/index.html 2003-12-25 17:43:52.000000000 +0100 +++ gd-2.0.17/index.html 2003-12-26 15:38:31.022439760 +0100 @@ -28,7 +28,12 @@ more compatible with the major Web browsers than even PNG is. WBMP is intended for wireless devices (not regular web browsers). Old code will need modification to call gdImagePng or gdImageJpeg instead -of gdImageGif. Please do not ask us to send you the old GIF +of gdImageGif. +

+Note: The version at this site also supports GIF format, for those people +who have not yet managed to move away from GIFs. +

+Please do not ask the original author to send you the old GIF version of GD. Yes, Unisys still holds a patent on the LZW compression algorithm in some countries. The best solution is to move to legally unencumbered, well-compressed, @@ -117,6 +122,18 @@ Portions relating to WBMP copyright 2000, 2001, 2002 Maurice Szmurlo and Johan Van den Brande.

+GIF decompression code copyright 1990, 1991, 1993, by David Koblas +(koblas@netcom.com). +

+Non-LZW-based GIF compression code copyright 1998, by Hutchison Avenue +Software Corporation (http://www.hasc.com/, +info@hasc.com). +

+LZW-based GIF compression code David Rowley. +Obtaining a license for the Unisys LZW compression patent is +entirely between the user and Unisys. The authors of gd can provide +NO assistance in this matter. +

Permission has been granted to copy, distribute and modify gd in any context without fee, including a commercial application, provided that this notice is present in user-accessible supporting documentation. @@ -202,6 +219,24 @@

  • fly, by Martin Gleeson
+

What's new in the patched version?

+ +This version reinstates GIF support. Specifically, the following functions are added: + +

+Note: While every effort has been made to ensure that the _WinNT_ build works, it has not +been tested.

What's new in version 2.0.17?

@@ -659,6 +694,7 @@ preprocessing them, this should not be a big problem. gd 2.0 should read old .gd and .gd2 files correctly. +

What's new in version 1.8.4?

  • Add support for FreeType2 (John Ellson ellson@graphviz.org) @@ -691,6 +727,7 @@ corrected
  • Updated links to fast-moving, always dodging libpng and zlib web sites
+

What's new in version 1.8.1?

  • Optional components no longer built by default (following the @@ -768,6 +805,7 @@ gdImageCreateFromXpm function, if the Xpm library is available. Thanks to Caolan McNamara.
+

What's new in version 1.6.3?

Version 1.6.3 corrects a memory leak in gd_png.c. This leak caused a significant amount of memory to be allocated and not freed when @@ -1334,7 +1372,8 @@
gdPoint (TYPE)
Represents a point in the coordinate space of the image; used -by gdImagePolygon and +by gdImagePolygon, +gdImageOpenPolygon, and gdImageFilledPolygon. 
 typedef struct {
@@ -1344,7 +1383,8 @@
 
gdPointPtr (TYPE)
 

 A pointer to a gdPoint structure; passed
-as an argument to gdImagePolygon
+as an argument to gdImagePolygon,
+gdImageOpenPolygon, 
 and gdImageFilledPolygon.
 
 
gdFTStringExtra (TYPE)
@@ -1457,6 +1497,75 @@
 /* ... Use the image ... */
 gdImageDestroy(im);
+ +
gdImageCreateFromGif(FILE *in) +(FUNCTION) +
gdImageCreateFromGifCtx(gdIOCtx *in) +(FUNCTION) +

+

+gdImageCreateFromGif is called to load images from GIF format files. +Invoke gdImageCreateFromGif with an already opened pointer to a file +containing the desired image. +gdImageCreateFromGif +returns a gdImagePtr to the new image, or NULL +if unable to load the image (most often because the file is corrupt or +does not contain a GIF image). gdImageCreateFromGif does not +close the file. You can inspect the sx and sy members of the +image to determine its size. The image must eventually be destroyed +using gdImageDestroy(). +
+gdImagePtr im;
+... inside a function ...
+FILE *in;
+in = fopen("mygif.gif", "rb");
+im = gdImageCreateFromGif(in);
+fclose(in);
+/* ... Use the image ... */
+gdImageDestroy(im);
+
+
gdImageCreateFromGifSource(gdSourcePtr in) +(FUNCTION) +
+gdImageCreateFromGifSource is called to load a GIF from +a data source other than a file. Usage is very similar to +the gdImageCreateFromGif function, +except that the programmer provides a custom data source. +

+The programmer must write an input function which accepts +a context pointer, a buffer, and a number of bytes to be +read as arguments. This function must read the number of +bytes requested, unless the end of the file has been reached, +in which case the function should return zero, or an error +has occurred, in which case the function should return +-1. The programmer then creates a +gdSource structure and sets +the source pointer to the input function and +the context pointer to any value which is useful to the +programmer. +

+The example below +implements gdImageCreateFromGif +by creating a custom data source and invoking gdImageCreateFromGifSource. +

+static int freadWrapper(void *context, char *buf, int len);
+
+gdImagePtr gdImageCreateFromGif(FILE *in)
+{
+        gdSource s;
+        s.source = freadWrapper;
+        s.context = in;
+        return gdImageCreateFromGifSource(&s);
+}
+
+static int freadWrapper(void *context, char *buf, int len)
+{
+        int got = fread(buf, 1, len, (FILE *) context);
+        return got;
+}
+
+ +
gdImageCreateFromPng(FILE *in) (FUNCTION)
gdImageCreateFromPngCtx(gdIOCtx *in) @@ -1672,6 +1781,92 @@ /* Now destroy it */ gdImageDestroy(im); + +
+void gdImageGif(gdImagePtr im, FILE *out) +(FUNCTION) +
+gdImageGif outputs the specified image to the specified +file in GIF format. The file must be open for writing. Under MSDOS +and all versions of Windows, it is important to use "wb" as opposed +to simply "w" as the mode when opening the file, and under Unix there +is no penalty for doing so. gdImageGif does not +close the file; your code must do so. +
+... inside a function ...
+gdImagePtr im;
+int black, white;
+FILE *out;
+/* Create the image */
+im = gdImageCreate(100, 100);
+/* Allocate background */
+white = gdImageColorAllocate(im, 255, 255, 255);
+/* Allocate drawing color */
+black = gdImageColorAllocate(im, 0, 0, 0);
+/* Draw rectangle */
+gdImageRectangle(im, 0, 0, 99, 99, black);
+/* Open output file in binary mode */
+out = fopen("rect.gif", "wb");
+/* Write GIF */
+gdImageGif(im, out);
+/* Close file */
+fclose(out);
+/* Destroy image */
+gdImageDestroy(im);
+
+ +
+void* gdImageGifCtx(gdImagePtr im, gdIOCtxPtr out) +(FUNCTION) +
Identical to gdImageGif except that it writes the GIF to a +gdIOCtx. +

+

+void* gdImageGifPtr(gdImagePtr im, int *size) +(FUNCTION) +
Identical to gdImageGif except that it returns a pointer to a memory +area with the GIF data. This memory must be freed by the caller when it is +no longer needed. The 'size' parameter received the total size of the block +of memory. +

+ +

gdImageGifToSink(gdImagePtr im, gdSinkPtr out) +(FUNCTION) +
+gdImageGifToSink is called to write a GIF to +a data "sink" (destination) other than a file. Usage is very similar to +the gdImageGif function, +except that the programmer provides a custom data sink. +

+The programmer must write an output function which accepts +a context pointer, a buffer, and a number of bytes to be +written as arguments. This function must write the number of +bytes requested and return that number, unless an error +has occurred, in which case the function should return +-1. The programmer then creates a +gdSink structure and sets +the sink pointer to the output function and +the context pointer to any value which is useful to the +programmer. +

+The example below +implements gdImageGif +by creating a custom data source and invoking gdImageGifFromSink. +

+static int stdioSink(void *context, char *buffer, int len)
+{
+        return fwrite(buffer, 1, len, (FILE *) context);
+}
+
+void gdImageGif(gdImagePtr im, FILE *out)
+{
+        gdSink mySink;
+        mySink.context = (void *) out;
+        mySink.sink = stdioSink;
+        gdImageGifToSink(im, &mySink);
+}
+
+
void gdImageJpeg(gdImagePtr im, FILE *out, int quality) (FUNCTION)
@@ -2133,6 +2328,15 @@ /* Destroy it */ gdImageDestroy(im); + +
void gdImageOpenPolygon(gdImagePtr im, gdPointPtr points, int pointsTotal, int color) +(FUNCTION) +
+gdImageOpenPolygon is used to draw an open polygon (ie. series of line segments). It is almost identical +to gdImagePolygon, except that it does not join the last point to the +first point. +

+

void gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color) (FUNCTION)
@@ -4488,6 +4692,9 @@ gdImageCreateFromGd2Ctx | gdImageCreateFromGd2Part | gdImageCreateFromGd2PartCtx | +gdImageCreateFromGif | +gdImageCreateFromGifCtx | +gdImageCreateFromGifSource | gdImageCreateFromJpeg | gdImageCreateFromJpegCtx | gdImageCreateFromPng | @@ -4507,6 +4714,10 @@ gdImageGetInterlaced | gdImageGetPixel | gdImageGetTransparent | +gdImageGif | +gdImageGifCtx | +gdImageGifPtr | +gdImageGifToSink | gdImageGreen | gdImageInterlace | gdImageJpeg | @@ -4522,6 +4733,7 @@ gdImagePngPtrEx | gdImagePngToSink | gdImagePolygon | +gdImageOpenPolygon | gdImagePtr | gdImageWBMP | gdImageWBMPCtx | diff -Nur gd-2.0.17.orig/Makefile.am gd-2.0.17/Makefile.am --- gd-2.0.17.orig/Makefile.am 2003-12-25 02:50:00.000000000 +0100 +++ gd-2.0.17/Makefile.am 2003-12-26 15:36:42.047006544 +0100 @@ -5,7 +5,7 @@ SUBDIRS = config test -bin_PROGRAMS = annotate gdparttopng gdtopng gd2copypal gd2topng pngtogd pngtogd2 webpng +bin_PROGRAMS = annotate gdparttopng gdtopng gd2copypal gd2topng pngtogd pngtogd2 webpng gd2togif gdcmpgif giftogd2 bin_SCRIPTS = bdftogd @@ -17,7 +17,7 @@ lib_LTLIBRARIES = libgd.la -libgd_la_SOURCES = gd.c gdfx.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c gd_io_file.c gd_io_ss.c gd_jpeg.c gd_png.c gd_ss.c gd_topal.c gd_wbmp.c gdcache.c gdfontg.c gdfontl.c gdfontmb.c gdfonts.c gdfontt.c gdft.c gdhelpers.c gdhelpers.h gdkanji.c gdtables.c gdxpm.c jisx0208.h wbmp.c wbmp.h +libgd_la_SOURCES = gd.c gdfx.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c gd_io_file.c gd_io_ss.c gd_jpeg.c gd_png.c gd_ss.c gd_topal.c gd_wbmp.c gdcache.c gdfontg.c gdfontl.c gdfontmb.c gdfonts.c gdfontt.c gdft.c gdhelpers.c gdhelpers.h gdkanji.c gdtables.c gdxpm.c jisx0208.h wbmp.c wbmp.h gd_gif_in.c gd_gif_out.c gd_biggif_out.c gd_lzw_out.c libgd_la_LDFLAGS = -version-info 2:0:0 Pliki gd-2.0.17.orig/test/fttestref.png i gd-2.0.17/test/fttestref.png różnią się