mirror/freebsd-ports
1
0
Fork 0
mirror of https://git.FreeBSD.org/ports.git synced 2025-01-30 10:38:37 +00:00
Code Issues Releases Activity

- Security patches to match 2.0.33

Browse Source 
- drop X-less Xpm support
  (no longer supported by the distribution)
This commit is contained in:
Dirk Meyer 2004-11-05 22:25:14 +00:00
parent 315b824ea6
commit 394025cc21
Notes: svn2git 2021-03-31 03:12:20 +00:00 
svn path=/head/; revision=120917
9 changed files with 10 additions and 817 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
graphics/gd/Makefile
View File

@ -7,6 +7,7 @@
PORTNAME= gd
PORTVERSION= 2.0.28
PORTREVISION= 1
PORTEPOCH= 1
CATEGORIES+= graphics
MASTER_SITES= http://www.boutell.com/gd/http/ \
@ -14,6 +15,10 @@ MASTER_SITES= http://www.boutell.com/gd/http/ \
MASTER_SITE_SUBDIR= graphics/gd
PKGNAMESUFFIX?= ${NOX11_SUFFIX}${PKGNAMESUFFIX2}
PATCH_SITES+= ${MASTER_SITE_LOCAL}
PATCH_SITE_SUBDIR= dinoex
PATCHFILES+= gd-patch-2.0.28-2.0.33.gz
MAINTAINER?= dinoex@FreeBSD.org
COMMENT?= A graphics library for fast creation of images
@ -25,26 +30,15 @@ MAKE_ENV= WRKSRC="${WRKSRC}" CC="${CC}" CFLAGS="${CFLAGS}" CPPFLAGS="${CPPFLAGS}
MAKEFILE= ${FILESDIR}/Makefile.bsd
INSTALLS_SHLIB= yes
SCRIPTDIR= ${FILESDIR}
CPPFLAGS+= -DHAVE_FT2BUILD_H
.include <bsd.port.pre.mk>
.if defined(WITH_XPM)
.if defined(WITHOUT_X11)
NOX11_SUFFIX?= -nox11
LIB_DEPENDS+= Xpm:${PORTSDIR}/graphics/xpm
CPPFLAGS+= -I${X11BASE}/include/X11 -I${X11BASE}/include -DHAVE_LIBXPM -DXPM_NOX
LDFLAGS+= -L${X11BASE}/lib -lXpm
.else
.if defined(WITH_XPM) && !defined(WITHOUT_X11)
USE_XPM= yes
CPPFLAGS+= -I${X11BASE}/include/X11 -I${X11BASE}/include -DHAVE_LIBXPM
LDFLAGS+= -L${X11BASE}/lib -lXpm -lX11
.endif
.endif
.if defined(WITH_LZW) || defined(HAVE_UNISYS_LICENSE) || \
(defined(USA_RESIDENT) && ${USA_RESIDENT} == "YES")
CPPFLAGS+= -DLZW_LICENSED
.endif
.if defined(GD_FONTS)
USE_PERL5_BUILD= yes
@ -56,10 +50,6 @@ pre-everything::
@${ECHO_MSG} "gd has the following tunables:"
@${ECHO_MSG} ""
@${ECHO_MSG} " WITH_XPM=yes Turns on Xpm support"
@${ECHO_MSG} " WITH_XPM=yes WITHOUT_X11=yes Turns on X-less Xpm support"
.if !defined(USA_RESIDENT) || ${USA_RESIDENT} != "YES"
@${ECHO_MSG} " WITH_LZW=yes Turns on GIF compression support"
.endif
@${ECHO_MSG} ""
post-extract:

2
graphics/gd/distinfo
View File

@ -1,2 +1,4 @@
MD5 (gd-2.0.28.tar.gz) = 14bf0b840b309ae8a29934a7a0743fd3
SIZE (gd-2.0.28.tar.gz) = 568797
MD5 (gd-patch-2.0.28-2.0.33.gz) = faf68dd765a095e875ece667b38ea4a7
SIZE (gd-patch-2.0.28-2.0.33.gz) = 39378

1
graphics/gd/files/Makefile.bsd
View File

@ -7,6 +7,7 @@ SRCS= gd.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c gd_io_file.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 \
gd_security.c \
wbmp.c wbmp.h
SRCS+= gd_gif_in.c gd_gif_out.c gd_biggif_out.c gd_lzw_out.c
MAKEDIR=/usr/share/mk

40
graphics/gd/files/gd2togif.c
View File

@ -1,40 +0,0 @@
#include <stdio.h>
#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;
}

573
graphics/gd/files/gd_gif_in.c
View File

@ -1,573 +0,0 @@
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#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<rv;i++) printf(" %02x",buf[i]);
}
printf("]\n");
}
return(rv);
}
static int
GetCode_(gdIOCtx *fd, int code_size, int flag)
{
static unsigned char buf[280];
static int curbit, lastbit, done, last_byte;
int i, j, ret;
unsigned char count;
if (flag) {
curbit = 0;
lastbit = 0;
done = FALSE;
return 0;
}
if ( (curbit+code_size) >= 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<<MAX_LWZ_BITS); ++i)
table[0][i] = table[1][0] = 0;
sp = stack;
return 0;
} else if (fresh) {
fresh = FALSE;
do {
firstcode = oldcode =
GetCode(fd, code_size, FALSE);
} while (firstcode == clear_code);
return firstcode;
}
if (sp > 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<<MAX_LWZ_BITS); ++i)
table[0][i] = table[1][i] = 0;
code_size = set_code_size+1;
max_code_size = 2*clear_code;
max_code = clear_code+2;
sp = stack;
firstcode = oldcode =
GetCode(fd, code_size, FALSE);
return firstcode;
} else if (code == end_code) {
int count;
unsigned char buf[260];
if (ZeroDataBlock)
return -2;
while ((count = GetDataBlock(fd, buf)) > 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_LWZ_BITS)) {
table[0][code] = oldcode;
table[1][code] = firstcode;
++max_code;
if ((max_code >= max_code_size) &&
(max_code_size < (1<<MAX_LWZ_BITS))) {
max_code_size *= 2;
++code_size;
}
}
oldcode = incode;
if (sp > 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; (i<gdMaxColors); i++) {
im->red[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 */
}
}

44
graphics/gd/files/gd_gif_out.c
View File

@ -1,44 +0,0 @@
#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
}

85
graphics/gd/files/gdcmpgif.c
View File

@ -1,85 +0,0 @@
#include <stdio.h>
#include <unistd.h> /* 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);
}
}

48
graphics/gd/files/giftogd2.c
View File

@ -1,48 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#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;
}

10
graphics/gd/files/patch-gd.h
View File

@ -11,16 +11,6 @@
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * in);
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in);
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data);
@@ -407,6 +411,9 @@
gdPoint, *gdPointPtr;
BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c);
+#ifdef __FreeBSD__
+BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c);
+#endif
BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c);
/* These functions still work with truecolor images,
@@ -517,6 +524,16 @@
/* Best to free this memory with gdFree(), not free() */
BGD_DECLARE(void *) gdImageJpegPtr (gdImagePtr im, int *size, int quality);