aboutsummaryrefslogtreecommitdiffstats
path: root/graphics/libimg
diff options
context:
space:
mode:
authormi <mi@FreeBSD.org>2005-06-10 09:21:05 +0800
committermi <mi@FreeBSD.org>2005-06-10 09:21:05 +0800
commita1cfeda4b4077caf1223abcb8f081972f546c183 (patch)
treee2717a5da049943d4fda598925d3e6b64405a44e /graphics/libimg
parentb113f2e2c1cdba6d1764e8cbdf5aec37fde0ec82 (diff)
downloadfreebsd-ports-gnome-a1cfeda4b4077caf1223abcb8f081972f546c183.tar.gz
freebsd-ports-gnome-a1cfeda4b4077caf1223abcb8f081972f546c183.tar.zst
freebsd-ports-gnome-a1cfeda4b4077caf1223abcb8f081972f546c183.zip
A number of enhancements:
. compile cleanly against 8.4 with -Wall on i386 and amd64; . use OS' run-time linker instead of dlopen-ing libpng, libjpeg, libtiff inside; . stop using TIFF's _internal_ headers for anything. This changes are quite radical, but seem to work with anything I have. Vendor's own tests pass except for some differences in PNG images -- most likely due to changes in PNG library since 2002. Stop requiring specific versions of jpeg, tiff, png -- we don't really care. Bump up PORTREVISION.
Diffstat (limited to 'graphics/libimg')
-rw-r--r--graphics/libimg/Makefile15
-rw-r--r--graphics/libimg/files/Makefile.bsd9
-rw-r--r--graphics/libimg/files/patch-jpeg625
-rw-r--r--graphics/libimg/files/patch-png414
-rw-r--r--graphics/libimg/files/patch-tiff592
-rw-r--r--graphics/libimg/files/patch-tk84_Tk_PhotoPutBlock15
-rw-r--r--graphics/libimg/files/patch-warnings229
7 files changed, 1880 insertions, 19 deletions
diff --git a/graphics/libimg/Makefile b/graphics/libimg/Makefile
index bd17f9b53dcd..94d3a16755dc 100644
--- a/graphics/libimg/Makefile
+++ b/graphics/libimg/Makefile
@@ -7,7 +7,7 @@
PORTNAME= libimg
PORTVERSION= 1.2.4
-PORTREVISION= 1
+PORTREVISION= 2
CATEGORIES= graphics tk84
MASTER_SITES= ${MASTER_SITE_SOURCEFORGE}
MASTER_SITE_SUBDIR= tkimg
@@ -16,17 +16,16 @@ DISTNAME= img${PORTVERSION}
MAINTAINER= ports@FreeBSD.org
COMMENT= A library of image format handlers for Tk4.1 and later
-LIB_DEPENDS= tk84.1:${PORTSDIR}/x11-toolkits/tk84 \
- png.5:${PORTSDIR}/graphics/png \
- jpeg.9:${PORTSDIR}/graphics/jpeg \
- tiff.4:${PORTSDIR}/graphics/tiff
+LIB_DEPENDS= tk84:${PORTSDIR}/x11-toolkits/tk84 \
+ png:${PORTSDIR}/graphics/png \
+ jpeg:${PORTSDIR}/graphics/jpeg \
+ tiff:${PORTSDIR}/graphics/tiff
WRKSRC= ${WRKDIR}/img${PORTVERSION}
-# We don't need the bundled libraries at all, except for a few headers
-# from libtiff, see comment in files/Makefile.bsd:
+# We don't need the bundled libraries:
EXTRACT_AFTER_ARGS= | ${TAR} -xf - --exclude '*/libz/*' \
- --exclude '*/compat/*' --exclude '*/libtiff/*.c' \
+ --exclude '*/compat/*' --exclude '*/libtiff/*' \
--exclude '*/libjpeg/*' --exclude '*/libpng/*'
MAKEFILE= ${FILESDIR}/Makefile.bsd
diff --git a/graphics/libimg/files/Makefile.bsd b/graphics/libimg/files/Makefile.bsd
index ce3264438cab..cfc6bc1f3164 100644
--- a/graphics/libimg/files/Makefile.bsd
+++ b/graphics/libimg/files/Makefile.bsd
@@ -24,17 +24,12 @@ LDADD= -lm -lz -L${LOCALBASE}/lib -lpng -ljpeg -ltiff \
CFLAGS+= -I${LOCALBASE}/include/tcl${TCL_VER}
CFLAGS+= -I${LOCALBASE}/include/tcl${TCL_VER}/generic
-CFLAGS+= -D__X11__ -I${X11BASE}/include
+CFLAGS+= -D__X11__ -I${X11BASE}/include -DALLOW_B64
CFLAGS+= -I${LOCALBASE}/include/tk${TCL_VER}
CFLAGS+= -DNDEBUG -Wall -I. -DUSE_TCL_STUBS -DUSE_TK_STUBS
CFLAGS+= -DVERSION=\"${PORTVERSION}\" -I${LOCALBASE}/include
CFLAGS+= -DHAVE_JPEGLIB_H -DHAVE_TIFF_H -DHAVE_DLFCN_H -DHAVE_IMG_H
-# This seems terrible... The package uses libtiff's interfaces, which are
-# clearly marked as internal... It includes the libtiff's header files, which
-# libtiff itself does NOT install. -mi
-CFLAGS+= -I${.CURDIR}/libtiff
-
all: pkgIndex.tcl
pkgIndex.tcl: pkgIndex.tcl.in
@@ -60,7 +55,7 @@ environ:
# fundamentals of this library
SRCS = imgInit.c imgObj.c imgUtil.c imgPmap.c imgUnixPmap.c \
imgBMP.c imgGIF.c imgJPEG.c imgPNG.c imgPS.c \
- imgTIFF.c imgTIFFjpeg.c imgTIFFpixar.c imgTIFFzip.c \
+ imgTIFF.c \
imgWindow.c imgXBM.c imgXPM.c
test: $(SHLIB_NAME)
diff --git a/graphics/libimg/files/patch-jpeg b/graphics/libimg/files/patch-jpeg
new file mode 100644
index 000000000000..d4cdcfe42f93
--- /dev/null
+++ b/graphics/libimg/files/patch-jpeg
@@ -0,0 +1,625 @@
+--- imgJPEG.c Thu Jun 9 06:36:41 2005
++++ imgJPEG.c Thu Jun 9 20:27:11 2005
+@@ -173,115 +173,4 @@
+ j_common_ptr cinfo));
+ static int load_jpeg_library _ANSI_ARGS_((Tcl_Interp *interp));
+-static int CreateCompress _ANSI_ARGS_((j_compress_ptr, int, size_t));
+-static int CreateDecompress _ANSI_ARGS_((j_decompress_ptr, int, size_t));
+-
+-/*
+- * Stuff to support dynamic loading of libjpeg
+- */
+-
+-static struct JpegFunctions {
+- VOID *handle;
+- int (* abort_decompress) _ANSI_ARGS_((j_decompress_ptr));
+- int (* destroy_compress) _ANSI_ARGS_((j_compress_ptr));
+- int (* destroy_decompress) _ANSI_ARGS_((j_decompress_ptr));
+- int (* finish_compress) _ANSI_ARGS_((j_compress_ptr));
+- int (* finish_decompress) _ANSI_ARGS_((j_decompress_ptr));
+- int (* read_header) _ANSI_ARGS_((j_decompress_ptr, int));
+- JDIMENSION (* read_scanlines) _ANSI_ARGS_((j_decompress_ptr,
+- JSAMPARRAY, JDIMENSION));
+- boolean (* resync_to_restart) _ANSI_ARGS_((j_decompress_ptr, int));
+- int (* set_defaults) _ANSI_ARGS_((j_compress_ptr));
+- int (* start_compress) _ANSI_ARGS_((j_compress_ptr, int));
+- int (* start_decompress) _ANSI_ARGS_((j_decompress_ptr));
+- struct jpeg_error_mgr *(* std_error) _ANSI_ARGS_((struct jpeg_error_mgr *));
+- JDIMENSION (* write_scanlines) _ANSI_ARGS_((j_compress_ptr,
+- JSAMPARRAY, JDIMENSION));
+- int (* set_colorspace) _ANSI_ARGS_((j_compress_ptr, J_COLOR_SPACE));
+- int (* set_quality) _ANSI_ARGS_((j_compress_ptr, int, int));
+- int (* simple_progression) _ANSI_ARGS_((j_compress_ptr));
+- int (* CreateCompress) _ANSI_ARGS_((j_compress_ptr, int, size_t));
+- int (* CreateDecompress) _ANSI_ARGS_((j_decompress_ptr, int, size_t));
+- int (* create_compress) _ANSI_ARGS_((j_compress_ptr));
+- int (* create_decompress) _ANSI_ARGS_((j_decompress_ptr));
+- void (* destroy) _ANSI_ARGS_((j_common_ptr));
+- JDIMENSION (* write_raw_data) _ANSI_ARGS_((j_compress_ptr,
+- JSAMPIMAGE, JDIMENSION));
+- void (* suppress_tables) _ANSI_ARGS_((j_compress_ptr, boolean));
+- void (* write_tables) _ANSI_ARGS_((j_compress_ptr));
+- JDIMENSION (* read_raw_data) _ANSI_ARGS_((j_decompress_ptr,
+- JSAMPIMAGE, JDIMENSION));
+- void (* abort) _ANSI_ARGS_((j_common_ptr));
+-} jpeg = {0};
+-
+-static char *symbols[] = {
+-#ifdef NEED_SHORT_EXTERNAL_NAMES
+- "jAbrtDecompress",
+- "jDestCompress",
+- "jDestDecompress",
+- "jFinCompress",
+- "jFinDecompress",
+- "jReadHeader",
+- "jReadScanlines",
+- "jResyncRestart",
+- "jSetDefaults",
+- "jStrtCompress",
+- "jStrtDecompress",
+- "jStdError",
+- "jWrtScanlines",
+- /* the following 3 symbols are not crucial. They implement
+- resp. the "-grayscale", "-quality" and "-progressive"
+- options. If any of the symbols are missing from the
+- library, the corresponding option just has no effect. */
+- "jSetColorspace",
+- "jSetQuality",
+- "jSimProgress",
+- "jCreaCompress",
+- "jCreaDecompress",
+- "jCreaCompress",
+- "jCreaDecompress",
+- "jDestroy",
+- "jWrtRawData",
+- "jSuppressTables",
+- "jWrtTables",
+- "jReadRawData",
+- "jAbort",
+-#else
+- "jpeg_abort_decompress",
+- "jpeg_destroy_compress",
+- "jpeg_destroy_decompress",
+- "jpeg_finish_compress",
+- "jpeg_finish_decompress",
+- "jpeg_read_header",
+- "jpeg_read_scanlines",
+- "jpeg_resync_to_restart",
+- "jpeg_set_defaults",
+- "jpeg_start_compress",
+- "jpeg_start_decompress",
+- "jpeg_std_error",
+- "jpeg_write_scanlines",
+- /* the following 3 symbols are not crucial. They implement
+- resp. the "-grayscale", "-quality" and "-progressive"
+- options. If any of the symbols are missing from the
+- library, the corresponding option just has no effect. */
+- "jpeg_set_colorspace",
+- "jpeg_set_quality",
+- "jpeg_simple_progression",
+- /* In later versions, jpeg_create_compress and jpeg_create_decompress
+- are macros pointing to jpeg_CreateCompress and jpeg_CreateDecompres.
+- Which one is found depends on the version. */
+- "jpeg_CreateCompress",
+- "jpeg_CreateDecompress",
+- "jpeg_create_compress",
+- "jpeg_create_decompress",
+- "jpeg_destroy",
+- "jpeg_write_raw_data",
+- "jpeg_suppress_tables",
+- "jpeg_write_tables",
+- "jpeg_read_raw_data",
+- "jpeg_abort",
+-#endif
+- (char *) NULL
+-};
+-
+
+ static int
+@@ -292,21 +181,10 @@
+ struct my_error_mgr jerror; /* for controlling libjpeg error handling */
+ int i;
++ static int initialized;
+
+- if (ImgLoadLib(interp, JPEG_LIB_NAME, &jpeg.handle, symbols, 13)
+- != TCL_OK) {
+- return TCL_ERROR;
+- }
+- if (jpeg.CreateCompress == NULL) {
+- if (jpeg.create_compress == NULL) {
+- goto load_failed;
+- }
+- jpeg.CreateCompress = CreateCompress;
+- }
+- if (jpeg.CreateDecompress == NULL) {
+- if (jpeg.create_decompress == NULL) {
+- goto load_failed;
+- }
+- jpeg.CreateDecompress = CreateDecompress;
+- }
++ if (initialized)
++ return TCL_OK;
++
++ initialized = 1;
+
+ /* The followin code tries to determine if the JPEG library is
+@@ -322,5 +200,5 @@
+ cinfo = (struct jpeg_compress_struct *)
+ ckalloc(8*sizeof(struct jpeg_compress_struct));
+- cinfo->err = jpeg.std_error(&jerror.pub);
++ cinfo->err = jpeg_std_error(&jerror.pub);
+ jerror.pub.error_exit = my_error_exit;
+ jerror.pub.output_message = my_output_message;
+@@ -328,18 +206,16 @@
+ if (setjmp(jerror.setjmp_buffer)) {
+ /* If we get here, the JPEG library is invalid. */
+- jpeg.destroy_compress(cinfo);
++ jpeg_destroy_compress(cinfo);
+ ckfree((char *)cinfo);
+-load_failed:
+ if (interp) {
+- Tcl_AppendResult(interp, "couldn't load \"", JPEG_LIB_NAME,
+- "\": please upgrade to at least version 6a", (char *) NULL);
++ Tcl_AppendResult(interp, "JPEG library mismatch, expecting \"",
++ JPEG_LIB_NAME, NULL);
+ }
+- ImgLoadFailed(&jpeg.handle);
+ return TCL_ERROR;
+ }
+
+- /* Now we can initialize libjpeg. */
++ /* Now we can initialize libjpeg_ */
+ ((char *) cinfo)[sizeof(struct jpeg_compress_struct)] = 53;
+- jpeg.CreateCompress(cinfo, JPEG_LIB_VERSION,
++ jpeg_CreateCompress(cinfo, JPEG_LIB_VERSION,
+ (size_t) sizeof(struct jpeg_compress_struct));
+ if (((char *) cinfo)[sizeof(struct jpeg_compress_struct)] != 53) {
+@@ -359,5 +235,5 @@
+ cinfo->X_density = 0;
+ cinfo->Y_density = 0;
+- jpeg.set_defaults(cinfo);
++ jpeg_set_defaults(cinfo);
+
+ if ((cinfo->data_precision != BITS_IN_JSAMPLE) ||
+@@ -375,5 +251,5 @@
+ }
+ }
+- jpeg.destroy_compress(cinfo);
++ jpeg_destroy_compress(cinfo);
+ ckfree((char *) cinfo);
+ return TCL_OK;
+@@ -383,13 +259,6 @@
+ ImgLoadJpegLibrary()
+ {
+- if ((load_jpeg_library(NULL) == TCL_OK)
+- && jpeg.destroy
+- && jpeg.write_raw_data
+- && jpeg.suppress_tables
+- && jpeg.write_tables
+- && jpeg.read_raw_data
+- && jpeg.abort) {
++ if (load_jpeg_library(NULL) == TCL_OK)
+ return TCL_OK;
+- }
+ return TCL_ERROR;
+ }
+@@ -420,179 +289,4 @@
+ JSAMPARRAY, JDIMENSION));
+
+-static int
+-CreateCompress(cinfo, version, size)
+- j_compress_ptr cinfo;
+- int version;
+- size_t size;
+-{
+- return jpeg.create_compress(cinfo);
+-}
+-
+-static int
+-CreateDecompress(cinfo, version, size)
+- j_decompress_ptr cinfo;
+- int version;
+- size_t size;
+-{
+- return jpeg.create_decompress(cinfo);
+-}
+-
+-int
+-Imgjpeg_CreateCompress(cinfo, version, size)
+- j_compress_ptr cinfo;
+- int version;
+- size_t size;
+-{
+- return jpeg.CreateCompress(cinfo, version, size);
+-}
+-
+-int
+-Imgjpeg_CreateDecompress(cinfo, version, size)
+- j_decompress_ptr cinfo;
+- int version;
+- size_t size;
+-{
+- return jpeg.CreateDecompress(cinfo, version, size);
+-}
+-
+-boolean
+-Imgjpeg_resync_to_restart(a,b)
+- j_decompress_ptr a;
+- int b;
+-{
+- return jpeg.resync_to_restart(a,b);
+-}
+-
+-JDIMENSION
+-Imgjpeg_read_scanlines(a,b,c)
+- j_decompress_ptr a;
+- JSAMPARRAY b;
+- JDIMENSION c;
+-{
+- return jpeg.read_scanlines(a,b,c);
+-}
+-
+-int
+-Imgjpeg_set_colorspace(a,b)
+- j_compress_ptr a;
+- J_COLOR_SPACE b;
+-{
+- return jpeg.set_colorspace(a,b);
+-}
+-
+-int
+-Imgjpeg_set_defaults(a)
+- j_compress_ptr a;
+-{
+- return jpeg.set_defaults(a);
+-}
+-
+-int
+-Imgjpeg_start_decompress(a)
+- j_decompress_ptr a;
+-{
+- return jpeg.start_decompress(a);
+-}
+-
+-void
+-Imgjpeg_destroy(a)
+- j_common_ptr a;
+-{
+- jpeg.destroy(a);
+-}
+-
+-struct jpeg_error_mgr *
+-Imgjpeg_std_error(a)
+- struct jpeg_error_mgr *a;
+-{
+- return jpeg.std_error(a);
+-}
+-
+-JDIMENSION Imgjpeg_write_raw_data(a,b,c)
+- j_compress_ptr a;
+- JSAMPIMAGE b;
+- JDIMENSION c;
+-{
+- return jpeg.write_raw_data(a,b,c);
+-}
+-
+-void
+-Imgjpeg_suppress_tables(a,b)
+- j_compress_ptr a;
+- boolean b;
+-{
+- jpeg.suppress_tables(a,b);
+-}
+-
+-void
+-Imgjpeg_abort(a)
+- j_common_ptr a;
+-{
+- jpeg.abort(a);
+-}
+-
+-int
+-Imgjpeg_read_header(a,b)
+- j_decompress_ptr a;
+- int b;
+-{
+- return jpeg.read_header(a,b);
+-}
+-
+-int
+-Imgjpeg_start_compress(a,b)
+- j_compress_ptr a;
+- int b;
+-{
+- return jpeg.start_compress(a,b);
+-}
+-
+-void
+-Imgjpeg_write_tables(a)
+- j_compress_ptr a;
+-{
+- jpeg.write_tables(a);
+-}
+-
+-int
+-Imgjpeg_finish_decompress(a)
+- j_decompress_ptr a;
+-{
+- return jpeg.finish_decompress(a);
+-}
+-
+-int
+-Imgjpeg_finish_compress(a)
+- j_compress_ptr a;
+-{
+- return jpeg.finish_compress(a);
+-}
+-
+-JDIMENSION
+-Imgjpeg_read_raw_data(a,b,c)
+- j_decompress_ptr a;
+- JSAMPIMAGE b;
+- JDIMENSION c;
+-{
+- return jpeg.read_raw_data(a,b,c);
+-}
+-
+-int
+-Imgjpeg_set_quality(a,b,c)
+- j_compress_ptr a;
+- int b;
+- int c;
+-{
+- return jpeg.set_quality(a,b,c);
+-}
+-
+-JDIMENSION
+-Imgjpeg_write_scanlines(a,b,c)
+- j_compress_ptr a;
+- JSAMPARRAY b;
+- JDIMENSION c;
+-{
+- return jpeg.write_scanlines(a,b,c);
+-}
+
+
+@@ -715,5 +409,5 @@
+ }
+ /* look for SOF0, SOF1, or SOF2, which are the only JPEG variants
+- * currently accepted by libjpeg.
++ * currently accepted by libjpeg_
+ */
+ if (buf[0] == (char) 0xc0 || buf[0] == (char) 0xc1
+@@ -794,5 +488,5 @@
+ /* Initialize JPEG error handler */
+ /* We set up the normal JPEG error routines, then override error_exit. */
+- cinfo.err = jpeg.std_error(&jerror.pub);
++ cinfo.err = jpeg_std_error(&jerror.pub);
+ jerror.pub.error_exit = my_error_exit;
+ jerror.pub.output_message = my_output_message;
+@@ -803,10 +497,10 @@
+ Tcl_AppendResult(interp, "couldn't read JPEG string: ", (char *) NULL);
+ append_jpeg_message(interp, (j_common_ptr) &cinfo);
+- jpeg.destroy_decompress(&cinfo);
++ jpeg_destroy_decompress(&cinfo);
+ return TCL_ERROR;
+ }
+
+- /* Now we can initialize libjpeg. */
+- jpeg.CreateDecompress(&cinfo, JPEG_LIB_VERSION,
++ /* Now we can initialize libjpeg_ */
++ jpeg_CreateDecompress(&cinfo, JPEG_LIB_VERSION,
+ (size_t) sizeof(struct jpeg_decompress_struct));
+ jpeg_channel_src(&cinfo, chan);
+@@ -817,5 +511,5 @@
+
+ /* Reclaim libjpeg's internal resources. */
+- jpeg.destroy_decompress(&cinfo);
++ jpeg_destroy_decompress(&cinfo);
+
+ return result;
+@@ -865,5 +559,5 @@
+ /* Initialize JPEG error handler */
+ /* We set up the normal JPEG error routines, then override error_exit. */
+- cinfo.err = jpeg.std_error(&jerror.pub);
++ cinfo.err = jpeg_std_error(&jerror.pub);
+ jerror.pub.error_exit = my_error_exit;
+ jerror.pub.output_message = my_output_message;
+@@ -874,10 +568,10 @@
+ Tcl_AppendResult(interp, "couldn't read JPEG string: ", (char *) NULL);
+ append_jpeg_message(interp, (j_common_ptr) &cinfo);
+- jpeg.destroy_decompress(&cinfo);
++ jpeg_destroy_decompress(&cinfo);
+ return TCL_ERROR;
+ }
+
+- /* Now we can initialize libjpeg. */
+- jpeg.CreateDecompress(&cinfo, JPEG_LIB_VERSION,
++ /* Now we can initialize libjpeg_ */
++ jpeg_CreateDecompress(&cinfo, JPEG_LIB_VERSION,
+ (size_t) sizeof(struct jpeg_decompress_struct));
+ jpeg_obj_src(&cinfo, data);
+@@ -888,5 +582,5 @@
+
+ /* Reclaim libjpeg's internal resources. */
+- jpeg.destroy_decompress(&cinfo);
++ jpeg_destroy_decompress(&cinfo);
+
+ return result;
+@@ -926,5 +620,5 @@
+ * in image being read. */
+ {
+- static char *jpegReadOptions[] = {"-fast", "-grayscale", NULL};
++ static const char *jpegReadOptions[] = {"-fast", "-grayscale", NULL};
+ int fileWidth, fileHeight, stopY, curY, outY, outWidth, outHeight;
+ myblock bl;
+@@ -935,5 +629,5 @@
+
+ /* Ready to read header data. */
+- jpeg.read_header(cinfo, TRUE);
++ jpeg_read_header(cinfo, TRUE);
+
+ /* This code only supports 8-bit-precision JPEG files. */
+@@ -972,5 +666,5 @@
+ }
+
+- jpeg.start_decompress(cinfo);
++ jpeg_start_decompress(cinfo);
+
+ /* Check dimensions. */
+@@ -1002,5 +696,5 @@
+ break;
+ case JCS_RGB:
+- /* note: this pixel layout assumes default configuration of libjpeg. */
++ /* note: this pixel layout assumes default configuration of libjpeg_ */
+ block.pixelSize = 3;
+ block.offset[0] = 0;
+@@ -1029,5 +723,5 @@
+ outY = destY;
+ for (curY = 0; curY < stopY; curY++) {
+- jpeg.read_scanlines(cinfo, buffer, 1);
++ jpeg_read_scanlines(cinfo, buffer, 1);
+ if (curY >= srcY) {
+ Tk_PhotoPutBlock(imageHandle, &block, destX, outY, outWidth, 1, TK_PHOTO_COMPOSITE_SET);
+@@ -1038,7 +732,7 @@
+ /* Do normal cleanup if we read the whole image; else early abort */
+ if (cinfo->output_scanline == cinfo->output_height)
+- jpeg.finish_decompress(cinfo);
++ jpeg_finish_decompress(cinfo);
+ else
+- jpeg.abort_decompress(cinfo);
++ jpeg_abort_decompress(cinfo);
+
+ return TCL_OK;
+@@ -1086,5 +780,5 @@
+ /* Initialize JPEG error handler */
+ /* We set up the normal JPEG error routines, then override error_exit. */
+- cinfo.err = jpeg.std_error(&jerror.pub);
++ cinfo.err = jpeg_std_error(&jerror.pub);
+ jerror.pub.error_exit = my_error_exit;
+ jerror.pub.output_message = my_output_message;
+@@ -1096,11 +790,11 @@
+ "\": ", (char *) NULL);
+ append_jpeg_message(interp, (j_common_ptr) &cinfo);
+- jpeg.destroy_compress(&cinfo);
++ jpeg_destroy_compress(&cinfo);
+ Tcl_Close(interp, chan);
+ return TCL_ERROR;
+ }
+
+- /* Now we can initialize libjpeg. */
+- jpeg.CreateCompress(&cinfo, JPEG_LIB_VERSION,
++ /* Now we can initialize libjpeg_ */
++ jpeg_CreateCompress(&cinfo, JPEG_LIB_VERSION,
+ (size_t) sizeof(struct jpeg_compress_struct));
+ jpeg_channel_dest(&cinfo, chan);
+@@ -1109,5 +803,5 @@
+ result = CommonWriteJPEG(interp, &cinfo, format, blockPtr);
+
+- jpeg.destroy_compress(&cinfo);
++ jpeg_destroy_compress(&cinfo);
+ if (Tcl_Close(interp, chan) == TCL_ERROR) {
+ return TCL_ERROR;
+@@ -1154,5 +848,5 @@
+ /* Initialize JPEG error handler */
+ /* We set up the normal JPEG error routines, then override error_exit. */
+- cinfo.err = jpeg.std_error(&jerror.pub);
++ cinfo.err = jpeg_std_error(&jerror.pub);
+ jerror.pub.error_exit = my_error_exit;
+ jerror.pub.output_message = my_output_message;
+@@ -1167,6 +861,6 @@
+ }
+
+- /* Now we can initialize libjpeg. */
+- jpeg.CreateCompress(&cinfo, JPEG_LIB_VERSION,
++ /* Now we can initialize libjpeg_ */
++ jpeg_CreateCompress(&cinfo, JPEG_LIB_VERSION,
+ (size_t) sizeof(struct jpeg_compress_struct));
+ jpeg_string_dest(&cinfo, dataPtr);
+@@ -1177,5 +871,5 @@
+ writeend:
+
+- jpeg.destroy_compress(&cinfo);
++ jpeg_destroy_compress(&cinfo);
+ if (dataPtr == &data) {
+ if (result == TCL_OK) {
+@@ -1210,5 +904,5 @@
+ Tk_PhotoImageBlock *blockPtr;
+ {
+- static char *jpegWriteOptions[] = {"-grayscale", "-optimize",
++ static const char *jpegWriteOptions[] = {"-grayscale", "-optimize",
+ "-progressive", "-quality", "-smooth", NULL};
+ JSAMPROW row_pointer[1]; /* pointer to original data scanlines */
+@@ -1239,5 +933,5 @@
+ cinfo->in_color_space = JCS_RGB;
+
+- jpeg.set_defaults(cinfo);
++ jpeg_set_defaults(cinfo);
+
+ /* Parse options, if any, and alter default parameters */
+@@ -1262,7 +956,7 @@
+ }
+ case 2: {
+- if (jpeg.simple_progression != NULL) {
++ if (jpeg_simple_progression != NULL) {
+ /* Select simple progressive mode. */
+- jpeg.simple_progression(cinfo);
++ jpeg_simple_progression(cinfo);
+ }
+ break;
+@@ -1278,5 +972,5 @@
+ return TCL_ERROR;
+ }
+- jpeg.set_quality(cinfo, quality, FALSE);
++ jpeg_set_quality(cinfo, quality, FALSE);
+ break;
+ }
+@@ -1301,11 +995,11 @@
+ greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
+ blueOffset = blockPtr->offset[2] - blockPtr->offset[0];
+- if ((jpeg.set_colorspace != NULL) &&
++ if ((jpeg_set_colorspace != NULL) &&
+ (grayscale || (!greenOffset && !blueOffset))) {
+ /* Generate monochrome JPEG file if source block is grayscale. */
+- jpeg.set_colorspace(cinfo, JCS_GRAYSCALE);
++ jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+ }
+
+- jpeg.start_compress(cinfo, TRUE);
++ jpeg_start_compress(cinfo, TRUE);
+
+ /* note: we assume libjpeg is configured for standard RGB pixel order. */
+@@ -1315,5 +1009,5 @@
+ for (h = blockPtr->height; h > 0; h--) {
+ row_pointer[0] = (JSAMPROW) pixLinePtr;
+- jpeg.write_scanlines(cinfo, row_pointer, 1);
++ jpeg_write_scanlines(cinfo, row_pointer, 1);
+ pixLinePtr += blockPtr->pitch;
+ }
+@@ -1341,10 +1035,10 @@
+ pixelPtr += blockPtr->pixelSize;
+ }
+- jpeg.write_scanlines(cinfo, buffer, 1);
++ jpeg_write_scanlines(cinfo, buffer, 1);
+ pixLinePtr += blockPtr->pitch;
+ }
+ }
+
+- jpeg.finish_compress(cinfo);
++ jpeg_finish_compress(cinfo);
+ return TCL_OK;
+ }
+@@ -1370,5 +1064,5 @@
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+- src->pub.resync_to_restart = jpeg.resync_to_restart; /* use default method */
++ src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+ src->pub.term_source = dummy_source;
+
+@@ -1443,5 +1137,5 @@
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+- src->pub.resync_to_restart = jpeg.resync_to_restart; /* use default method */
++ src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+ src->pub.term_source = dummy_source;
+
diff --git a/graphics/libimg/files/patch-png b/graphics/libimg/files/patch-png
new file mode 100644
index 000000000000..05041d90273b
--- /dev/null
+++ b/graphics/libimg/files/patch-png
@@ -0,0 +1,414 @@
+--- imgPNG.c Tue Jan 15 16:00:08 2002
++++ imgPNG.c Thu Jun 9 20:11:01 2005
+@@ -104,5 +104,4 @@
+ static void tk_png_error _ANSI_ARGS_((png_structp, png_const_charp));
+ static void tk_png_warning _ANSI_ARGS_((png_structp, png_const_charp));
+-static int load_png_library _ANSI_ARGS_((Tcl_Interp *interp));
+
+ /*
+@@ -116,87 +115,4 @@
+ static void tk_png_flush _ANSI_ARGS_((png_structp));
+
+-static struct PngFunctions {
+- VOID *handle;
+- png_structp (* create_read_struct) _ANSI_ARGS_((png_const_charp,
+- png_voidp, png_error_ptr, png_error_ptr));
+- png_infop (* create_info_struct) _ANSI_ARGS_((png_structp));
+- png_structp (* create_write_struct) _ANSI_ARGS_((png_const_charp,
+- png_voidp, png_error_ptr, png_error_ptr));
+- void (* destroy_read_struct) _ANSI_ARGS_((png_structpp,
+- png_infopp, png_infopp));
+- void (* destroy_write_struct) _ANSI_ARGS_((png_structpp, png_infopp));
+- void (* error) _ANSI_ARGS_((png_structp, png_charp));
+- png_byte (* get_channels) _ANSI_ARGS_((png_structp, png_infop));
+- png_voidp (* get_error_ptr) _ANSI_ARGS_((png_structp));
+- png_voidp (* get_progressive_ptr) _ANSI_ARGS_((png_structp));
+- png_uint_32 (* get_rowbytes) _ANSI_ARGS_((png_structp, png_infop));
+- png_uint_32 (* get_IHDR) _ANSI_ARGS_((png_structp, png_infop,
+- png_uint_32*, png_uint_32*, int*, int*, int*, int*, int*));
+- png_uint_32 (* get_valid) _ANSI_ARGS_((png_structp, png_infop, png_uint_32));
+- void (* read_image) _ANSI_ARGS_((png_structp, png_bytepp));
+- void (* read_info) _ANSI_ARGS_((png_structp, png_infop));
+- void (* read_update_info) _ANSI_ARGS_((png_structp, png_infop));
+- int (* set_interlace_handling) _ANSI_ARGS_ ((png_structp));
+- void (* set_read_fn) _ANSI_ARGS_((png_structp, png_voidp, png_rw_ptr));
+- void (* set_text) _ANSI_ARGS_((png_structp, png_infop, png_textp, int));
+- void (* set_write_fn) _ANSI_ARGS_((png_structp, png_voidp,
+- png_rw_ptr, png_voidp));
+- void (* set_IHDR) _ANSI_ARGS_((png_structp, png_infop, png_uint_32,
+- png_uint_32, int, int, int, int, int));
+- void (* write_end) _ANSI_ARGS_((png_structp, png_infop));
+- void (* write_info) _ANSI_ARGS_((png_structp, png_infop));
+- void (* write_row) _ANSI_ARGS_((png_structp, png_bytep));
+- void (* set_expand) _ANSI_ARGS_((png_structp));
+- void (* set_filler) _ANSI_ARGS_((png_structp, png_uint_32, int));
+- void (* set_strip_16) _ANSI_ARGS_((png_structp));
+- png_uint_32 (* get_sRGB) _ANSI_ARGS_((png_structp, png_infop, int *));
+- void (* set_sRGB) _ANSI_ARGS_((png_structp, png_infop, int));
+- png_uint_32 (* get_gAMA) _ANSI_ARGS_((png_structp, png_infop, double *));
+- void (* set_gAMA) PNGARG((png_structp png_ptr, png_infop, double));
+- void (* set_gamma) _ANSI_ARGS_((png_structp, double, double));
+- void (* set_sRGB_gAMA_and_cHRM) _ANSI_ARGS_((png_structp, png_infop, int));
+- void (* write_iTXt) _ANSI_ARGS_((png_structp, int, png_charp, png_charp,
+- png_charp, png_charp));
+-} png = {0};
+-
+-static char *symbols[] = {
+- "png_create_read_struct",
+- "png_create_info_struct",
+- "png_create_write_struct",
+- "png_destroy_read_struct",
+- "png_destroy_write_struct",
+- "png_error",
+- "png_get_channels",
+- "png_get_error_ptr",
+- "png_get_progressive_ptr",
+- "png_get_rowbytes",
+- "png_get_IHDR",
+- "png_get_valid",
+- "png_read_image",
+- "png_read_info",
+- "png_read_update_info",
+- "png_set_interlace_handling",
+- "png_set_read_fn",
+- "png_set_text",
+- "png_set_write_fn",
+- "png_set_IHDR",
+- "png_write_end",
+- "png_write_info",
+- "png_write_row",
+- /* The following symbols are not crucial. All of them
+- are checked at runtime. */
+- "png_set_expand",
+- "png_set_filler",
+- "png_set_strip_16",
+- "png_get_sRGB",
+- "png_set_sRGB",
+- "png_get_gAMA",
+- "png_set_gAMA",
+- "png_set_gamma",
+- "png_set_sRGB_gAMA_and_cHRM",
+- "png_write_iTXt", /* Only used to check if libpng has iTXt support at runtime */
+- (char *) NULL
+-};
+-
+ typedef struct cleanup_info {
+ Tcl_Interp *interp;
+@@ -209,5 +125,5 @@
+ png_const_charp error_msg;
+ {
+- cleanup_info *info = (cleanup_info *) png.get_error_ptr(png_ptr);
++ cleanup_info *info = (cleanup_info *) png_get_error_ptr(png_ptr);
+ Tcl_AppendResult(info->interp, error_msg, (char *) NULL);
+ longjmp(info->jmpbuf,1);
+@@ -228,7 +144,7 @@
+ png_size_t length;
+ {
+- if (ImgRead((MFile *) png.get_progressive_ptr(png_ptr),
++ if (ImgRead((MFile *) png_get_progressive_ptr(png_ptr),
+ (char *) data, (size_t) length) != (int) length) {
+- png.error(png_ptr, "Read Error");
++ png_error(png_ptr, "Read Error");
+ }
+ }
+@@ -240,7 +156,7 @@
+ png_size_t length;
+ {
+- if (ImgWrite((MFile *) png.get_progressive_ptr(png_ptr),
++ if (ImgWrite((MFile *) png_get_progressive_ptr(png_ptr),
+ (char *) data, (size_t) length) != (int) length) {
+- png.error(png_ptr, "Write Error");
++ png_error(png_ptr, "Write Error");
+ }
+ }
+@@ -303,15 +219,4 @@
+ }
+
+-static int
+-load_png_library(interp)
+- Tcl_Interp *interp;
+-{
+- if (ImgLoadLib(interp, PNG_LIB_NAME, &png.handle, symbols, 22)
+- != TCL_OK) {
+- return TCL_ERROR;
+- }
+- return TCL_OK;
+-}
+-
+ static int ChnReadPNG(interp, chan, fileName, format, imageHandle,
+ destX, destY, width, height, srcX, srcY)
+@@ -329,8 +234,4 @@
+ cleanup_info cleanup;
+
+- if (load_png_library(interp) != TCL_OK) {
+- return TCL_ERROR;
+- }
+-
+ handle.data = (char *) chan;
+ handle.state = IMG_CHAN;
+@@ -338,9 +239,9 @@
+ cleanup.interp = interp;
+
+- png_ptr=png.create_read_struct(PNG_LIBPNG_VER_STRING,
++ png_ptr=png_create_read_struct(PNG_LIBPNG_VER_STRING,
+ (png_voidp) &cleanup,tk_png_error,tk_png_warning);
+ if (!png_ptr) return(0);
+
+- png.set_read_fn(png_ptr, (png_voidp) &handle, tk_png_read);
++ png_set_read_fn(png_ptr, (png_voidp) &handle, tk_png_read);
+
+ return CommonReadPNG(png_ptr, format, imageHandle, destX, destY,
+@@ -362,11 +263,7 @@
+ cleanup_info cleanup;
+
+- if (load_png_library(interp) != TCL_OK) {
+- return TCL_ERROR;
+- }
+-
+ cleanup.interp = interp;
+
+- png_ptr=png.create_read_struct(PNG_LIBPNG_VER_STRING,
++ png_ptr=png_create_read_struct(PNG_LIBPNG_VER_STRING,
+ (png_voidp) &cleanup,tk_png_error,tk_png_warning);
+ if (!png_ptr) return TCL_ERROR;
+@@ -374,5 +271,5 @@
+ ImgReadInit(dataObj,'\211',&handle);
+
+- png.set_read_fn(png_ptr,(png_voidp) &handle, tk_png_read);
++ png_set_read_fn(png_ptr,(png_voidp) &handle, tk_png_read);
+
+ return CommonReadPNG(png_ptr, format, imageHandle, destX, destY,
+@@ -406,27 +303,27 @@
+ int intent;
+
+- info_ptr=png.create_info_struct(png_ptr);
++ info_ptr=png_create_info_struct(png_ptr);
+ if (!info_ptr) {
+- png.destroy_read_struct(&png_ptr,NULL,NULL);
++ png_destroy_read_struct(&png_ptr,NULL,NULL);
+ return(TCL_ERROR);
+ }
+
+- end_info=png.create_info_struct(png_ptr);
++ end_info=png_create_info_struct(png_ptr);
+ if (!end_info) {
+- png.destroy_read_struct(&png_ptr,&info_ptr,NULL);
++ png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
+ return(TCL_ERROR);
+ }
+
+- if (setjmp((((cleanup_info *) png.get_error_ptr(png_ptr))->jmpbuf))) {
++ if (setjmp((((cleanup_info *) png_get_error_ptr(png_ptr))->jmpbuf))) {
+ if (png_data) {
+ ckfree((char *)png_data);
+ }
+- png.destroy_read_struct(&png_ptr, &info_ptr, &end_info);
++ png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+ return TCL_ERROR;
+ }
+
+- png.read_info(png_ptr,info_ptr);
++ png_read_info(png_ptr,info_ptr);
+
+- png.get_IHDR(png_ptr, info_ptr, &info_width, &info_height, &bit_depth,
++ png_get_IHDR(png_ptr, info_ptr, &info_width, &info_height, &bit_depth,
+ &color_type, &interlace_type, (int *) NULL, (int *) NULL);
+
+@@ -447,6 +344,6 @@
+ Tk_PhotoGetImage(imageHandle, &block);
+
+- if (png.set_strip_16 != NULL) {
+- png.set_strip_16(png_ptr);
++ if (png_set_strip_16 != NULL) {
++ png_set_strip_16(png_ptr);
+ } else if (bit_depth == 16) {
+ block.offset[1] = 2;
+@@ -454,11 +351,11 @@
+ }
+
+- if (png.set_expand != NULL) {
+- png.set_expand(png_ptr);
++ if (png_set_expand != NULL) {
++ png_set_expand(png_ptr);
+ }
+
+- png.read_update_info(png_ptr,info_ptr);
+- block.pixelSize = png.get_channels(png_ptr, info_ptr);
+- block.pitch = png.get_rowbytes(png_ptr, info_ptr);
++ png_read_update_info(png_ptr,info_ptr);
++ block.pixelSize = png_get_channels(png_ptr, info_ptr);
++ block.pitch = png_get_rowbytes(png_ptr, info_ptr);
+
+ if ((color_type & PNG_COLOR_MASK_COLOR) == 0) {
+@@ -471,5 +368,5 @@
+
+ if ((color_type & PNG_COLOR_MASK_ALPHA)
+- || png.get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
++ || png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+ /* with alpha channel */
+ block.offset[3] = block.pixelSize - 1;
+@@ -479,12 +376,13 @@
+ }
+
+- if (png.get_sRGB && png.get_sRGB(png_ptr, info_ptr, &intent)) {
+- png.set_sRGB(png_ptr, info_ptr, intent);
+- } else if (png.get_gAMA) {
++ if (png_get_sRGB(png_ptr, info_ptr, &intent)) {
++ /* XXX does this get/set make sense? */
++ png_set_sRGB(png_ptr, info_ptr, intent);
++ } else {
+ double gamma;
+- if (!png.get_gAMA(png_ptr, info_ptr, &gamma)) {
++ if (!png_get_gAMA(png_ptr, info_ptr, &gamma)) {
+ gamma = 0.45455;
+ }
+- png.set_gamma(png_ptr, 1.0, gamma);
++ png_set_gamma(png_ptr, 1.0, gamma);
+ }
+
+@@ -498,10 +396,10 @@
+ block.pixelPtr=(unsigned char *) (png_data[srcY]+srcX*block.pixelSize);
+
+- png.read_image(png_ptr,(png_bytepp) png_data);
++ png_read_image(png_ptr,(png_bytepp) png_data);
+
+ ImgPhotoPutBlock(imageHandle,&block,destX,destY,width,height);
+
+ ckfree((char *) png_data);
+- png.destroy_read_struct(&png_ptr,&info_ptr,&end_info);
++ png_destroy_read_struct(&png_ptr,&info_ptr,&end_info);
+
+ return(TCL_OK);
+@@ -529,12 +427,7 @@
+ handle.state = IMG_CHAN;
+
+- if (load_png_library(interp) != TCL_OK) {
+- Tcl_Close(NULL, chan);
+- return TCL_ERROR;
+- }
+-
+ cleanup.interp = interp;
+
+- png_ptr=png.create_write_struct(PNG_LIBPNG_VER_STRING,
++ png_ptr=png_create_write_struct(PNG_LIBPNG_VER_STRING,
+ (png_voidp) &cleanup,tk_png_error,tk_png_warning);
+ if (!png_ptr) {
+@@ -543,12 +436,12 @@
+ }
+
+- info_ptr=png.create_info_struct(png_ptr);
++ info_ptr=png_create_info_struct(png_ptr);
+ if (!info_ptr) {
+- png.destroy_write_struct(&png_ptr,NULL);
++ png_destroy_write_struct(&png_ptr,NULL);
+ Tcl_Close(NULL, chan);
+ return TCL_ERROR;
+ }
+
+- png.set_write_fn(png_ptr,(png_voidp) &handle, tk_png_write, tk_png_flush);
++ png_set_write_fn(png_ptr,(png_voidp) &handle, tk_png_write, tk_png_flush);
+
+ result = CommonWritePNG(interp, png_ptr, info_ptr, format, blockPtr);
+@@ -572,11 +465,7 @@
+ ImgFixStringWriteProc(&data, &interp, &dataPtr, &format, &blockPtr);
+
+- if (load_png_library(interp) != TCL_OK) {
+- return TCL_ERROR;
+- }
+-
+ cleanup.interp = interp;
+
+- png_ptr=png.create_write_struct(PNG_LIBPNG_VER_STRING,
++ png_ptr=png_create_write_struct(PNG_LIBPNG_VER_STRING,
+ (png_voidp) &cleanup, tk_png_error, tk_png_warning);
+ if (!png_ptr) {
+@@ -584,11 +473,11 @@
+ }
+
+- info_ptr = png.create_info_struct(png_ptr);
++ info_ptr = png_create_info_struct(png_ptr);
+ if (!info_ptr) {
+- png.destroy_write_struct(&png_ptr,NULL);
++ png_destroy_write_struct(&png_ptr,NULL);
+ return TCL_ERROR;
+ }
+
+- png.set_write_fn(png_ptr, (png_voidp) &handle, tk_png_write, tk_png_flush);
++ png_set_write_fn(png_ptr, (png_voidp) &handle, tk_png_write, tk_png_flush);
+
+ ImgWriteInit(dataPtr, &handle);
+@@ -621,9 +510,9 @@
+ tagcount = (tagcount > 1) ? (tagcount/2 - 1) : 0;
+
+- if (setjmp((((cleanup_info *) png.get_error_ptr(png_ptr))->jmpbuf))) {
++ if (setjmp((((cleanup_info *) png_get_error_ptr(png_ptr))->jmpbuf))) {
+ if (row_pointers) {
+ ckfree((char *) row_pointers);
+ }
+- png.destroy_write_struct(&png_ptr,&info_ptr);
++ png_destroy_write_struct(&png_ptr,&info_ptr);
+ return TCL_ERROR;
+ }
+@@ -652,5 +541,5 @@
+ #if 0 /* The function png_set_filler doesn't seem to work; don't known why :-( */
+ } else if ((blockPtr->pixelSize==4) && (newPixelSize == 3)
+- && (png.set_filler != NULL)) {
++ && (png_set_filler != NULL)) {
+ /*
+ * The set_filler() function doesn't need to be called
+@@ -660,16 +549,14 @@
+ * possible with v0.95 and higher.
+ */
+- png.set_filler(png_ptr, 0, PNG_FILLER_AFTER);
++ png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
+ newPixelSize++;
+ #endif
+ }
+
+- png.set_IHDR(png_ptr, info_ptr, blockPtr->width, blockPtr->height, 8,
++ png_set_IHDR(png_ptr, info_ptr, blockPtr->width, blockPtr->height, 8,
+ color_type, PNG_INTERLACE_ADAM7, PNG_COMPRESSION_TYPE_BASE,
+ PNG_FILTER_TYPE_BASE);
+
+- if (png.set_gAMA) {
+- png.set_gAMA(png_ptr, info_ptr, 1.0);
+- }
++ png_set_gAMA(png_ptr, info_ptr, 1.0);
+
+ if (tagcount > 0) {
+@@ -686,10 +573,10 @@
+ }
+ text.lang = NULL;
+- png.set_text(png_ptr, info_ptr, (png_text *) &text, 1);
++ png_set_text(png_ptr, info_ptr, (png_text *) &text, 1);
+ }
+ }
+- png.write_info(png_ptr,info_ptr);
++ png_write_info(png_ptr,info_ptr);
+
+- number_passes = png.set_interlace_handling(png_ptr);
++ number_passes = png_set_interlace_handling(png_ptr);
+
+ if (blockPtr->pixelSize != newPixelSize) {
+@@ -709,5 +596,5 @@
+ dst += newPixelSize;
+ }
+- png.write_row(png_ptr, row_pointers);
++ png_write_row(png_ptr, row_pointers);
+ }
+ }
+@@ -717,11 +604,11 @@
+ for (pass = 0; pass < number_passes; pass++) {
+ for(I=0;I<blockPtr->height;I++) {
+- png.write_row(png_ptr, (png_bytep) blockPtr->pixelPtr
++ png_write_row(png_ptr, (png_bytep) blockPtr->pixelPtr
+ + I * blockPtr->pitch + blockPtr->offset[0]);
+ }
+ }
+ }
+- png.write_end(png_ptr,NULL);
+- png.destroy_write_struct(&png_ptr,&info_ptr);
++ png_write_end(png_ptr,NULL);
++ png_destroy_write_struct(&png_ptr,&info_ptr);
+
+ return(TCL_OK);
diff --git a/graphics/libimg/files/patch-tiff b/graphics/libimg/files/patch-tiff
new file mode 100644
index 000000000000..5722f0ca1612
--- /dev/null
+++ b/graphics/libimg/files/patch-tiff
@@ -0,0 +1,592 @@
+--- imgTIFF.c Tue Jan 15 15:59:58 2002
++++ imgTIFF.c Thu Jun 9 19:57:53 2005
+@@ -4,5 +4,5 @@
+ * A photo image file handler for TIFF files.
+ *
+- * Uses the libtiff.so library, which is dynamically
++ * Uses the libTIFFso library, which is dynamically
+ * loaded only when used.
+ *
+@@ -40,9 +40,9 @@
+
+ #ifdef __WIN32__
+-#define TIFF_LIB_NAME "tiff.dll"
++#define TIFF_LIB_NAME "TIFFdll"
+ #endif
+
+ #ifndef TIFF_LIB_NAME
+-#define TIFF_LIB_NAME "libtiff.so"
++#define TIFF_LIB_NAME "libTIFFso"
+ #endif
+
+@@ -78,73 +78,4 @@
+ };
+
+-static struct TiffFunctions {
+- VOID *handle;
+- void (* Close) _ANSI_ARGS_((TIFF *));
+- int (* GetField) _ANSI_ARGS_(TCL_VARARGS(TIFF *, tif));
+- int (* GetFieldDefaulted) _ANSI_ARGS_(TCL_VARARGS(TIFF *,tif));
+- TIFF* (* Open) _ANSI_ARGS_((CONST char*, CONST char*));
+- int (* ReadEncodedStrip) _ANSI_ARGS_((TIFF*, tstrip_t, tdata_t, tsize_t));
+- int (* ReadRGBAImage) _ANSI_ARGS_((TIFF *, uint32, uint32, uint32*, int));
+- int (* ReadTile) _ANSI_ARGS_((TIFF *, uint32, uint32, uint32*, int));
+- int (* SetField) _ANSI_ARGS_(TCL_VARARGS(TIFF *, tif));
+- tsize_t (* TileSize) _ANSI_ARGS_((TIFF*));
+- int (* WriteEncodedStrip) _ANSI_ARGS_((TIFF*, tstrip_t, tdata_t, tsize_t));
+- void (* free) _ANSI_ARGS_((tdata_t));
+- tdata_t (* malloc) _ANSI_ARGS_((tsize_t));
+- tdata_t (* memcpy) _ANSI_ARGS_((tdata_t, tdata_t, tsize_t));
+- tdata_t (* realloc) _ANSI_ARGS_((tdata_t, tsize_t));
+- TIFFErrorHandler (* SetErrorHandler) _ANSI_ARGS_((TIFFErrorHandler));
+- TIFFErrorHandler (* SetWarningHandler) _ANSI_ARGS_((TIFFErrorHandler));
+- TIFF* (* ClientOpen) _ANSI_ARGS_((CONST char*, CONST char*, VOID *,
+- TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc,
+- TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc));
+- TIFFCodec* (*RegisterCODEC) _ANSI_ARGS_((uint16, CONST char*, VOID *));
+- void (* Error) _ANSI_ARGS_(TCL_VARARGS(CONST char *, arg1));
+- int (* PredictorInit) _ANSI_ARGS_((TIFF *));
+- void (* MergeFieldInfo) _ANSI_ARGS_((TIFF *, CONST VOID *, int));
+- int (* FlushData1) _ANSI_ARGS_((TIFF *));
+- void (* NoPostDecode) _ANSI_ARGS_((TIFF *, VOID*, tsize_t));
+- tsize_t (* TileRowSize) _ANSI_ARGS_((TIFF *));
+- tsize_t (* ScanlineSize) _ANSI_ARGS_((TIFF *));
+- void (* setByteArray) _ANSI_ARGS_((VOID **, VOID*, long));
+- int (* VSetField) _ANSI_ARGS_((TIFF *, ttag_t, va_list));
+- void (* SwabArrayOfShort) _ANSI_ARGS_((uint16*, unsigned long));
+-} tiff = {0};
+-
+-static char *symbols[] = {
+- "TIFFClose",
+- "TIFFGetField",
+- "TIFFGetFieldDefaulted",
+- "TIFFOpen",
+- "TIFFReadEncodedStrip",
+- "TIFFReadRGBAImage",
+- "TIFFReadTile",
+- "TIFFSetField",
+- "TIFFTileSize",
+- "TIFFWriteEncodedStrip",
+- /* The following symbols are not crucial. If they cannot be
+- found, just don't use them. The ClientOpen function is
+- more difficult to emulate, but even that is possible. */
+- "_TIFFfree",
+- "_TIFFmalloc",
+- "_TIFFmemcpy",
+- "_TIFFrealloc",
+- "TIFFSetErrorHandler",
+- "TIFFSetWarningHandler",
+- "TIFFClientOpen",
+- "TIFFRegisterCODEC", /* not in libtiff.def */
+- "TIFFError",
+- "TIFFPredictorInit", /* not in libtiff.def */
+- "_TIFFMergeFieldInfo", /* not in libtiff.def */
+- "TIFFFlushData1", /* not in libtiff.def */
+- "_TIFFNoPostDecode", /* not in libtiff.def */
+- "TIFFTileRowSize",
+- "TIFFScanlineSize",
+- "_TIFFsetByteArray", /* not in libtiff.def */
+- "TIFFVSetField",
+- "TIFFSwabArrayOfShort",
+- (char *) NULL
+-};
+-
+ /*
+ * Prototypes for local procedures defined in this file:
+@@ -162,166 +93,5 @@
+ static int ParseWriteFormat _ANSI_ARGS_((Tcl_Interp *interp, Tcl_Obj *format,
+ int *comp, char **mode));
+-static int load_tiff_library _ANSI_ARGS_((Tcl_Interp *interp));
+ static void _TIFFerr _ANSI_ARGS_((CONST char *, CONST char *, va_list));
+-static void _TIFFwarn _ANSI_ARGS_((CONST char *, CONST char *, va_list));
+-void ImgTIFFfree _ANSI_ARGS_((tdata_t data));
+-tdata_t ImgTIFFmalloc _ANSI_ARGS_((tsize_t size));
+-tdata_t ImgTIFFrealloc _ANSI_ARGS_((tdata_t data, tsize_t size));
+-tdata_t ImgTIFFmemcpy _ANSI_ARGS_((tdata_t, tdata_t, tsize_t));
+-void ImgTIFFError _ANSI_ARGS_(TCL_VARARGS(CONST char *, module));
+-int ImgTIFFPredictorInit _ANSI_ARGS_((TIFF *tif));
+-void ImgTIFFMergeFieldInfo _ANSI_ARGS_((TIFF* tif, CONST VOID *voidp, int i));
+-int ImgTIFFFlushData1 _ANSI_ARGS_((TIFF *tif));
+-void ImgTIFFNoPostDecode _ANSI_ARGS_((TIFF *, VOID *, tsize_t));
+-tsize_t ImgTIFFTileRowSize _ANSI_ARGS_((TIFF *));
+-tsize_t ImgTIFFScanlineSize _ANSI_ARGS_((TIFF *));
+-void ImgTIFFsetByteArray _ANSI_ARGS_((VOID **, VOID*, long));
+-int ImgTIFFSetField _ANSI_ARGS_(TCL_VARARGS(TIFF *, tif));
+-tsize_t ImgTIFFTileSize _ANSI_ARGS_((TIFF*));
+-void ImgTIFFSwabArrayOfShort _ANSI_ARGS_((uint16*, unsigned long));
+-
+-/*
+- * External hooks to functions, so they can be called from
+- * imgTIFFzip.c and imgTIFFjpeg.c as well.
+- */
+-
+-void ImgTIFFfree (data)
+- tdata_t data;
+-{
+- if (tiff.free) {
+- tiff.free(data);
+- } else {
+- ckfree((char *) data);
+- }
+-}
+-
+-tdata_t ImgTIFFmalloc(size)
+- tsize_t size;
+-{
+- if (tiff.malloc) {
+- return tiff.malloc(size);
+- } else {
+- return ckalloc(size);
+- }
+-}
+-
+-tdata_t ImgTIFFrealloc(data, size)
+- tdata_t data;
+- tsize_t size;
+-{
+- if (tiff.realloc) {
+- return tiff.realloc(data, size);
+- } else {
+- return ckrealloc(data, size);
+- }
+-}
+-
+-tdata_t
+-ImgTIFFmemcpy(a,b,c)
+- tdata_t a;
+- tdata_t b;
+- tsize_t c;
+-{
+- return tiff.memcpy(a,b,c);
+-}
+-
+-void
+-ImgTIFFError TCL_VARARGS_DEF(CONST char *, arg1)
+-{
+- va_list ap;
+- CONST char* module;
+- CONST char* fmt;
+-
+- module = (CONST char*) TCL_VARARGS_START(CONST char *, arg1, ap);
+- fmt = va_arg(ap, CONST char *);
+- _TIFFerr(module, fmt, ap);
+- va_end(ap);
+-}
+-
+-int
+-ImgTIFFPredictorInit(tif)
+- TIFF *tif;
+-{
+- return tiff.PredictorInit(tif);
+-}
+-
+-void
+-ImgTIFFMergeFieldInfo(tif, voidp, i)
+- TIFF* tif;
+- CONST VOID *voidp;
+- int i;
+-{
+- tiff.MergeFieldInfo(tif, voidp, i);
+-}
+-
+-int
+-ImgTIFFFlushData1(tif)
+- TIFF *tif;
+-{
+- return tiff.FlushData1(tif);
+-}
+-
+-void
+-ImgTIFFNoPostDecode(tif,a,b)
+- TIFF * tif;
+- VOID *a;
+- tsize_t b;
+-{
+- tiff.NoPostDecode(tif, a, b);
+-}
+-
+-tsize_t
+-ImgTIFFTileRowSize(tif)
+- TIFF * tif;
+-{
+- return tiff.TileRowSize(tif);
+-}
+-
+-tsize_t
+-ImgTIFFScanlineSize(tif)
+- TIFF *tif;
+-{
+- return tiff.ScanlineSize(tif);
+-}
+-
+-void
+-ImgTIFFsetByteArray(a,b,c)
+- VOID **a;
+- VOID *b;
+- long c;
+-{
+- tiff.setByteArray(a,b,c);
+-}
+-
+-int
+-ImgTIFFSetField TCL_VARARGS_DEF(TIFF*, arg1)
+-{
+- va_list ap;
+- TIFF* tif;
+- ttag_t tag;
+- int result;
+-
+- tif = (TIFF*) TCL_VARARGS_START(TIFF*, arg1, ap);
+- tag = va_arg(ap, ttag_t);
+- result = tiff.VSetField(tif, tag, ap);
+- va_end(ap);
+- return result;
+-}
+-
+-tsize_t
+-ImgTIFFTileSize(tif)
+- TIFF* tif;
+-{
+- return tiff.TileSize(tif);
+-}
+-
+-void
+-ImgTIFFSwabArrayOfShort(p, l)
+- uint16* p;
+- unsigned long l;
+-{
+- tiff.SwabArrayOfShort(p,l);
+- return;
+-}
+
+ /*
+@@ -369,37 +139,15 @@
+ }
+
+-static int
+-load_tiff_library(interp)
+- Tcl_Interp *interp;
++static void
++initialize(void)
+ {
+- static int initialized = 0;
+- if (errorMessage) {
+- ckfree(errorMessage);
+- errorMessage = NULL;
+- }
+- if (ImgLoadLib(interp, TIFF_LIB_NAME, &tiff.handle, symbols, 10)
+- != TCL_OK) {
+- return TCL_ERROR;
+- }
+- if (tiff.SetErrorHandler != NULL) {
+- tiff.SetErrorHandler(_TIFFerr);
+- }
+- if (tiff.SetWarningHandler != NULL) {
+- tiff.SetWarningHandler(_TIFFwarn);
+- }
++ static int initialized;
++
+ if (!initialized) {
++ TIFFSetErrorHandler(_TIFFerr);
+ initialized = 1;
+- if (tiff.RegisterCODEC && tiff.Error && tiff.PredictorInit &&
+- tiff.MergeFieldInfo && tiff.FlushData1 && tiff.NoPostDecode &&
+- tiff.TileRowSize && tiff.ScanlineSize && tiff.setByteArray &&
+- tiff.VSetField && tiff.SwabArrayOfShort) {
+- tiff.RegisterCODEC(COMPRESSION_DEFLATE, "Deflate", ImgInitTIFFzip);
+- tiff.RegisterCODEC(COMPRESSION_JPEG, "JPEG", ImgInitTIFFjpeg);
+- tiff.RegisterCODEC(COMPRESSION_PIXARLOG, "PixarLog", ImgInitTIFFpixar);
+- }
+ }
+- return TCL_OK;
+ }
+-
++
+ static void _TIFFerr(module, fmt, ap)
+ CONST char *module;
+@@ -423,12 +171,4 @@
+ }
+
+-/* warnings are not processed in Tcl */
+-static void _TIFFwarn(module, fmt, ap)
+- CONST char *module;
+- CONST char *fmt;
+- va_list ap;
+-{
+-}
+-
+ static int
+ mapDummy(fd, base, size)
+@@ -686,12 +426,9 @@
+ TIFF *tif;
+ char tempFileName[256];
+- int count, result;
++ int result;
+ MFile handle;
+- char buffer[1024];
+ char *dataPtr = NULL;
+
+- if (load_tiff_library(interp) != TCL_OK) {
+- return TCL_ERROR;
+- }
++ initialize();
+
+ if (!ImgReadInit(data, '\115', &handle)) {
+@@ -699,36 +436,14 @@
+ }
+
+- if (tiff.ClientOpen) {
+- tempFileName[0] = 0;
+- if (handle.state != IMG_STRING) {
+- dataPtr = ckalloc((handle.length*3)/4 + 2);
+- handle.length = ImgRead(&handle, dataPtr, handle.length);
+- handle.data = dataPtr;
+- }
+- handle.state = 0;
+- tif = tiff.ClientOpen("inline data", "r", (thandle_t) &handle,
+- readString, writeString, seekString, closeDummy,
+- sizeString, mapDummy, unMapDummy);
+- } else {
+- Tcl_Channel outchan;
+- tmpnam(tempFileName);
+- outchan = ImgOpenFileChannel(interp, tempFileName, 0644);
+- if (!outchan) {
+- return TCL_ERROR;
+- }
+-
+- count = ImgRead(&handle, buffer, 1024);
+- while (count == 1024) {
+- Tcl_Write(outchan, buffer, count);
+- count = ImgRead(&handle, buffer, 1024);
+- }
+- if (count>0){
+- Tcl_Write(outchan, buffer, count);
+- }
+- if (Tcl_Close(interp, outchan) == TCL_ERROR) {
+- return TCL_ERROR;
+- }
+- tif = tiff.Open(tempFileName, "r");
+- }
++ tempFileName[0] = 0;
++ if (handle.state != IMG_STRING) {
++ dataPtr = ckalloc((handle.length*3)/4 + 2);
++ handle.length = ImgRead(&handle, dataPtr, handle.length);
++ handle.data = dataPtr;
++ }
++ handle.state = 0;
++ tif = TIFFClientOpen("inline data", "r", (thandle_t) &handle,
++ readString, writeString, seekString, closeDummy,
++ sizeString, mapDummy, unMapDummy);
+
+ if (tif != NULL) {
+@@ -765,41 +480,16 @@
+ TIFF *tif;
+ char tempFileName[256];
+- int count, result;
+- char buffer[1024];
+-
+- if (load_tiff_library(interp) != TCL_OK) {
+- return TCL_ERROR;
+- }
++ int result;
++ MFile handle;
+
+- if (tiff.ClientOpen) {
+- MFile handle;
+- tempFileName[0] = 0;
+- handle.data = (char *) chan;
+- handle.state = IMG_CHAN;
+- tif = tiff.ClientOpen(fileName, "r", (thandle_t) &handle,
+- readMFile, writeDummy, seekMFile, closeDummy,
+- sizeMFile, mapDummy, unMapDummy);
+- } else {
+- Tcl_Channel outchan;
+- tmpnam(tempFileName);
+- outchan = ImgOpenFileChannel(interp, tempFileName, 0644);
+- if (!outchan) {
+- return TCL_ERROR;
+- }
++ initialize();
+
+- count = Tcl_Read(chan, buffer, 1024);
+- while (count == 1024) {
+- Tcl_Write(outchan, buffer, count);
+- count = Tcl_Read(chan, buffer, 1024);
+- }
+- if (count>0){
+- Tcl_Write(outchan, buffer, count);
+- }
+- if (Tcl_Close(interp, outchan) == TCL_ERROR) {
+- return TCL_ERROR;
+- }
++ tempFileName[0] = 0;
++ handle.data = (char *) chan;
++ handle.state = IMG_CHAN;
++ tif = TIFFClientOpen(fileName, "r", (thandle_t) &handle,
++ readMFile, writeDummy, seekMFile, closeDummy,
++ sizeMFile, mapDummy, unMapDummy);
+
+- tif = tiff.Open(tempFileName, "r");
+- }
+ if (tif) {
+ result = CommonReadTIFF(interp, tif, format, imageHandle,
+@@ -857,12 +547,8 @@
+ block.pixelSize = sizeof (uint32);
+
+- tiff.GetField(tif, TIFFTAG_IMAGEWIDTH, &w);
+- tiff.GetField(tif, TIFFTAG_IMAGELENGTH, &h);
++ TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &w);
++ TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &h);
+ npixels = w * h;
+- if (tiff.malloc == NULL) {
+- raster = (uint32 *) ckalloc(npixels * sizeof (uint32));
+- } else {
+- raster = (uint32 *) tiff.malloc(npixels * sizeof (uint32));
+- }
++ raster = _TIFFmalloc(npixels * sizeof (uint32));
+ block.width = w;
+ block.height = h;
+@@ -874,10 +560,6 @@
+ }
+
+- if (!tiff.ReadRGBAImage(tif, w, h, raster, 0) || errorMessage) {
+- if (tiff.free == NULL) {
+- ckfree((char *)raster);
+- } else {
+- tiff.free((char *)raster);
+- }
++ if (!TIFFReadRGBAImage(tif, w, h, raster, 0) || errorMessage) {
++ _TIFFfree(raster);
+ if (errorMessage) {
+ Tcl_AppendResult(interp, errorMessage, (char *) NULL);
+@@ -894,10 +576,6 @@
+ destY, width, height);
+
+- if (tiff.free == NULL) {
+- ckfree((char *)raster);
+- } else {
+- tiff.free((char *)raster);
+- }
+- tiff.Close(tif);
++ _TIFFfree(raster);
++ TIFFClose(tif);
+ return TCL_OK;
+ }
+@@ -917,7 +595,5 @@
+ Tcl_DString data;
+
+- if (load_tiff_library(interp) != TCL_OK) {
+- return TCL_ERROR;
+- }
++ initialize();
+
+ ImgFixStringWriteProc(&data, &interp, &dataPtr, &format, &blockPtr);
+@@ -927,18 +603,13 @@
+ }
+
+- if (tiff.ClientOpen) {
+- tempFileName[0] = 0;
+- Tcl_DStringInit(&dstring);
+- ImgWriteInit(&dstring, &handle);
+- tif = tiff.ClientOpen("inline data", mode, (thandle_t) &handle,
+- readString, writeString, seekString, closeDummy,
+- sizeString, mapDummy, unMapDummy);
+- } else {
+- tmpnam(tempFileName);
+- tif = tiff.Open(tempFileName,mode);
+- }
++ tempFileName[0] = 0;
++ Tcl_DStringInit(&dstring);
++ ImgWriteInit(&dstring, &handle);
++ tif = TIFFClientOpen("inline data", mode, (thandle_t) &handle,
++ readString, writeString, seekString, closeDummy,
++ sizeString, mapDummy, unMapDummy);
+
+ result = CommonWriteTIFF(interp, tif, comp, blockPtr);
+- tiff.Close(tif);
++ TIFFClose(tif);
+
+ if (result != TCL_OK) {
+@@ -999,8 +670,5 @@
+ }
+
+- if (load_tiff_library(interp) != TCL_OK) {
+- Tcl_DStringFree(&nameBuffer);
+- return TCL_ERROR;
+- }
++ initialize();
+
+ if (ParseWriteFormat(interp, format, &comp, &mode) != TCL_OK) {
+@@ -1009,5 +677,5 @@
+ }
+
+- if (!(tif = tiff.Open(fullname, mode))) {
++ if (!(tif = TIFFOpen(fullname, mode))) {
+ Tcl_AppendResult(interp, filename, ": ", Tcl_PosixError(interp),
+ (char *)NULL);
+@@ -1019,5 +687,5 @@
+
+ result = CommonWriteTIFF(interp, tif, comp, blockPtr);
+- tiff.Close(tif);
++ TIFFClose(tif);
+ return result;
+ }
+@@ -1029,5 +697,5 @@
+ char **mode;
+ {
+- static char *tiffWriteOptions[] = {"-compression", "-byteorder"};
++ static const char *tiffWriteOptions[] = {"-compression", "-byteorder"};
+ int objc, length, c, i, index;
+ Tcl_Obj **objv;
+@@ -1112,27 +780,27 @@
+ unsigned char *data = NULL;
+
+- tiff.SetField(tif, TIFFTAG_IMAGEWIDTH, blockPtr->width);
+- tiff.SetField(tif, TIFFTAG_IMAGELENGTH, blockPtr->height);
+- tiff.SetField(tif, TIFFTAG_COMPRESSION, comp);
+-
+- tiff.SetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+- tiff.SetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
+- tiff.SetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+- tiff.SetField(tif, TIFFTAG_ROWSPERSTRIP, blockPtr->height);
+-
+- tiff.SetField(tif, TIFFTAG_RESOLUTIONUNIT, (int)2);
+- tiff.SetField(tif, TIFFTAG_XRESOLUTION, (float)1200.0);
+- tiff.SetField(tif, TIFFTAG_YRESOLUTION, (float)1200.0);
++ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, blockPtr->width);
++ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, blockPtr->height);
++ TIFFSetField(tif, TIFFTAG_COMPRESSION, comp);
++
++ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
++ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
++ TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
++ TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, blockPtr->height);
++
++ TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, (int)2);
++ TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float)1200.0);
++ TIFFSetField(tif, TIFFTAG_YRESOLUTION, (float)1200.0);
+
+- tiff.SetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
++ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
+ if ((blockPtr->offset[0] == blockPtr->offset[1])
+ && (blockPtr->offset[0] == blockPtr->offset[2])) {
+ numsamples = 1;
+- tiff.SetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
+- tiff.SetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
++ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
++ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
+ } else {
+ numsamples = 3;
+- tiff.SetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
+- tiff.SetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
++ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
++ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
+ }
+
+@@ -1186,5 +854,5 @@
+ }
+
+- tiff.WriteEncodedStrip(tif, 0, data,
++ TIFFWriteEncodedStrip(tif, 0, data,
+ numsamples * blockPtr->width * blockPtr->height);
+ if (data != blockPtr->pixelPtr) {
diff --git a/graphics/libimg/files/patch-tk84_Tk_PhotoPutBlock b/graphics/libimg/files/patch-tk84_Tk_PhotoPutBlock
index 7cdb0eb6d863..7b4be394f46c 100644
--- a/graphics/libimg/files/patch-tk84_Tk_PhotoPutBlock
+++ b/graphics/libimg/files/patch-tk84_Tk_PhotoPutBlock
@@ -87,8 +87,8 @@
}
break;
}
---- imgUtil.c.orig Sat Mar 20 23:09:14 1999
-+++ imgUtil.c Mon Dec 1 12:47:43 2003
+--- imgUtil.c Tue Jan 15 15:59:59 2002
++++ imgUtil.c Thu Jun 9 20:51:49 2005
@@ -95,7 +95,7 @@
}
if (end > X) {
@@ -98,7 +98,7 @@
}
X = end;
}
-@@ -103,7 +103,7 @@
+@@ -103,12 +103,12 @@
}
blockPtr->pixelPtr = imagePtr;
} else {
@@ -107,13 +107,20 @@
}
return TCL_OK;
}
-@@ -248,4 +248,4 @@
+
+-
++#if 0 /* OS run-time linker is better suited for this job { */
+ /*
+ *----------------------------------------------------------------------
+ *
+@@ -248,4 +248,5 @@
dlclose(*handlePtr);
}
*handlePtr = IMG_FAILED;
-}
\ No newline at end of file
+}
++#endif /* } */
--- imgWindow.c.orig Sat Jan 15 13:25:37 2000
+++ imgWindow.c Mon Dec 1 12:52:11 2003
@@ -378,7 +378,7 @@
diff --git a/graphics/libimg/files/patch-warnings b/graphics/libimg/files/patch-warnings
new file mode 100644
index 000000000000..91aaaf017842
--- /dev/null
+++ b/graphics/libimg/files/patch-warnings
@@ -0,0 +1,229 @@
+--- imgObj.c Tue Jan 15 16:00:08 2002
++++ imgObj.c Thu Jun 9 05:28:23 2005
+@@ -33,5 +33,5 @@
+ return (initialized = IMG_PERL|IMG_OBJS);
+ #else
+- char *version;
++ const char *version;
+ initialized = IMG_TCL;
+ if (!Tcl_GetCommandInfo(interp,"image", &cmdInfo)) {
+--- imgInit.c Tue Jan 15 15:59:58 2002
++++ imgInit.c Thu Jun 9 05:27:40 2005
+@@ -94,5 +94,5 @@
+ {
+ Tk_PhotoImageFormat **formatPtr = Formats;
+- char *version;
++ const char *version;
+
+ if ((version = Tcl_InitStubs(interp, "8.0", 0)) == NULL) {
+--- imgPmap.h Tue Jan 15 15:59:58 2002
++++ imgPmap.h Thu Jun 9 05:48:57 2005
+@@ -53,5 +53,5 @@
+ int ncolors; /* number of colors */
+ int cpp; /* characters per pixel */
+- char ** data; /* The data that defines this pixmap
++ const char ** data; /* The data that defines this pixmap
+ * image (array of strings). It is
+ * converted into an X Pixmap when this
+--- imgPmap.c Tue Jan 15 15:59:58 2002
++++ imgPmap.c Thu Jun 9 05:52:31 2005
+@@ -49,6 +53,5 @@
+ Display *display));
+ static void ImgXpmDelete _ANSI_ARGS_((ClientData clientData));
+-static int ImgXpmCmd _ANSI_ARGS_((ClientData clientData,
+- Tcl_Interp *interp, int argc, char **argv));
++static Tcl_CmdProc ImgXpmCmd;
+ static void ImgXpmCmdDeletedProc _ANSI_ARGS_((
+ ClientData clientData));
+@@ -56,11 +59,11 @@
+ PixmapInstance *instancePtr));
+ static int ImgXpmConfigureMaster _ANSI_ARGS_((
+- PixmapMaster *masterPtr, int argc, char **argv,
+- int flags));
++ PixmapMaster *masterPtr, int argc,
++ const char **argv, int flags));
+ static int ImgXpmGetData _ANSI_ARGS_((Tcl_Interp *interp,
+ PixmapMaster *masterPtr));
+-static char ** ImgXpmGetDataFromFile _ANSI_ARGS_((Tcl_Interp * interp,
++static const char ** ImgXpmGetDataFromFile _ANSI_ARGS_((Tcl_Interp * interp,
+ char * string, int * numLines_return));
+-static char ** ImgXpmGetDataFromString _ANSI_ARGS_((Tcl_Interp*interp,
++static const char ** ImgXpmGetDataFromString _ANSI_ARGS_((Tcl_Interp*interp,
+ char * string, int * numLines_return));
+ static void ImgXpmGetPixmapFromData _ANSI_ARGS_((
+@@ -68,7 +71,7 @@
+ PixmapMaster *masterPtr,
+ PixmapInstance *instancePtr));
+-static char * GetType _ANSI_ARGS_((char * colorDefn,
++static const char * GetType _ANSI_ARGS_((const char * colorDefn,
+ int * type_ret));
+-static char * GetColor _ANSI_ARGS_((char * colorDefn,
++static const char * GetColor _ANSI_ARGS_((const char * colorDefn,
+ char * colorName, int * type_ret));
+
+@@ -131,6 +134,6 @@
+ PixmapMaster *masterPtr;
+ int i;
+- char *argvbuf[10];
+- char **args = argvbuf;
++ const char *argvbuf[10];
++ const char **args = argvbuf;
+
+ /*
+@@ -138,5 +141,5 @@
+ */
+ if (argc > 10) {
+- args = (char **) ckalloc(argc * sizeof(char *));
++ args = (const char **)ckalloc(argc * sizeof(char *));
+ }
+ for (i = 0; i < argc; i++) {
+@@ -197,5 +200,5 @@
+ * overall pixmap image to (reconfigure). */
+ int argc; /* Number of entries in argv. */
+- char **argv; /* Pairs of configuration options for image. */
++ const char **argv; /* Pairs of configuration options for image. */
+ int flags; /* Flags to pass to Tk_ConfigureWidget,
+ * such as TK_CONFIG_ARGV_ONLY. */
+@@ -280,8 +283,8 @@
+ PixmapMaster *masterPtr;
+ {
+- char ** data = NULL;
++ const char ** data = NULL;
+ int isAllocated = 0; /* do we need to free "data"? */
+ int listArgc;
+- char ** listArgv = NULL;
++ const char ** listArgv = NULL;
+ int numLines;
+ int size[2];
+@@ -371,5 +374,6 @@
+ }
+
+-static char ** ImgXpmGetDataFromString(interp, string, numLines_return)
++static const char **
++ImgXpmGetDataFromString(interp, string, numLines_return)
+ Tcl_Interp * interp;
+ char * string;
+@@ -379,5 +383,5 @@
+ char * p, * list;
+ int numLines;
+- char ** data;
++ const char ** data;
+
+ /* skip the leading blanks (leading blanks are not defined in the
+@@ -497,8 +501,9 @@
+ error:
+ Tcl_AppendResult(interp, "File format error", NULL);
+- return (char**) NULL;
++ return NULL;
+ }
+
+-static char ** ImgXpmGetDataFromFile(interp, fileName, numLines_return)
++static const char **
++ImgXpmGetDataFromFile(interp, fileName, numLines_return)
+ Tcl_Interp * interp;
+ char * fileName;
+@@ -507,10 +512,10 @@
+ Tcl_Channel chan;
+ int size;
+- char ** data = (char **) NULL;
++ const char ** data = NULL;
+ char *cmdBuffer = NULL;
+
+ chan = ImgOpenFileChannel(interp, fileName, 0);
+ if (!chan) {
+- return (char **) NULL;
++ return NULL;
+ }
+
+@@ -540,10 +545,10 @@
+
+
+-static char *
++static const char *
+ GetType(colorDefn, type_ret)
+- char * colorDefn;
++ const char * colorDefn;
+ int * type_ret;
+ {
+- char * p = colorDefn;
++ const char * p = colorDefn;
+
+ /* skip white spaces */
+@@ -590,7 +595,7 @@
+ * colorName is guaranteed to be big enough
+ */
+-static char *
++static const char *
+ GetColor(colorDefn, colorName, type_ret)
+- char * colorDefn;
++ const char * colorDefn;
+ char * colorName; /* if found, name is copied to this array */
+ int * type_ret;
+@@ -699,5 +704,5 @@
+
+ for (i=0; i<masterPtr->ncolors; i++) {
+- char * colorDefn; /* the color definition line */
++ const char * colorDefn; /* the color definition line */
+ char * colorName; /* temp place to hold the color name
+ * defined for one type of visual */
+@@ -790,5 +795,5 @@
+ */
+ for (i=0; i<masterPtr->size[1]; i++) {
+- char * p = masterPtr->data[i+lOffset];
++ const char * p = masterPtr->data[i+lOffset];
+
+ for (j=0; j<masterPtr->size[0]; j++) {
+@@ -905,5 +910,5 @@
+ Tcl_Interp *interp; /* Current interpreter. */
+ int argc; /* Number of arguments. */
+- char **argv; /* Argument strings. */
++ const char *argv[]; /* Argument strings. */
+ {
+ PixmapMaster *masterPtr = (PixmapMaster *) clientData;
+--- imgPS.c Tue Jan 15 16:00:10 2002
++++ imgPS.c Thu Jun 9 05:58:04 2005
+@@ -269,5 +269,5 @@
+ {
+ #ifndef MAC_TCL
+- char *argv[10];
++ const char *argv[10];
+ int len, i, j, fileWidth, fileHeight, maxintensity, index;
+ char *p, type;
+--- imgXPM.c Tue Jan 15 16:00:08 2002
++++ imgXPM.c Thu Jun 9 20:33:32 2005
+@@ -287,6 +287,6 @@
+ char buffer[MAX_BUFFER];
+ int i, isMono;
+- int color1;
+- unsigned int data;
++ intptr_t color1;
++ uintptr_t data;
+ Tcl_HashEntry *hPtr;
+
+@@ -466,5 +466,5 @@
+
+ for (i = 0; i < width; ) {
+- unsigned int col;
++ uintptr_t col;
+
+ memcpy((char *) &color1, p, byteSize);
+@@ -476,7 +476,7 @@
+ */
+ if (hPtr != (Tcl_HashEntry *)NULL)
+- col = (int)Tcl_GetHashValue(hPtr);
++ col = (uintptr_t)Tcl_GetHashValue(hPtr);
+ else
+- col = (int)0;
++ col = 0;
+
+ /*
+@@ -500,7 +500,7 @@
+ hPtr = Tcl_FindHashEntry(&colorTable, (char *) color1);
+ if (hPtr != (Tcl_HashEntry *)NULL)
+- col = (int)Tcl_GetHashValue(hPtr);
++ col = (uintptr_t)Tcl_GetHashValue(hPtr);
+ else
+- col = (int)0;
++ col = 0;
+ }
+ } while ((i < width) && col);