Hello,
Attached is a patch to add TIFF Group 3/4, TIFF CCITT, and TIFF RAW_16
decoding to PIL 1.1.6. The lack of this in PIL is something people have
complained/asked about off and on for years (from looking at mailing
lists and forums on google). However, this is not a new patch. It is
completley based on a patch by Vladimir Pastukhov posted to the
image-sig mailing list in the year of 2003
(http://mail.python.org/pipermail/image-sig/2003-July/002354.html). All
I have done is adapted it so that it applies to PIL 1.1.6. I
tested it against libtiff 3.8.2.
One problem with the patch, and I suppose the reason why it never
catched on, is that it requires libtiff header files that are not
installed as per the current libtiff's installation process. These are
tiffiop.h, tif_dir.h, and tif_config.h. Thus, I am also cc'ing the
libtiff mailing list here. I solve the problem by adding the needed
files to the PIL patch from the libtiff configured source. I assume this
is not a problem license-wise as both libraries are under the BSD. Is
this correct?
I know this is far from ideal. There is a libtiff bug report from the
year 2004 (http://bugzilla.remotesensing.org/show_bug.cgi?id=688)
explaning the need for tiffiop.h and tif_dir.h to be installed
(tiffiop.h didn't use tiff_config.h back then). There is also the
explanation of why they are not installed (they contain private
structures and functions) along with the intention, but without
promises, of creating some separate interface for this kind of access.
I'm adding my vote to that request, but couldn't the header files in
question just be installed in the meantime? Given that there is no
timeline for such special interface and all.
The other problem is that, besides needing other eyes to revise the
patch, I don't know how to test this on Win32 or if more work is
required for that. Would need other interested people to take a shot.
I hope the libtiff developers won't see a problem with adding the
requested headers to the installation for now. It could be made to be
like a deprecated interface by using #warnings or something similar.
Then the problem of breaking applications when an interface to this
finally comes wouldn't be so bad as you could say everyone was warned.
Doing this simple change now, rather than just waiting for a formalized
solution later, would help people improve TIFF support
(multi-page, etc.) in PIL and others.
Thoughts?
--Renier
--- Imaging-1.1.6.orig/PIL/TiffImagePlugin.py 2006-12-03 07:37:15.000000000 -0400
+++ Imaging-1.1.6/PIL/TiffImagePlugin.py 2007-06-24 02:24:09.000000000 -0400
@@ -494,7 +494,7 @@
return self.__frame
- def _decoder(self, rawmode, layer):
+ def _decoder(self, rawmode, layer, tile=None):
"Setup decoder contexts"
args = None
@@ -515,6 +515,13 @@
if self.tag.has_key(317):
# Section 14: Differencing Predictor
self.decoderconfig = (self.tag[PREDICTOR][0],)
+ elif compression in ["tiff_ccitt", "group3", "group4", "tiff_raw_16"]:
+ args = (rawmode,
+ compression,
+ (self.tag.has_key(FILLORDER)) \
+ and self.tag[FILLORDER][0] or -1,
+ (tile is not None and self.tag.has_key(STRIPBYTECOUNTS)) \
+ and self.tag[STRIPBYTECOUNTS][tile] or -1)
return args
@@ -587,16 +594,15 @@
self.tile = []
if self.tag.has_key(STRIPOFFSETS):
# striped image
+ offsets = self.tag[STRIPOFFSETS]
h = getscalar(ROWSPERSTRIP, ysize)
w = self.size[0]
- a = None
- for o in self.tag[STRIPOFFSETS]:
- if not a:
- a = self._decoder(rawmode, l)
+ for i in range(len(offsets)):
+ a = self._decoder(rawmode, l, i)
self.tile.append(
(self._compression,
(0, min(y, ysize), w, min(y+h, ysize)),
- o, a))
+ offsets[i], a))
y = y + h
if y >= self.size[1]:
x = y = 0
--- Imaging-1.1.6.orig/_imaging.c 2006-12-03 08:20:39.000000000 -0400
+++ Imaging-1.1.6/_imaging.c 2007-06-24 02:24:09.000000000 -0400
@@ -2999,6 +2999,7 @@
extern PyObject* PyImaging_HexDecoderNew(PyObject* self, PyObject* args);
extern PyObject* PyImaging_JpegDecoderNew(PyObject* self, PyObject* args);
extern PyObject* PyImaging_TiffLzwDecoderNew(PyObject* self, PyObject* args);
+extern PyObject* PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args);
extern PyObject* PyImaging_MspDecoderNew(PyObject* self, PyObject* args);
extern PyObject* PyImaging_PackbitsDecoderNew(PyObject* self, PyObject* args);
extern PyObject* PyImaging_PcdDecoderNew(PyObject* self, PyObject* args);
@@ -3064,6 +3065,12 @@
{"jpeg_encoder", (PyCFunction)PyImaging_JpegEncoderNew, 1},
#endif
{"tiff_lzw_decoder", (PyCFunction)PyImaging_TiffLzwDecoderNew, 1},
+#ifdef HAVE_LIBTIFF
+ {"tiff_ccitt_decoder", (PyCFunction)PyImaging_LibTiffDecoderNew, 1},
+ {"group3_decoder", (PyCFunction)PyImaging_LibTiffDecoderNew, 1},
+ {"group4_decoder", (PyCFunction)PyImaging_LibTiffDecoderNew, 1},
+ {"tiff_raw_16_decoder", (PyCFunction)PyImaging_LibTiffDecoderNew, 1},
+#endif
{"msp_decoder", (PyCFunction)PyImaging_MspDecoderNew, 1},
{"packbits_decoder", (PyCFunction)PyImaging_PackbitsDecoderNew, 1},
{"pcd_decoder", (PyCFunction)PyImaging_PcdDecoderNew, 1},
--- Imaging-1.1.6.orig/decode.c 2006-12-03 07:51:25.000000000 -0400
+++ Imaging-1.1.6/decode.c 2007-06-24 02:24:09.000000000 -0400
@@ -53,6 +53,7 @@
PyObject_HEAD
int (*decode)(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
+ void (*cleanup)(ImagingCodecState state);
struct ImagingCodecStateInstance state;
Imaging im;
PyObject* lock;
@@ -88,6 +89,7 @@
/* Initialize decoder context */
decoder->state.context = context;
+ decoder->cleanup = NULL;
/* Target image */
decoder->lock = NULL;
@@ -99,6 +101,8 @@
static void
_dealloc(ImagingDecoderObject* decoder)
{
+ if (decoder->cleanup)
+ decoder->cleanup(&decoder->state);
free(decoder->state.buffer);
free(decoder->state.context);
Py_XDECREF(decoder->lock);
@@ -382,6 +386,80 @@
return (PyObject*) decoder;
}
+/* -------------------------------------------------------------------- */
+/* LibTiff */
+/* -------------------------------------------------------------------- */
+
+#ifdef HAVE_LIBTIFF
+
+#include "Tiff.h"
+
+#include <string.h>
+#ifdef __WIN32__
+#define strcasecmp(s1, s2) stricmp(s1, s2)
+#endif
+
+PyObject*
+PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args)
+{
+ ImagingDecoderObject* decoder;
+ char* mode;
+ char* rawmode;
+ char* compname;
+ int compression;
+ int fillorder = -1;
+ int count = -1;
+
+ if (! PyArg_ParseTuple(args, "sss|ii", &mode, &rawmode, &compname, &fillorder, &count))
+ return NULL;
+
+ TRACE(("new decoder %s, fillorder %d, %d bytes\n", compname, fillorder, count));
+
+ if (strcasecmp(compname, "tiff_ccitt") == 0) {
+ compression = COMPRESSION_CCITTRLE;
+
+ } else if (strcasecmp(compname, "group3") == 0) {
+ compression = COMPRESSION_CCITTFAX3;
+
+ } else if (strcasecmp(compname, "group4") == 0) {
+ compression = COMPRESSION_CCITTFAX4;
+
+ } else if (strcasecmp(compname, "tiff_raw_16") == 0) {
+ compression = COMPRESSION_CCITTRLEW;
+
+ } else {
+ PyErr_SetString(PyExc_ValueError, "unknown compession");
+ return NULL;
+ }
+
+ if (fillorder < 0) {
+ fillorder = FILLORDER_MSB2LSB;
+
+ } else if (fillorder != FILLORDER_MSB2LSB && fillorder != FILLORDER_LSB2MSB) {
+ PyErr_SetString(PyExc_ValueError, "invalid fillorder");
+ return NULL;
+ }
+
+ decoder = PyImaging_DecoderNew(sizeof(TIFFSTATE));
+ if (decoder == NULL)
+ return NULL;
+
+ if (get_unpacker(decoder, mode, rawmode) < 0)
+ return NULL;
+
+ if (! ImagingLibTiffInit(&decoder->state, compression, fillorder, count)) {
+ Py_DECREF(decoder);
+ PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed");
+ return NULL;
+ }
+
+ decoder->decode = ImagingLibTiffDecode;
+ decoder->cleanup = ImagingLibTiffCleanup;
+
+ return (PyObject*) decoder;
+}
+
+#endif
/* -------------------------------------------------------------------- */
/* MSP */
--- Imaging-1.1.6.orig/libImaging/Imaging.h 2006-12-03 07:37:25.000000000 -0400
+++ Imaging-1.1.6/libImaging/Imaging.h 2007-06-24 02:24:09.000000000 -0400
@@ -417,6 +417,10 @@
#endif
extern int ImagingLzwDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
+#ifdef HAVE_LIBTIFF
+extern int ImagingLibTiffDecode(Imaging im, ImagingCodecState state,
+ UINT8* buffer, int bytes);
+#endif
#ifdef HAVE_LIBMPEG
extern int ImagingMpegDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
--- Imaging-1.1.6.orig/libImaging/Tiff.h 2007-06-27 02:19:41.000000000 -0400
+++ Imaging-1.1.6/libImaging/Tiff.h 2007-06-26 02:00:02.000000000 -0400
@@ -0,0 +1,27 @@
+/*
+ * The Python Imaging Library.
+ * $Id: //modules/pil/libImaging/Tiff.h#1 $
+ *
+ * declarations for the LibTiff-based Group3 and Group4 decoder
+ *
+ */
+
+#include <tiffiop.h>
+
+typedef struct {
+
+ /* PRIVATE CONTEXT (set by decoder) */
+ TIFF tiff;
+ int count;
+
+} TIFFSTATE;
+
+extern int ImagingLibTiffInit(ImagingCodecState state, int compression, int fillorder, int count);
+extern void ImagingLibTiffCleanup(ImagingCodecState state);
+
+/*
+#define VA_ARGS(...) __VA_ARGS__
+#define TRACE(args) fprintf(stderr, VA_ARGS args)
+*/
+
+#define TRACE(args)
--- Imaging-1.1.6.orig/libImaging/TiffDecode.c 2007-06-27 02:20:59.000000000 -0400
+++ Imaging-1.1.6/libImaging/TiffDecode.c 2007-06-24 02:24:09.000000000 -0400
@@ -0,0 +1,185 @@
+/*
+ * The Python Imaging Library.
+ * $Id: //modules/pil/libImaging/TiffDecode.c#1 $
+ *
+ * LibTiff-based Group3 and Group4 decoder
+ *
+ */
+
+#include "Imaging.h"
+
+#ifdef HAVE_LIBTIFF
+
+#undef INT32
+#undef UINT32
+
+#include "Tiff.h"
+
+#include <stddef.h>
+
+#include <tiffio.h>
+#include <tiffiop.h>
+
+extern void _TIFFSetDefaultCompressionState(TIFF* tif);
+
+typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
+
+typedef struct {
+ int rw_mode; /* O_RDONLY for decode, else encode */
+ int mode; /* operating mode */
+ uint32 rowbytes; /* bytes in a decoded scanline */
+ uint32 rowpixels; /* pixels in a scanline */
+
+ uint16 cleanfaxdata; /* CleanFaxData tag */
+ uint32 badfaxrun; /* BadFaxRun tag */
+ uint32 badfaxlines; /* BadFaxLines tag */
+ uint32 groupoptions; /* Group 3/4 options tag */
+ uint32 recvparams; /* encoded Class 2 session params */
+ char* subaddress; /* subaddress string */
+ uint32 recvtime; /* time spent receiving (secs) */
+ TIFFVGetMethod vgetparent; /* super-class method */
+ TIFFVSetMethod vsetparent; /* super-class method */
+} Fax3BaseState;
+
+typedef struct {
+ Fax3BaseState b;
+ const u_char* bitmap; /* bit reversal table */
+ uint32 data; /* current i/o byte/word */
+ int bit; /* current i/o bit in byte */
+ int EOLcnt; /* count of EOL codes recognized */
+ TIFFFaxFillFunc fill; /* fill routine */
+ uint32* runs; /* b&w runs for current/previous row */
+ uint32* refruns; /* runs for reference line */
+ uint32* curruns; /* runs for current line */
+} Fax3DecodeState;
+
+
+#define DECODER_STATE(tiff) (UINT8 *)(tiff->tif_data + offsetof(Fax3DecodeState, bitmap))
+#define DECODER_STATE_SIZE (sizeof(Fax3DecodeState) - offsetof(Fax3DecodeState, bitmap))
+
+
+static void
+_errorHandler(const char* module, const char* fmt, va_list ap)
+{
+ /* be quiet */
+}
+
+static void
+_cleanupLibTiff( TIFF *tiff )
+{
+ if (tiff->tif_cleanup)
+ tiff->tif_cleanup(tiff);
+
+ if (tiff->tif_fieldinfo)
+ free(tiff->tif_fieldinfo);
+}
+
+int
+ImagingLibTiffInit(ImagingCodecState state, int compression, int fillorder, int count)
+{
+ TIFF *tiff = &((TIFFSTATE *) state->context)->tiff;
+ const TIFFCodec *codec;
+
+ TIFFSetErrorHandler(_errorHandler);
+ TIFFSetWarningHandler(_errorHandler);
+
+ codec = TIFFFindCODEC((uint16) compression);
+ if (codec == NULL)
+ return 0;
+
+ _TIFFmemset(tiff, 0, sizeof (*tiff));
+ _TIFFSetDefaultCompressionState(tiff);
+ TIFFDefaultDirectory(tiff);
+
+ tiff->tif_mode = O_RDONLY;
+ tiff->tif_dir.td_fillorder = (uint16) fillorder;
+ tiff->tif_dir.td_compression = (uint16) compression;
+
+ ((TIFFSTATE *) state->context)->count = count;
+
+ if (! codec->init(tiff, 0)) {
+ _cleanupLibTiff(tiff);
+ return 0;
+ }
+
+ return 1;
+}
+
+void
+ImagingLibTiffCleanup(ImagingCodecState state)
+{
+ _cleanupLibTiff( &((TIFFSTATE *) state->context)->tiff );
+}
+
+int
+ImagingLibTiffDecode(Imaging im, ImagingCodecState state, UINT8* buffer, int bytes)
+{
+ TIFF *tiff = &((TIFFSTATE *) state->context)->tiff;
+ int count = ((TIFFSTATE *) state->context)->count;
+ int savecc;
+ UINT8 saveds[DECODER_STATE_SIZE];
+
+ if (bytes < count)
+ return 0;
+
+ if ((tiff->tif_flags & TIFF_CODERSETUP) == 0) {
+ tiff->tif_dir.td_bitspersample = 1;
+ tiff->tif_dir.td_imagewidth = state->xsize;
+ tiff->tif_scanlinesize = TIFFScanlineSize(tiff);
+
+ if (! tiff->tif_setupdecode(tiff) || ! tiff->tif_predecode(tiff, 0)) {
+ state->errcode = IMAGING_CODEC_BROKEN;
+ return -1;
+ }
+
+ tiff->tif_flags |= TIFF_CODERSETUP;
+ }
+
+ tiff->tif_row = state->y + state->yoff;
+ tiff->tif_rawcp = buffer;
+ tiff->tif_rawcc = bytes;
+
+ TRACE(("decoding %d bytes, row %d\n", bytes, tiff->tif_row));
+ for (;;) {
+ if (count < 0) {
+ savecc = tiff->tif_rawcc;
+ memcpy(saveds, DECODER_STATE(tiff), DECODER_STATE_SIZE);
+ }
+
+ if (tiff->tif_decoderow(tiff, (tidata_t) state->buffer,
+ tiff->tif_scanlinesize, 0) < 0) {
+ TRACE(("decode error, %d bytes left\n", tiff->tif_rawcc));
+ if (count < 0)
+ break;
+ state->errcode = IMAGING_CODEC_BROKEN;
+ return -1;
+ }
+
+ if (count < 0 && tiff->tif_rawcc <= 0) {
+ TRACE(("not enough data\n"));
+ break;
+ }
+
+ tiff->tif_postdecode(tiff, (tidata_t) buffer, tiff->tif_scanlinesize);
+
+ state->shuffle((UINT8*) im->image[state->y + state->yoff] +
+ state->xoff * im->pixelsize, state->buffer,
+ state->xsize);
+
+ TRACE(("decoded row %d, %d bytes left\n", tiff->tif_row, tiff->tif_rawcc));
+ tiff->tif_row++;
+ state->y++;
+
+ if (state->y >= state->ysize) {
+ TRACE(("decoded %d rows\n", state->y));
+ return -1; /* errcode = 0 */
+ }
+ }
+
+ memcpy(DECODER_STATE(tiff), saveds, DECODER_STATE_SIZE);
+
+ TRACE(("decoded %d rows, %d bytes left\n", state->y, savecc));
+ return bytes - savecc;
+}
+
+#endif
--- Imaging-1.1.6.orig/setup.py 2006-12-03 07:37:29.000000000 -0400
+++ Imaging-1.1.6/setup.py 2007-06-26 02:49:51.000000000 -0400
@@ -62,8 +62,8 @@
"Convert", "ConvertYCbCr", "Copy", "Crc32", "Crop", "Dib", "Draw",
"Effects", "EpsEncode", "File", "Fill", "Filter", "FliDecode",
"Geometry", "GetBBox", "GifDecode", "GifEncode", "HexDecode",
- "Histo", "JpegDecode", "JpegEncode", "LzwDecode", "Matrix",
- "ModeFilter", "MspDecode", "Negative", "Offset", "Pack",
+ "Histo", "JpegDecode", "JpegEncode", "TiffDecode", "LzwDecode",
+ "Matrix", "ModeFilter", "MspDecode", "Negative", "Offset", "Pack",
"PackDecode", "Palette", "Paste", "Quant", "QuantHash",
"QuantHeap", "PcdDecode", "PcxDecode", "PcxEncode", "Point",
"RankFilter", "RawDecode", "RawEncode", "Storage", "SunRleDecode",
@@ -276,6 +276,9 @@
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
+ if feature.tiff:
+ libs.append(feature.tiff)
+ defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1")[0] == 1:
@@ -297,11 +300,6 @@
define_macros=defs
))
- if os.path.isfile("_imagingtiff.c") and feature.tiff:
- exts.append(Extension(
- "_imagingtiff", ["_imagingtiff.c"], libraries=["tiff"]
- ))
-
if sys.platform == "darwin":
# locate Tcl/Tk frameworks
frameworks = []
@@ -364,7 +362,7 @@
(feature.tcl and feature.tk, "TKINTER"),
(feature.jpeg, "JPEG"),
(feature.zlib, "ZLIB (PNG/ZIP)"),
- # (feature.tiff, "experimental TIFF G3/G4 read"),
+ (feature.tiff, "experimental TIFF G3/G4 read"),
(feature.freetype, "FREETYPE2"),
]
--- Imaging-1.1.6.orig/libImaging/tiffiop.h 2007-06-27 02:24:16.000000000 -0400
+++ Imaging-1.1.6/libImaging/tiffiop.h 2007-06-26 01:59:18.000000000 -0400
@@ -0,0 +1,323 @@
+/* $Id: tiffiop.h,v 1.46 2006/03/16 12:22:27 dron Exp $ */
+
+/*
+ * Copyright (c) 1988-1997 Sam Leffler
+ * Copyright (c) 1991-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _TIFFIOP_
+#define _TIFFIOP_
+/*
+ * ``Library-private'' definitions.
+ */
+
+#include "tif_config.h"
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+
+#ifdef HAVE_ASSERT_H
+# include <assert.h>
+#else
+# define assert(x)
+#endif
+
+#ifdef HAVE_SEARCH_H
+# include <search.h>
+#else
+extern void *lfind(const void *, const void *, size_t *, size_t,
+ int (*)(const void *, const void *));
+#endif
+
+#include "tiffio.h"
+#include "tif_dir.h"
+
+#ifndef STRIP_SIZE_DEFAULT
+# define STRIP_SIZE_DEFAULT 8192
+#endif
+
+#define streq(a,b) (strcmp(a,b) == 0)
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+typedef struct client_info {
+ struct client_info *next;
+ void *data;
+ char *name;
+} TIFFClientInfoLink;
+
+/*
+ * Typedefs for ``method pointers'' used internally.
+ */
+typedef unsigned char tidataval_t; /* internal image data value type */
+typedef tidataval_t* tidata_t; /* reference to internal image data */
+
+typedef void (*TIFFVoidMethod)(TIFF*);
+typedef int (*TIFFBoolMethod)(TIFF*);
+typedef int (*TIFFPreMethod)(TIFF*, tsample_t);
+typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t);
+typedef int (*TIFFSeekMethod)(TIFF*, uint32);
+typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t);
+typedef uint32 (*TIFFStripMethod)(TIFF*, uint32);
+typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*);
+
+struct tiff {
+ char* tif_name; /* name of open file */
+ int tif_fd; /* open file descriptor */
+ int tif_mode; /* open mode (O_*) */
+ uint32 tif_flags;
+#define TIFF_FILLORDER 0x0003 /* natural bit fill order for machine */
+#define TIFF_DIRTYHEADER 0x0004 /* header must be written on close */
+#define TIFF_DIRTYDIRECT 0x0008 /* current directory must be written */
+#define TIFF_BUFFERSETUP 0x0010 /* data buffers setup */
+#define TIFF_CODERSETUP 0x0020 /* encoder/decoder setup done */
+#define TIFF_BEENWRITING 0x0040 /* written 1+ scanlines to file */
+#define TIFF_SWAB 0x0080 /* byte swap file information */
+#define TIFF_NOBITREV 0x0100 /* inhibit bit reversal logic */
+#define TIFF_MYBUFFER 0x0200 /* my raw data buffer; free on close */
+#define TIFF_ISTILED 0x0400 /* file is tile, not strip- based */
+#define TIFF_MAPPED 0x0800 /* file is mapped into memory */
+#define TIFF_POSTENCODE 0x1000 /* need call to postencode routine */
+#define TIFF_INSUBIFD 0x2000 /* currently writing a subifd */
+#define TIFF_UPSAMPLED 0x4000 /* library is doing data up-sampling */
+#define TIFF_STRIPCHOP 0x8000 /* enable strip chopping support */
+#define TIFF_HEADERONLY 0x10000 /* read header only, do not process */
+ /* the first directory */
+ toff_t tif_diroff; /* file offset of current directory */
+ toff_t tif_nextdiroff; /* file offset of following directory */
+ toff_t* tif_dirlist; /* list of offsets to already seen */
+ /* directories to prevent IFD looping */
+ uint16 tif_dirnumber; /* number of already seen directories */
+ TIFFDirectory tif_dir; /* internal rep of current directory */
+ TIFFHeader tif_header; /* file's header block */
+ const int* tif_typeshift; /* data type shift counts */
+ const long* tif_typemask; /* data type masks */
+ uint32 tif_row; /* current scanline */
+ tdir_t tif_curdir; /* current directory (index) */
+ tstrip_t tif_curstrip; /* current strip for read/write */
+ toff_t tif_curoff; /* current offset for read/write */
+ toff_t tif_dataoff; /* current offset for writing dir */
+/* SubIFD support */
+ uint16 tif_nsubifd; /* remaining subifds to write */
+ toff_t tif_subifdoff; /* offset for patching SubIFD link */
+/* tiling support */
+ uint32 tif_col; /* current column (offset by row too) */
+ ttile_t tif_curtile; /* current tile for read/write */
+ tsize_t tif_tilesize; /* # of bytes in a tile */
+/* compression scheme hooks */
+ int tif_decodestatus;
+ TIFFBoolMethod tif_setupdecode;/* called once before predecode */
+ TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
+ TIFFBoolMethod tif_setupencode;/* called once before preencode */
+ int tif_encodestatus;
+ TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
+ TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
+ TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
+ TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
+ TIFFCodeMethod tif_decodestrip;/* strip decoding routine */
+ TIFFCodeMethod tif_encodestrip;/* strip encoding routine */
+ TIFFCodeMethod tif_decodetile; /* tile decoding routine */
+ TIFFCodeMethod tif_encodetile; /* tile encoding routine */
+ TIFFVoidMethod tif_close; /* cleanup-on-close routine */
+ TIFFSeekMethod tif_seek; /* position within a strip routine */
+ TIFFVoidMethod tif_cleanup; /* cleanup state routine */
+ TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */
+ TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */
+ tidata_t tif_data; /* compression scheme private data */
+/* input/output buffering */
+ tsize_t tif_scanlinesize;/* # of bytes in a scanline */
+ tsize_t tif_scanlineskew;/* scanline skew for reading strips */
+ tidata_t tif_rawdata; /* raw data buffer */
+ tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */
+ tidata_t tif_rawcp; /* current spot in raw buffer */
+ tsize_t tif_rawcc; /* bytes unread from raw buffer */
+/* memory-mapped file support */
+ tidata_t tif_base; /* base of mapped file */
+ toff_t tif_size; /* size of mapped file region (bytes) */
+ TIFFMapFileProc tif_mapproc; /* map file method */
+ TIFFUnmapFileProc tif_unmapproc;/* unmap file method */
+/* input/output callback methods */
+ thandle_t tif_clientdata; /* callback parameter */
+ TIFFReadWriteProc tif_readproc; /* read method */
+ TIFFReadWriteProc tif_writeproc;/* write method */
+ TIFFSeekProc tif_seekproc; /* lseek method */
+ TIFFCloseProc tif_closeproc; /* close method */
+ TIFFSizeProc tif_sizeproc; /* filesize method */
+/* post-decoding support */
+ TIFFPostMethod tif_postdecode; /* post decoding routine */
+/* tag support */
+ TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */
+ size_t tif_nfields; /* # entries in registered tag table */
+ const TIFFFieldInfo *tif_foundfield;/* cached pointer to already found tag */
+ TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */
+ TIFFClientInfoLink *tif_clientinfo; /* extra client information. */
+};
+
+#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
+
+#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
+#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
+#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
+#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
+#define TIFFReadFile(tif, buf, size) \
+ ((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size))
+#define TIFFWriteFile(tif, buf, size) \
+ ((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size))
+#define TIFFSeekFile(tif, off, whence) \
+ ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence))
+#define TIFFCloseFile(tif) \
+ ((*(tif)->tif_closeproc)((tif)->tif_clientdata))
+#define TIFFGetFileSize(tif) \
+ ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
+#define TIFFMapFileContents(tif, paddr, psize) \
+ ((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize))
+#define TIFFUnmapFileContents(tif, addr, size) \
+ ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size))
+
+/*
+ * Default Read/Seek/Write definitions.
+ */
+#ifndef ReadOK
+#define ReadOK(tif, buf, size) \
+ (TIFFReadFile(tif, (tdata_t) buf, (tsize_t)(size)) == (tsize_t)(size))
+#endif
+#ifndef SeekOK
+#define SeekOK(tif, off) \
+ (TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off)
+#endif
+#ifndef WriteOK
+#define WriteOK(tif, buf, size) \
+ (TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size)
+#endif
+
+/* NB: the uint32 casts are to silence certain ANSI-C compilers */
+#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y)))
+#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
+#define TIFFroundup(x, y) (TIFFhowmany(x,y)*(y))
+
+#define TIFFmax(A,B) ((A)>(B)?(A):(B))
+#define TIFFmin(A,B) ((A)<(B)?(A):(B))
+
+#define TIFFArrayCount(a) (sizeof (a) / sizeof ((a)[0]))
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+extern int _TIFFgetMode(const char*, const char*);
+extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t);
+extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t);
+extern int _TIFFNoPreCode (TIFF*, tsample_t);
+extern int _TIFFNoSeek(TIFF*, uint32);
+extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t);
+extern void _TIFFSwab24BitData(TIFF*, tidata_t, tsize_t);
+extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t);
+extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t);
+extern int TIFFFlushData1(TIFF*);
+extern int TIFFDefaultDirectory(TIFF*);
+extern void _TIFFSetDefaultCompressionState(TIFF*);
+extern int TIFFSetCompressionScheme(TIFF*, int);
+extern int TIFFSetDefaultCompressionState(TIFF*);
+extern uint32 _TIFFDefaultStripSize(TIFF*, uint32);
+extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
+extern int _TIFFDataSize(TIFFDataType);
+
+extern void _TIFFsetByteArray(void**, void*, uint32);
+extern void _TIFFsetString(char**, char*);
+extern void _TIFFsetShortArray(uint16**, uint16*, uint32);
+extern void _TIFFsetLongArray(uint32**, uint32*, uint32);
+extern void _TIFFsetFloatArray(float**, float*, uint32);
+extern void _TIFFsetDoubleArray(double**, double*, uint32);
+
+extern void _TIFFprintAscii(FILE*, const char*);
+extern void _TIFFprintAsciiTag(FILE*, const char*, const char*);
+
+extern TIFFErrorHandler _TIFFwarningHandler;
+extern TIFFErrorHandler _TIFFerrorHandler;
+extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
+extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
+
+extern tdata_t _TIFFCheckMalloc(TIFF*, size_t, size_t, const char*);
+
+extern int TIFFInitDumpMode(TIFF*, int);
+#ifdef PACKBITS_SUPPORT
+extern int TIFFInitPackBits(TIFF*, int);
+#endif
+#ifdef CCITT_SUPPORT
+extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int);
+extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int);
+#endif
+#ifdef THUNDER_SUPPORT
+extern int TIFFInitThunderScan(TIFF*, int);
+#endif
+#ifdef NEXT_SUPPORT
+extern int TIFFInitNeXT(TIFF*, int);
+#endif
+#ifdef LZW_SUPPORT
+extern int TIFFInitLZW(TIFF*, int);
+#endif
+#ifdef OJPEG_SUPPORT
+extern int TIFFInitOJPEG(TIFF*, int);
+#endif
+#ifdef JPEG_SUPPORT
+extern int TIFFInitJPEG(TIFF*, int);
+#endif
+#ifdef JBIG_SUPPORT
+extern int TIFFInitJBIG(TIFF*, int);
+#endif
+#ifdef ZIP_SUPPORT
+extern int TIFFInitZIP(TIFF*, int);
+#endif
+#ifdef PIXARLOG_SUPPORT
+extern int TIFFInitPixarLog(TIFF*, int);
+#endif
+#ifdef LOGLUV_SUPPORT
+extern int TIFFInitSGILog(TIFF*, int);
+#endif
+#ifdef VMS
+extern const TIFFCodec _TIFFBuiltinCODECS[];
+#else
+extern TIFFCodec _TIFFBuiltinCODECS[];
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+#endif /* _TIFFIOP_ */
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
--- Imaging-1.1.6.orig/libImaging/tif_dir.h 2007-06-27 02:24:21.000000000 -0400
+++ Imaging-1.1.6/libImaging/tif_dir.h 2007-06-26 02:00:28.000000000 -0400
@@ -0,0 +1,199 @@
+/* $Id: tif_dir.h,v 1.28 2005/12/26 14:31:25 dron Exp $ */
+
+/*
+ * Copyright (c) 1988-1997 Sam Leffler
+ * Copyright (c) 1991-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _TIFFDIR_
+#define _TIFFDIR_
+/*
+ * ``Library-private'' Directory-related Definitions.
+ */
+
+/*
+ * Internal format of a TIFF directory entry.
+ */
+typedef struct {
+#define FIELD_SETLONGS 4
+ /* bit vector of fields that are set */
+ unsigned long td_fieldsset[FIELD_SETLONGS];
+
+ uint32 td_imagewidth, td_imagelength, td_imagedepth;
+ uint32 td_tilewidth, td_tilelength, td_tiledepth;
+ uint32 td_subfiletype;
+ uint16 td_bitspersample;
+ uint16 td_sampleformat;
+ uint16 td_compression;
+ uint16 td_photometric;
+ uint16 td_threshholding;
+ uint16 td_fillorder;
+ uint16 td_orientation;
+ uint16 td_samplesperpixel;
+ uint32 td_rowsperstrip;
+ uint16 td_minsamplevalue, td_maxsamplevalue;
+ double td_sminsamplevalue, td_smaxsamplevalue;
+ float td_xresolution, td_yresolution;
+ uint16 td_resolutionunit;
+ uint16 td_planarconfig;
+ float td_xposition, td_yposition;
+ uint16 td_pagenumber[2];
+ uint16* td_colormap[3];
+ uint16 td_halftonehints[2];
+ uint16 td_extrasamples;
+ uint16* td_sampleinfo;
+ tstrip_t td_stripsperimage;
+ tstrip_t td_nstrips; /* size of offset & bytecount arrays */
+ uint32* td_stripoffset;
+ uint32* td_stripbytecount;
+ int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
+ uint16 td_nsubifd;
+ uint32* td_subifd;
+ /* YCbCr parameters */
+ uint16 td_ycbcrsubsampling[2];
+ uint16 td_ycbcrpositioning;
+ /* Colorimetry parameters */
+ uint16* td_transferfunction[3];
+ /* CMYK parameters */
+ int td_inknameslen;
+ char* td_inknames;
+
+ int td_customValueCount;
+ TIFFTagValue *td_customValues;
+} TIFFDirectory;
+
+/*
+ * Field flags used to indicate fields that have
+ * been set in a directory, and to reference fields
+ * when manipulating a directory.
+ */
+
+/*
+ * FIELD_IGNORE is used to signify tags that are to
+ * be processed but otherwise ignored. This permits
+ * antiquated tags to be quietly read and discarded.
+ * Note that a bit *is* allocated for ignored tags;
+ * this is understood by the directory reading logic
+ * which uses this fact to avoid special-case handling
+ */
+#define FIELD_IGNORE 0
+
+/* multi-item fields */
+#define FIELD_IMAGEDIMENSIONS 1
+#define FIELD_TILEDIMENSIONS 2
+#define FIELD_RESOLUTION 3
+#define FIELD_POSITION 4
+
+/* single-item fields */
+#define FIELD_SUBFILETYPE 5
+#define FIELD_BITSPERSAMPLE 6
+#define FIELD_COMPRESSION 7
+#define FIELD_PHOTOMETRIC 8
+#define FIELD_THRESHHOLDING 9
+#define FIELD_FILLORDER 10
+#define FIELD_ORIENTATION 15
+#define FIELD_SAMPLESPERPIXEL 16
+#define FIELD_ROWSPERSTRIP 17
+#define FIELD_MINSAMPLEVALUE 18
+#define FIELD_MAXSAMPLEVALUE 19
+#define FIELD_PLANARCONFIG 20
+#define FIELD_RESOLUTIONUNIT 22
+#define FIELD_PAGENUMBER 23
+#define FIELD_STRIPBYTECOUNTS 24
+#define FIELD_STRIPOFFSETS 25
+#define FIELD_COLORMAP 26
+#define FIELD_EXTRASAMPLES 31
+#define FIELD_SAMPLEFORMAT 32
+#define FIELD_SMINSAMPLEVALUE 33
+#define FIELD_SMAXSAMPLEVALUE 34
+#define FIELD_IMAGEDEPTH 35
+#define FIELD_TILEDEPTH 36
+#define FIELD_HALFTONEHINTS 37
+#define FIELD_YCBCRSUBSAMPLING 39
+#define FIELD_YCBCRPOSITIONING 40
+#define FIELD_TRANSFERFUNCTION 44
+#define FIELD_INKNAMES 46
+#define FIELD_SUBIFD 49
+/* FIELD_CUSTOM (see tiffio.h) 65 */
+/* end of support for well-known tags; codec-private tags follow */
+#define FIELD_CODEC 66 /* base of codec-private tags */
+
+
+/*
+ * Pseudo-tags don't normally need field bits since they
+ * are not written to an output file (by definition).
+ * The library also has express logic to always query a
+ * codec for a pseudo-tag so allocating a field bit for
+ * one is a waste. If codec wants to promote the notion
+ * of a pseudo-tag being ``set'' or ``unset'' then it can
+ * do using internal state flags without polluting the
+ * field bit space defined for real tags.
+ */
+#define FIELD_PSEUDO 0
+
+#define FIELD_LAST (32*FIELD_SETLONGS-1)
+
+#define TIFFExtractData(tif, type, v) \
+ ((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \
+ ((v) >> (tif)->tif_typeshift[type]) & (tif)->tif_typemask[type] : \
+ (v) & (tif)->tif_typemask[type]))
+#define TIFFInsertData(tif, type, v) \
+ ((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \
+ ((v) & (tif)->tif_typemask[type]) << (tif)->tif_typeshift[type] : \
+ (v) & (tif)->tif_typemask[type]))
+
+
+#define BITn(n) (((unsigned long)1L)<<((n)&0x1f))
+#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32])
+#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
+#define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field))
+#define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field))
+
+#define FieldSet(fields, f) (fields[(f)/32] & BITn(f))
+#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f))
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+extern const TIFFFieldInfo *_TIFFGetFieldInfo(size_t *);
+extern const TIFFFieldInfo *_TIFFGetExifFieldInfo(size_t *);
+extern void _TIFFSetupFieldInfo(TIFF*, const TIFFFieldInfo[], size_t);
+extern void _TIFFPrintFieldInfo(TIFF*, FILE*);
+extern TIFFDataType _TIFFSampleToTagType(TIFF*);
+extern const TIFFFieldInfo* _TIFFFindOrRegisterFieldInfo( TIFF *tif,
+ ttag_t tag,
+ TIFFDataType dt );
+extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag,
+ TIFFDataType dt );
+
+#define _TIFFMergeFieldInfo TIFFMergeFieldInfo
+#define _TIFFFindFieldInfo TIFFFindFieldInfo
+#define _TIFFFindFieldInfoByName TIFFFindFieldInfoByName
+#define _TIFFFieldWithTag TIFFFieldWithTag
+#define _TIFFFieldWithName TIFFFieldWithName
+
+#if defined(__cplusplus)
+}
+#endif
+#endif /* _TIFFDIR_ */
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
--- Imaging-1.1.6.orig/libImaging/tif_config.h 2007-06-27 02:24:26.000000000 -0400
+++ Imaging-1.1.6/libImaging/tif_config.h 2007-06-26 02:20:43.000000000 -0400
@@ -0,0 +1,261 @@
+/* libtiff/tif_config.h. Generated by configure. */
+/* libtiff/tif_config.h.in. Generated from configure.ac by autoheader. */
+
+/* Support CCITT Group 3 & 4 algorithms */
+#define CCITT_SUPPORT 1
+
+/* Pick up YCbCr subsampling info from the JPEG data stream to support files
+ lacking the tag (default enabled). */
+#define CHECK_JPEG_YCBCR_SUBSAMPLING 1
+
+/* Support C++ stream API (requires C++ compiler) */
+#define CXX_SUPPORT 1
+
+/* Treat extra sample as alpha (default enabled). The RGBA interface will
+ treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many
+ packages produce RGBA files but don't mark the alpha properly. */
+#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1
+
+/* Use the Apple OpenGL framework. */
+/* #undef HAVE_APPLE_OPENGL_FRAMEWORK */
+
+/* Define to 1 if you have the <assert.h> header file. */
+#define HAVE_ASSERT_H 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `floor' function. */
+#define HAVE_FLOOR 1
+
+/* Define to 1 if you have the `getopt' function. */
+#define HAVE_GETOPT 1
+
+/* Define as 0 or 1 according to the floating point format suported by the
+ machine */
+#define HAVE_IEEEFP 1
+
+/* Define to 1 if the system has the type `int16'. */
+/* #undef HAVE_INT16 */
+
+/* Define to 1 if the system has the type `int32'. */
+/* #undef HAVE_INT32 */
+
+/* Define to 1 if the system has the type `int8'. */
+/* #undef HAVE_INT8 */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `isascii' function. */
+#define HAVE_ISASCII 1
+
+/* Define to 1 if you have the `lfind' function. */
+#define HAVE_LFIND 1
+
+/* Define to 1 if you have the `c' library (-lc). */
+#define HAVE_LIBC 1
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
+
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `memset' function. */
+#define HAVE_MEMSET 1
+
+/* Define to 1 if you have the `mmap' function. */
+#define HAVE_MMAP 1
+
+/* Define to 1 if you have the `pow' function. */
+#define HAVE_POW 1
+
+/* Define if you have POSIX threads libraries and header files. */
+#define HAVE_PTHREAD 1
+
+/* Define to 1 if you have the <search.h> header file. */
+#define HAVE_SEARCH_H 1
+
+/* Define to 1 if you have the `sqrt' function. */
+#define HAVE_SQRT 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strcasecmp' function. */
+#define HAVE_STRCASECMP 1
+
+/* Define to 1 if you have the `strchr' function. */
+#define HAVE_STRCHR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strrchr' function. */
+#define HAVE_STRRCHR 1
+
+/* Define to 1 if you have the `strstr' function. */
+#define HAVE_STRSTR 1
+
+/* Define to 1 if you have the `strtol' function. */
+#define HAVE_STRTOL 1
+
+/* Define to 1 if you have the `strtoul' function. */
+#define HAVE_STRTOUL 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <windows.h> header file. */
+/* #undef HAVE_WINDOWS_H */
+
+/* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
+ (Intel) */
+#define HOST_BIGENDIAN 0
+
+/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
+#define HOST_FILLORDER FILLORDER_LSB2MSB
+
+/* Support JPEG compression (requires IJG JPEG library) */
+#define JPEG_SUPPORT 1
+
+/* Support LogLuv high dynamic range encoding */
+#define LOGLUV_SUPPORT 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+ */
+#define LT_OBJDIR ".libs/"
+
+/* Support LZW algorithm */
+#define LZW_SUPPORT 1
+
+/* Support Microsoft Document Imaging format */
+#define MDI_SUPPORT 1
+
+/* Support NeXT 2-bit RLE algorithm */
+#define NEXT_SUPPORT 1
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
+
+/* Support Old JPEG compresson (read contrib/ojpeg/README first! Compilation
+ fails with unpatched IJG JPEG library) */
+/* #undef OJPEG_SUPPORT */
+
+/* Name of package */
+#define PACKAGE "tiff"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "[EMAIL PROTECTED]"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "LibTIFF Software"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "LibTIFF Software 3.8.2"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "tiff"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "3.8.2"
+
+/* Support Macintosh PackBits algorithm */
+#define PACKBITS_SUPPORT 1
+
+/* Support Pixar log-format algorithm (requires Zlib) */
+#define PIXARLOG_SUPPORT 1
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+ your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* The size of a `int', as computed by sizeof. */
+#define SIZEOF_INT 4
+
+/* The size of a `long', as computed by sizeof. */
+#define SIZEOF_LONG 4
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Support strip chopping (whether or not to convert single-strip uncompressed
+ images to mutiple strips of specified size to reduce memory usage) */
+#define STRIPCHOP_DEFAULT TIFF_STRIPCHOP
+
+/* Default size of the strip in bytes (when strip chopping enabled) */
+#define STRIP_SIZE_DEFAULT 8192
+
+/* Enable SubIFD tag (330) support */
+#define SUBIFD_SUPPORT 1
+
+/* Support ThunderScan 4-bit RLE algorithm */
+#define THUNDER_SUPPORT 1
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#define TIME_WITH_SYS_TIME 1
+
+/* Define to 1 if your <sys/time.h> declares `struct tm'. */
+/* #undef TM_IN_SYS_TIME */
+
+/* Version number of package */
+#define VERSION "3.8.2"
+
+/* Define to 1 if your processor stores words with the most significant byte
+ first (like Motorola and SPARC, unlike Intel and VAX). */
+/* #undef WORDS_BIGENDIAN */
+
+/* Define to 1 if the X Window System is missing or not being used. */
+/* #undef X_DISPLAY_MISSING */
+
+/* Support Deflate compression */
+#define ZIP_SUPPORT 1
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+#define _FILE_OFFSET_BITS 64
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+ calls it, or to nothing if 'inline' is not supported under any name. */
+#ifndef __cplusplus
+/* #undef inline */
+#endif
+
+/* Define to `long' if <sys/types.h> does not define. */
+/* #undef off_t */
+
+/* Define to `unsigned' if <sys/types.h> does not define. */
+/* #undef size_t */
_______________________________________________
Image-SIG maillist - Image-SIG@python.org
http://mail.python.org/mailman/listinfo/image-sig
