laag-libtiff 4.0.9.0

data/vendor/gitlab.com/libtiff/libtiff/tools/tiffdither.c

@@ -0,0 +1,347 @@
+/* $Id: tiffdither.c,v 1.16 2015-06-21 01:09:11 bfriesen 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.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffio.h"
+#include "tiffiop.h"
+
+#define	streq(a,b)	(strcmp(a,b) == 0)
+#define	strneq(a,b,n)	(strncmp(a,b,n) == 0)
+
+#define	CopyField(tag, v) \
+	if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+
+uint32	imagewidth;
+uint32	imagelength;
+int	threshold = 128;
+
+static	void usage(void);
+
+/* 
+ * Floyd-Steinberg error propragation with threshold.
+ * This code is stolen from tiffmedian.
+ */
+static int
+fsdither(TIFF* in, TIFF* out)
+{
+	unsigned char *outline, *inputline, *inptr;
+	short *thisline, *nextline, *tmpptr;
+	register unsigned char	*outptr;
+	register short *thisptr, *nextptr;
+	register uint32 i, j;
+	uint32 imax, jmax;
+	int lastline, lastpixel;
+	int bit;
+	tsize_t outlinesize;
+	int errcode = 0;
+
+	imax = imagelength - 1;
+	jmax = imagewidth - 1;
+	inputline = (unsigned char *)_TIFFmalloc(TIFFScanlineSize(in));
+	thisline = (short *)_TIFFmalloc(TIFFSafeMultiply(tmsize_t, imagewidth, sizeof (short)));
+	nextline = (short *)_TIFFmalloc(TIFFSafeMultiply(tmsize_t, imagewidth, sizeof (short)));
+	outlinesize = TIFFScanlineSize(out);
+	outline = (unsigned char *) _TIFFmalloc(outlinesize);
+	if (! (inputline && thisline && nextline && outline)) {
+	    fprintf(stderr, "Out of memory.\n");
+	    goto skip_on_error;
+	}
+
+	/*
+	 * Get first line
+	 */
+	if (TIFFReadScanline(in, inputline, 0, 0) <= 0)
+            goto skip_on_error;
+
+	inptr = inputline;
+	nextptr = nextline;
+	for (j = 0; j < imagewidth; ++j)
+		*nextptr++ = *inptr++;
+	for (i = 1; i < imagelength; ++i) {
+		tmpptr = thisline;
+		thisline = nextline;
+		nextline = tmpptr;
+		lastline = (i == imax);
+		if (TIFFReadScanline(in, inputline, i, 0) <= 0)
+			goto skip_on_error;
+		inptr = inputline;
+		nextptr = nextline;
+		for (j = 0; j < imagewidth; ++j)
+			*nextptr++ = *inptr++;
+		thisptr = thisline;
+		nextptr = nextline;
+		_TIFFmemset(outptr = outline, 0, outlinesize);
+		bit = 0x80;
+		for (j = 0; j < imagewidth; ++j) {
+			register int v;
+
+			lastpixel = (j == jmax);
+			v = *thisptr++;
+			if (v < 0)
+				v = 0;
+			else if (v > 255)
+				v = 255;
+			if (v > threshold) {
+				*outptr |= bit;
+				v -= 255;
+			}
+			bit >>= 1;
+			if (bit == 0) {
+				outptr++;
+				bit = 0x80;
+			}
+			if (!lastpixel)
+				thisptr[0] += v * 7 / 16;
+			if (!lastline) {
+				if (j != 0)
+					nextptr[-1] += v * 3 / 16;
+				*nextptr++ += v * 5 / 16;
+				if (!lastpixel)
+					nextptr[0] += v / 16;
+			}
+		}
+		if (TIFFWriteScanline(out, outline, i-1, 0) < 0)
+			goto skip_on_error;
+	}
+	goto exit_label;
+
+  skip_on_error:
+	errcode = 1;
+  exit_label:
+	_TIFFfree(inputline);
+	_TIFFfree(thisline);
+	_TIFFfree(nextline);
+	_TIFFfree(outline);
+	return errcode;
+}
+
+static	uint16 compression = COMPRESSION_PACKBITS;
+static	uint16 predictor = 0;
+static	uint32 group3options = 0;
+
+static void
+processG3Options(char* cp)
+{
+	if ((cp = strchr(cp, ':'))) {
+		do {
+			cp++;
+			if (strneq(cp, "1d", 2))
+				group3options &= ~GROUP3OPT_2DENCODING;
+			else if (strneq(cp, "2d", 2))
+				group3options |= GROUP3OPT_2DENCODING;
+			else if (strneq(cp, "fill", 4))
+				group3options |= GROUP3OPT_FILLBITS;
+			else
+				usage();
+		} while ((cp = strchr(cp, ':')));
+	}
+}
+
+static int
+processCompressOptions(char* opt)
+{
+	if (streq(opt, "none"))
+		compression = COMPRESSION_NONE;
+	else if (streq(opt, "packbits"))
+		compression = COMPRESSION_PACKBITS;
+	else if (strneq(opt, "g3", 2)) {
+		processG3Options(opt);
+		compression = COMPRESSION_CCITTFAX3;
+	} else if (streq(opt, "g4"))
+		compression = COMPRESSION_CCITTFAX4;
+	else if (strneq(opt, "lzw", 3)) {
+		char* cp = strchr(opt, ':');
+		if (cp)
+			predictor = atoi(cp+1);
+		compression = COMPRESSION_LZW;
+	} else if (strneq(opt, "zip", 3)) {
+		char* cp = strchr(opt, ':');
+		if (cp)
+			predictor = atoi(cp+1);
+		compression = COMPRESSION_DEFLATE;
+	} else
+		return (0);
+	return (1);
+}
+
+int
+main(int argc, char* argv[])
+{
+	TIFF *in, *out;
+	uint16 samplesperpixel, bitspersample = 1, shortv;
+	float floatv;
+	char thing[1024];
+	uint32 rowsperstrip = (uint32) -1;
+	uint16 fillorder = 0;
+	int c;
+#if !HAVE_DECL_OPTARG
+	extern int optind;
+	extern char *optarg;
+#endif
+
+	while ((c = getopt(argc, argv, "c:f:r:t:")) != -1)
+		switch (c) {
+		case 'c':		/* compression scheme */
+			if (!processCompressOptions(optarg))
+				usage();
+			break;
+		case 'f':		/* fill order */
+			if (streq(optarg, "lsb2msb"))
+				fillorder = FILLORDER_LSB2MSB;
+			else if (streq(optarg, "msb2lsb"))
+				fillorder = FILLORDER_MSB2LSB;
+			else
+				usage();
+			break;
+		case 'r':		/* rows/strip */
+			rowsperstrip = atoi(optarg);
+			break;
+		case 't':
+			threshold = atoi(optarg);
+			if (threshold < 0)
+				threshold = 0;
+			else if (threshold > 255)
+				threshold = 255;
+			break;
+		case '?':
+			usage();
+			/*NOTREACHED*/
+		}
+	if (argc - optind < 2)
+		usage();
+	in = TIFFOpen(argv[optind], "r");
+	if (in == NULL)
+		return (-1);
+	TIFFGetField(in, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
+	if (samplesperpixel != 1) {
+		fprintf(stderr, "%s: Not a b&w image.\n", argv[0]);
+		return (-1);
+	}
+	TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
+	if (bitspersample != 8) {
+		fprintf(stderr,
+		    " %s: Sorry, only handle 8-bit samples.\n", argv[0]);
+		return (-1);
+	}
+	out = TIFFOpen(argv[optind+1], "w");
+	if (out == NULL)
+		return (-1);
+	CopyField(TIFFTAG_IMAGEWIDTH, imagewidth);
+	TIFFGetField(in, TIFFTAG_IMAGELENGTH, &imagelength);
+	TIFFSetField(out, TIFFTAG_IMAGELENGTH, imagelength-1);
+	TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 1);
+	TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 1);
+	TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+	TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
+	if (fillorder)
+		TIFFSetField(out, TIFFTAG_FILLORDER, fillorder);
+	else
+		CopyField(TIFFTAG_FILLORDER, shortv);
+	snprintf(thing, sizeof(thing), "Dithered B&W version of %s", argv[optind]);
+	TIFFSetField(out, TIFFTAG_IMAGEDESCRIPTION, thing);
+	CopyField(TIFFTAG_PHOTOMETRIC, shortv);
+	CopyField(TIFFTAG_ORIENTATION, shortv);
+	CopyField(TIFFTAG_XRESOLUTION, floatv);
+	CopyField(TIFFTAG_YRESOLUTION, floatv);
+	CopyField(TIFFTAG_RESOLUTIONUNIT, shortv);
+        rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip);
+	TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
+	switch (compression) {
+	case COMPRESSION_CCITTFAX3:
+		TIFFSetField(out, TIFFTAG_GROUP3OPTIONS, group3options);
+		break;
+	case COMPRESSION_LZW:
+	case COMPRESSION_DEFLATE:
+		if (predictor)
+			TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
+		break;
+	}
+	fsdither(in, out);
+	TIFFClose(in);
+	TIFFClose(out);
+	return (0);
+}
+
+char* stuff[] = {
+"usage: tiffdither [options] input.tif output.tif",
+"where options are:",
+" -r #		make each strip have no more than # rows",
+" -t #		set the threshold value for dithering (default 128)",
+" -f lsb2msb	force lsb-to-msb FillOrder for output",
+" -f msb2lsb	force msb-to-lsb FillOrder for output",
+" -c lzw[:opts]	compress output with Lempel-Ziv & Welch encoding",
+" -c zip[:opts]	compress output with deflate encoding",
+" -c packbits	compress output with packbits encoding",
+" -c g3[:opts]	compress output with CCITT Group 3 encoding",
+" -c g4		compress output with CCITT Group 4 encoding",
+" -c none	use no compression algorithm on output",
+"",
+"Group 3 options:",
+" 1d		use default CCITT Group 3 1D-encoding",
+" 2d		use optional CCITT Group 3 2D-encoding",
+" fill		byte-align EOL codes",
+"For example, -c g3:2d:fill to get G3-2D-encoded data with byte-aligned EOLs",
+"",
+"LZW and deflate options:",
+" #		set predictor value",
+"For example, -c lzw:2 to get LZW-encoded data with horizontal differencing",
+NULL
+};
+
+static void
+usage(void)
+{
+	char buf[BUFSIZ];
+	int i;
+
+	setbuf(stderr, buf);
+        fprintf(stderr, "%s\n\n", TIFFGetVersion());
+	for (i = 0; stuff[i] != NULL; i++)
+		fprintf(stderr, "%s\n", stuff[i]);
+	exit(-1);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */

data/vendor/gitlab.com/libtiff/libtiff/tools/tiffdump.c

@@ -0,0 +1,889 @@
+/* $Id: tiffdump.c,v 1.35 2016-11-19 15:42:46 bfriesen 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.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include "tiffiop.h"
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#ifdef HAVE_IO_H
+# include <io.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#ifndef HAVE_GETOPT
+extern int getopt(int, char**, char*);
+#endif
+
+#include "tiffio.h"
+
+#ifndef O_BINARY
+# define O_BINARY	0
+#endif
+
+static union
+{
+	TIFFHeaderClassic classic;
+	TIFFHeaderBig big;
+	TIFFHeaderCommon common;
+} hdr;
+char* appname;
+char* curfile;
+int swabflag;
+int bigendian;
+int bigtiff;
+uint32 maxitems = 24;   /* maximum indirect data items to print */
+
+const char* bytefmt = "%s%#02x";	/* BYTE */
+const char* sbytefmt = "%s%d";		/* SBYTE */
+const char* shortfmt = "%s%u";		/* SHORT */
+const char* sshortfmt = "%s%d";		/* SSHORT */
+const char* longfmt = "%s%lu";		/* LONG */
+const char* slongfmt = "%s%ld";		/* SLONG */
+const char* ifdfmt = "%s%#04lx";	/* IFD offset */
+#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
+const char* long8fmt = "%s%I64u";	/* LONG8 */
+const char* slong8fmt = "%s%I64d";	/* SLONG8 */
+const char* ifd8fmt = "%s%#08I64x";	/* IFD offset8*/
+#else
+const char* long8fmt = "%s%llu";	/* LONG8 */
+const char* slong8fmt = "%s%lld";	/* SLONG8 */
+const char* ifd8fmt = "%s%#08llx";	/* IFD offset8*/
+#endif
+const char* rationalfmt = "%s%g";	/* RATIONAL */
+const char* srationalfmt = "%s%g";	/* SRATIONAL */
+const char* floatfmt = "%s%g";		/* FLOAT */
+const char* doublefmt = "%s%g";		/* DOUBLE */
+
+static void dump(int, uint64);
+
+#if !HAVE_DECL_OPTARG
+extern int optind;
+extern char* optarg;
+#endif
+
+void
+usage()
+{
+	fprintf(stderr, "usage: %s [-h] [-o offset] [-m maxitems] file.tif ...\n", appname);
+	exit(-1);
+}
+
+int
+main(int argc, char* argv[])
+{
+	int one = 1, fd;
+	int multiplefiles = (argc > 1);
+	int c;
+	uint64 diroff = 0;
+	bigendian = (*(char *)&one == 0);
+
+	appname = argv[0];
+	while ((c = getopt(argc, argv, "m:o:h")) != -1) {
+		switch (c) {
+		case 'h':			/* print values in hex */
+			shortfmt = "%s%#x";
+			sshortfmt = "%s%#x";
+			longfmt = "%s%#lx";
+			slongfmt = "%s%#lx";
+			break;
+		case 'o':
+			diroff = (uint64) strtoul(optarg, NULL, 0);
+			break;
+		case 'm':
+			maxitems = strtoul(optarg, NULL, 0);
+			break;
+		default:
+			usage();
+		}
+	}
+	if (optind >= argc)
+		usage();
+	for (; optind < argc; optind++) {
+		fd = open(argv[optind], O_RDONLY|O_BINARY, 0);
+		if (fd < 0) {
+			perror(argv[0]);
+			return (-1);
+		}
+		if (multiplefiles)
+			printf("%s:\n", argv[optind]);
+		curfile = argv[optind];
+		swabflag = 0;
+		bigtiff = 0;
+		dump(fd, diroff);
+		close(fd);
+	}
+	return (0);
+}
+
+#define ord(e) ((int)e)
+
+static uint64 ReadDirectory(int, unsigned, uint64);
+static void ReadError(char*);
+static void Error(const char*, ...);
+static void Fatal(const char*, ...);
+
+static void
+dump(int fd, uint64 diroff)
+{
+	unsigned i, j;
+	uint64* visited_diroff = NULL;
+	unsigned int count_visited_dir = 0;
+
+	_TIFF_lseek_f(fd, (_TIFF_off_t) 0, 0);
+	if (read(fd, (char*) &hdr, sizeof (TIFFHeaderCommon)) != sizeof (TIFFHeaderCommon))
+		ReadError("TIFF header");
+	if (hdr.common.tiff_magic != TIFF_BIGENDIAN
+	    && hdr.common.tiff_magic != TIFF_LITTLEENDIAN &&
+#if HOST_BIGENDIAN
+	    /* MDI is sensitive to the host byte order, unlike TIFF */
+	    MDI_BIGENDIAN != hdr.common.tiff_magic
+#else
+	    MDI_LITTLEENDIAN != hdr.common.tiff_magic
+#endif
+	   ) {
+		Fatal("Not a TIFF or MDI file, bad magic number %u (%#x)",
+		    hdr.common.tiff_magic, hdr.common.tiff_magic);
+	}
+	if (hdr.common.tiff_magic == TIFF_BIGENDIAN
+	    || hdr.common.tiff_magic == MDI_BIGENDIAN)
+		swabflag = !bigendian;
+	else
+		swabflag = bigendian;
+	if (swabflag)
+		TIFFSwabShort(&hdr.common.tiff_version);
+	if (hdr.common.tiff_version==42)
+	{
+		if (read(fd, (char*) &hdr.classic.tiff_diroff, 4) != 4)
+			ReadError("TIFF header");
+		if (swabflag)
+			TIFFSwabLong(&hdr.classic.tiff_diroff);
+		printf("Magic: %#x <%s-endian> Version: %#x <%s>\n",
+		    hdr.classic.tiff_magic,
+		    hdr.classic.tiff_magic == TIFF_BIGENDIAN ? "big" : "little",
+		    42,"ClassicTIFF");
+		if (diroff == 0)
+			diroff = hdr.classic.tiff_diroff;
+	}
+	else if (hdr.common.tiff_version==43)
+	{
+		if (read(fd, (char*) &hdr.big.tiff_offsetsize, 12) != 12)
+			ReadError("TIFF header");
+		if (swabflag)
+		{
+			TIFFSwabShort(&hdr.big.tiff_offsetsize);
+			TIFFSwabShort(&hdr.big.tiff_unused);
+			TIFFSwabLong8(&hdr.big.tiff_diroff);
+		}
+		printf("Magic: %#x <%s-endian> Version: %#x <%s>\n",
+		    hdr.big.tiff_magic,
+		    hdr.big.tiff_magic == TIFF_BIGENDIAN ? "big" : "little",
+		    43,"BigTIFF");
+		printf("OffsetSize: %#x Unused: %#x\n",
+		    hdr.big.tiff_offsetsize,hdr.big.tiff_unused);
+		if (diroff == 0)
+			diroff = hdr.big.tiff_diroff;
+		bigtiff = 1;
+	}
+	else
+		Fatal("Not a TIFF file, bad version number %u (%#x)",
+		    hdr.common.tiff_version, hdr.common.tiff_version);
+	for (i = 0; diroff != 0; i++) {
+		for(j=0; j<count_visited_dir; j++)
+		{
+		    if( visited_diroff[j] == diroff )
+		    {
+			free(visited_diroff);
+			Fatal("Cycle detected in chaining of TIFF directories!");
+		    }
+		}
+                {
+                    size_t alloc_size;
+                    alloc_size=TIFFSafeMultiply(tmsize_t,(count_visited_dir + 1),
+                                                sizeof(uint64));
+                    if (alloc_size == 0)
+                    {
+                        if (visited_diroff)
+                            free(visited_diroff);
+                        visited_diroff = 0;
+                    }
+                    else
+                    {
+                        visited_diroff = (uint64*) realloc(visited_diroff,alloc_size);
+                    }
+                }
+		if( !visited_diroff )
+		    Fatal("Out of memory");
+		visited_diroff[count_visited_dir] = diroff;
+		count_visited_dir ++;
+
+		if (i > 0)
+			putchar('\n');
+		diroff = ReadDirectory(fd, i, diroff);
+	}
+	if( visited_diroff )
+	    free(visited_diroff);
+}
+
+static const int datawidth[] = {
+	0, /* 00 = undefined */
+	1, /* 01 = TIFF_BYTE */
+	1, /* 02 = TIFF_ASCII */
+	2, /* 03 = TIFF_SHORT */
+	4, /* 04 = TIFF_LONG */
+	8, /* 05 = TIFF_RATIONAL */
+	1, /* 06 = TIFF_SBYTE */
+	1, /* 07 = TIFF_UNDEFINED */
+	2, /* 08 = TIFF_SSHORT */
+	4, /* 09 = TIFF_SLONG */
+	8, /* 10 = TIFF_SRATIONAL */
+	4, /* 11 = TIFF_FLOAT */
+	8, /* 12 = TIFF_DOUBLE */
+	4, /* 13 = TIFF_IFD */
+	0, /* 14 = undefined */
+	0, /* 15 = undefined */
+	8, /* 16 = TIFF_LONG8 */
+	8, /* 17 = TIFF_SLONG8 */
+	8, /* 18 = TIFF_IFD8 */
+};
+#define NWIDTHS (sizeof (datawidth) / sizeof (datawidth[0]))
+static void PrintTag(FILE*, uint16);
+static void PrintType(FILE*, uint16);
+static void PrintData(FILE*, uint16, uint32, unsigned char*);
+
+/*
+ * Read the next TIFF directory from a file
+ * and convert it to the internal format.
+ * We read directories sequentially.
+ */
+static uint64
+ReadDirectory(int fd, unsigned int ix, uint64 off)
+{
+	uint16 dircount;
+	uint32 direntrysize;
+	void* dirmem = NULL;
+	uint64 nextdiroff = 0;
+	uint32 n;
+	uint8* dp;
+
+	if (off == 0)			/* no more directories */
+		goto done;
+	if (_TIFF_lseek_f(fd, (_TIFF_off_t)off, SEEK_SET) != (_TIFF_off_t)off) {
+		Fatal("Seek error accessing TIFF directory");
+		goto done;
+	}
+	if (!bigtiff) {
+		if (read(fd, (char*) &dircount, sizeof (uint16)) != sizeof (uint16)) {
+			ReadError("directory count");
+			goto done;
+		}
+		if (swabflag)
+			TIFFSwabShort(&dircount);
+		direntrysize = 12;
+	} else {
+		uint64 dircount64 = 0;
+		if (read(fd, (char*) &dircount64, sizeof (uint64)) != sizeof (uint64)) {
+			ReadError("directory count");
+			goto done;
+		}
+		if (swabflag)
+			TIFFSwabLong8(&dircount64);
+		if (dircount64>0xFFFF) {
+			Error("Sanity check on directory count failed");
+			goto done;
+		}
+		dircount = (uint16)dircount64;
+		direntrysize = 20;
+	}
+	dirmem = _TIFFmalloc(TIFFSafeMultiply(tmsize_t,dircount,direntrysize));
+	if (dirmem == NULL) {
+		Fatal("No space for TIFF directory");
+		goto done;
+	}
+	n = read(fd, (char*) dirmem, dircount*direntrysize);
+	if (n != dircount*direntrysize) {
+		n /= direntrysize;
+		Error(
+#if defined(__WIN32__) && defined(_MSC_VER)
+	    "Could only read %lu of %u entries in directory at offset %#I64x",
+		      (unsigned long)n, dircount, (unsigned __int64) off);
+#else
+	    "Could only read %lu of %u entries in directory at offset %#llx",
+		      (unsigned long)n, dircount, (unsigned long long) off);
+#endif
+		dircount = n;
+		nextdiroff = 0;
+	} else {
+		if (!bigtiff) {
+			uint32 nextdiroff32;
+			if (read(fd, (char*) &nextdiroff32, sizeof (uint32)) != sizeof (uint32))
+				nextdiroff32 = 0;
+			if (swabflag)
+				TIFFSwabLong(&nextdiroff32);
+			nextdiroff = nextdiroff32;
+		} else {
+			if (read(fd, (char*) &nextdiroff, sizeof (uint64)) != sizeof (uint64))
+				nextdiroff = 0;
+			if (swabflag)
+				TIFFSwabLong8(&nextdiroff);
+		}
+	}
+#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
+	printf("Directory %u: offset %I64u (%#I64x) next %I64u (%#I64x)\n", ix,
+	    (unsigned __int64)off, (unsigned __int64)off,
+	    (unsigned __int64)nextdiroff, (unsigned __int64)nextdiroff);
+#else
+	printf("Directory %u: offset %llu (%#llx) next %llu (%#llx)\n", ix,
+	    (unsigned long long)off, (unsigned long long)off,
+	    (unsigned long long)nextdiroff, (unsigned long long)nextdiroff);
+#endif
+	for (dp = (uint8*)dirmem, n = dircount; n > 0; n--) {
+		uint16 tag;
+		uint16 type;
+		uint16 typewidth;
+		uint64 count;
+		uint64 datasize;
+		int datafits;
+		void* datamem;
+		uint64 dataoffset;
+		int datatruncated;
+                int datasizeoverflow;
+
+		tag = *(uint16*)dp;
+		if (swabflag)
+			TIFFSwabShort(&tag);
+		dp += sizeof(uint16);
+		type = *(uint16*)dp;
+		dp += sizeof(uint16);
+		if (swabflag)
+			TIFFSwabShort(&type);
+		PrintTag(stdout, tag);
+		putchar(' ');
+		PrintType(stdout, type);
+		putchar(' ');
+		if (!bigtiff)
+		{
+			uint32 count32;
+			count32 = *(uint32*)dp;
+			if (swabflag)
+				TIFFSwabLong(&count32);
+			dp += sizeof(uint32);
+			count = count32;
+		}
+		else
+		{
+			memcpy(&count, dp, sizeof(uint64));
+			if (swabflag)
+				TIFFSwabLong8(&count);
+			dp += sizeof(uint64);
+		}
+#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
+		printf("%I64u<", (unsigned __int64)count);
+#else
+		printf("%llu<", (unsigned long long)count);
+#endif
+		if (type >= NWIDTHS)
+			typewidth = 0;
+		else
+			typewidth = datawidth[type];
+		datasize = TIFFSafeMultiply(tmsize_t,count,typewidth);
+                datasizeoverflow = (typewidth > 0 && datasize / typewidth != count);
+		datafits = 1;
+		datamem = dp;
+		dataoffset = 0;
+		datatruncated = 0;
+		if (!bigtiff)
+		{
+			if (datasizeoverflow || datasize>4)
+			{
+				uint32 dataoffset32;
+				datafits = 0;
+				datamem = NULL;
+				dataoffset32 = *(uint32*)dp;
+				if (swabflag)
+					TIFFSwabLong(&dataoffset32);
+				dataoffset = dataoffset32;
+			}
+			dp += sizeof(uint32);
+		}
+		else
+		{
+			if (datasizeoverflow || datasize>8)
+			{
+				datafits = 0;
+				datamem = NULL;
+				dataoffset = *(uint64*)dp;
+				if (swabflag)
+					TIFFSwabLong8(&dataoffset);
+			}
+			dp += sizeof(uint64);
+		}
+		if (datasizeoverflow || datasize>0x10000)
+		{
+			datatruncated = 1;
+			count = 0x10000/typewidth;
+			datasize = TIFFSafeMultiply(tmsize_t,count,typewidth);
+		}
+		if (count>maxitems)
+		{
+			datatruncated = 1;
+			count = maxitems;
+                        datasize = TIFFSafeMultiply(tmsize_t,count,typewidth);
+		}
+		if (!datafits)
+		{
+			datamem = _TIFFmalloc(datasize);
+			if (datamem) {
+				if (_TIFF_lseek_f(fd, (_TIFF_off_t)dataoffset, 0) !=
+				    (_TIFF_off_t)dataoffset)
+				{
+					Error(
+				"Seek error accessing tag %u value", tag);
+					_TIFFfree(datamem);
+					datamem = NULL;
+				}
+				else if (read(fd, datamem, (size_t)datasize) != (TIFF_SSIZE_T)datasize)
+				{
+					Error(
+				"Read error accessing tag %u value", tag);
+					_TIFFfree(datamem);
+					datamem = NULL;
+				}
+			} else
+				Error("No space for data for tag %u",tag);
+		}
+		if (datamem)
+		{
+			if (swabflag)
+			{
+				switch (type)
+				{
+					case TIFF_BYTE:
+					case TIFF_ASCII:
+					case TIFF_SBYTE:
+					case TIFF_UNDEFINED:
+						break;
+					case TIFF_SHORT:
+					case TIFF_SSHORT:
+						TIFFSwabArrayOfShort((uint16*)datamem,(tmsize_t)count);
+						break;
+					case TIFF_LONG:
+					case TIFF_SLONG:
+					case TIFF_FLOAT:
+					case TIFF_IFD:
+						TIFFSwabArrayOfLong((uint32*)datamem,(tmsize_t)count);
+						break;
+					case TIFF_RATIONAL:
+					case TIFF_SRATIONAL:
+						TIFFSwabArrayOfLong((uint32*)datamem,(tmsize_t)count*2);
+						break;
+					case TIFF_DOUBLE:
+					case TIFF_LONG8:
+					case TIFF_SLONG8:
+					case TIFF_IFD8:
+						TIFFSwabArrayOfLong8((uint64*)datamem,(tmsize_t)count);
+						break;
+				}
+			}
+			PrintData(stdout,type,(uint32)count,datamem);
+			if (datatruncated)
+				printf(" ...");
+			if (!datafits)
+                                {
+                                        _TIFFfree(datamem);
+                                        datamem = NULL;
+                                }
+		}
+		printf(">\n");
+	}
+done:
+	if (dirmem)
+		_TIFFfree((char *)dirmem);
+	return (nextdiroff);
+}
+
+static const struct tagname {
+	uint16 tag;
+	const char* name;
+} tagnames[] = {
+    { TIFFTAG_SUBFILETYPE,	"SubFileType" },
+    { TIFFTAG_OSUBFILETYPE,	"OldSubFileType" },
+    { TIFFTAG_IMAGEWIDTH,	"ImageWidth" },
+    { TIFFTAG_IMAGELENGTH,	"ImageLength" },
+    { TIFFTAG_BITSPERSAMPLE,	"BitsPerSample" },
+    { TIFFTAG_COMPRESSION,	"Compression" },
+    { TIFFTAG_PHOTOMETRIC,	"Photometric" },
+    { TIFFTAG_THRESHHOLDING,	"Threshholding" },
+    { TIFFTAG_CELLWIDTH,	"CellWidth" },
+    { TIFFTAG_CELLLENGTH,	"CellLength" },
+    { TIFFTAG_FILLORDER,	"FillOrder" },
+    { TIFFTAG_DOCUMENTNAME,	"DocumentName" },
+    { TIFFTAG_IMAGEDESCRIPTION,	"ImageDescription" },
+    { TIFFTAG_MAKE,		"Make" },
+    { TIFFTAG_MODEL,		"Model" },
+    { TIFFTAG_STRIPOFFSETS,	"StripOffsets" },
+    { TIFFTAG_ORIENTATION,	"Orientation" },
+    { TIFFTAG_SAMPLESPERPIXEL,	"SamplesPerPixel" },
+    { TIFFTAG_ROWSPERSTRIP,	"RowsPerStrip" },
+    { TIFFTAG_STRIPBYTECOUNTS,	"StripByteCounts" },
+    { TIFFTAG_MINSAMPLEVALUE,	"MinSampleValue" },
+    { TIFFTAG_MAXSAMPLEVALUE,	"MaxSampleValue" },
+    { TIFFTAG_XRESOLUTION,	"XResolution" },
+    { TIFFTAG_YRESOLUTION,	"YResolution" },
+    { TIFFTAG_PLANARCONFIG,	"PlanarConfig" },
+    { TIFFTAG_PAGENAME,		"PageName" },
+    { TIFFTAG_XPOSITION,	"XPosition" },
+    { TIFFTAG_YPOSITION,	"YPosition" },
+    { TIFFTAG_FREEOFFSETS,	"FreeOffsets" },
+    { TIFFTAG_FREEBYTECOUNTS,	"FreeByteCounts" },
+    { TIFFTAG_GRAYRESPONSEUNIT,	"GrayResponseUnit" },
+    { TIFFTAG_GRAYRESPONSECURVE,"GrayResponseCurve" },
+    { TIFFTAG_GROUP3OPTIONS,	"Group3Options" },
+    { TIFFTAG_GROUP4OPTIONS,	"Group4Options" },
+    { TIFFTAG_RESOLUTIONUNIT,	"ResolutionUnit" },
+    { TIFFTAG_PAGENUMBER,	"PageNumber" },
+    { TIFFTAG_COLORRESPONSEUNIT,"ColorResponseUnit" },
+    { TIFFTAG_TRANSFERFUNCTION,	"TransferFunction" },
+    { TIFFTAG_SOFTWARE,		"Software" },
+    { TIFFTAG_DATETIME,		"DateTime" },
+    { TIFFTAG_ARTIST,		"Artist" },
+    { TIFFTAG_HOSTCOMPUTER,	"HostComputer" },
+    { TIFFTAG_PREDICTOR,	"Predictor" },
+    { TIFFTAG_WHITEPOINT,	"Whitepoint" },
+    { TIFFTAG_PRIMARYCHROMATICITIES,"PrimaryChromaticities" },
+    { TIFFTAG_COLORMAP,		"Colormap" },
+    { TIFFTAG_HALFTONEHINTS,	"HalftoneHints" },
+    { TIFFTAG_TILEWIDTH,	"TileWidth" },
+    { TIFFTAG_TILELENGTH,	"TileLength" },
+    { TIFFTAG_TILEOFFSETS,	"TileOffsets" },
+    { TIFFTAG_TILEBYTECOUNTS,	"TileByteCounts" },
+    { TIFFTAG_BADFAXLINES,	"BadFaxLines" },
+    { TIFFTAG_CLEANFAXDATA,	"CleanFaxData" },
+    { TIFFTAG_CONSECUTIVEBADFAXLINES, "ConsecutiveBadFaxLines" },
+    { TIFFTAG_SUBIFD,		"SubIFD" },
+    { TIFFTAG_INKSET,		"InkSet" },
+    { TIFFTAG_INKNAMES,		"InkNames" },
+    { TIFFTAG_NUMBEROFINKS,	"NumberOfInks" },
+    { TIFFTAG_DOTRANGE,		"DotRange" },
+    { TIFFTAG_TARGETPRINTER,	"TargetPrinter" },
+    { TIFFTAG_EXTRASAMPLES,	"ExtraSamples" },
+    { TIFFTAG_SAMPLEFORMAT,	"SampleFormat" },
+    { TIFFTAG_SMINSAMPLEVALUE,	"SMinSampleValue" },
+    { TIFFTAG_SMAXSAMPLEVALUE,	"SMaxSampleValue" },
+    { TIFFTAG_JPEGPROC,		"JPEGProcessingMode" },
+    { TIFFTAG_JPEGIFOFFSET,	"JPEGInterchangeFormat" },
+    { TIFFTAG_JPEGIFBYTECOUNT,	"JPEGInterchangeFormatLength" },
+    { TIFFTAG_JPEGRESTARTINTERVAL,"JPEGRestartInterval" },
+    { TIFFTAG_JPEGLOSSLESSPREDICTORS,"JPEGLosslessPredictors" },
+    { TIFFTAG_JPEGPOINTTRANSFORM,"JPEGPointTransform" },
+    { TIFFTAG_JPEGTABLES,       "JPEGTables" },
+    { TIFFTAG_JPEGQTABLES,	"JPEGQTables" },
+    { TIFFTAG_JPEGDCTABLES,	"JPEGDCTables" },
+    { TIFFTAG_JPEGACTABLES,	"JPEGACTables" },
+    { TIFFTAG_YCBCRCOEFFICIENTS,"YCbCrCoefficients" },
+    { TIFFTAG_YCBCRSUBSAMPLING,	"YCbCrSubsampling" },
+    { TIFFTAG_YCBCRPOSITIONING,	"YCbCrPositioning" },
+    { TIFFTAG_REFERENCEBLACKWHITE, "ReferenceBlackWhite" },
+    { TIFFTAG_REFPTS,		"IgReferencePoints (Island Graphics)" },
+    { TIFFTAG_REGIONTACKPOINT,	"IgRegionTackPoint (Island Graphics)" },
+    { TIFFTAG_REGIONWARPCORNERS,"IgRegionWarpCorners (Island Graphics)" },
+    { TIFFTAG_REGIONAFFINE,	"IgRegionAffine (Island Graphics)" },
+    { TIFFTAG_MATTEING,		"OBSOLETE Matteing (Silicon Graphics)" },
+    { TIFFTAG_DATATYPE,		"OBSOLETE DataType (Silicon Graphics)" },
+    { TIFFTAG_IMAGEDEPTH,	"ImageDepth (Silicon Graphics)" },
+    { TIFFTAG_TILEDEPTH,	"TileDepth (Silicon Graphics)" },
+    { 32768,			"OLD BOGUS Matteing tag" },
+    { TIFFTAG_COPYRIGHT,	"Copyright" },
+    { TIFFTAG_ICCPROFILE,	"ICC Profile" },
+    { TIFFTAG_JBIGOPTIONS,	"JBIG Options" },
+    { TIFFTAG_STONITS,		"StoNits" },
+};
+#define	NTAGS	(sizeof (tagnames) / sizeof (tagnames[0]))
+
+static void
+PrintTag(FILE* fd, uint16 tag)
+{
+	const struct tagname *tp;
+
+	for (tp = tagnames; tp < &tagnames[NTAGS]; tp++)
+		if (tp->tag == tag) {
+			fprintf(fd, "%s (%u)", tp->name, tag);
+			return;
+		}
+	fprintf(fd, "%u (%#x)", tag, tag);
+}
+
+static void
+PrintType(FILE* fd, uint16 type)
+{
+	static const char *typenames[] = {
+	    "0",
+	    "BYTE",
+	    "ASCII",
+	    "SHORT",
+	    "LONG",
+	    "RATIONAL",
+	    "SBYTE",
+	    "UNDEFINED",
+	    "SSHORT",
+	    "SLONG",
+	    "SRATIONAL",
+	    "FLOAT",
+	    "DOUBLE",
+	    "IFD",
+	    "14",
+	    "15",
+	    "LONG8",
+	    "SLONG8",
+	    "IFD8"
+	};
+#define	NTYPES	(sizeof (typenames) / sizeof (typenames[0]))
+
+	if (type < NTYPES)
+		fprintf(fd, "%s (%u)", typenames[type], type);
+	else
+		fprintf(fd, "%u (%#x)", type, type);
+}
+#undef	NTYPES
+
+#include <ctype.h>
+
+static void
+PrintASCII(FILE* fd, uint32 cc, const unsigned char* cp)
+{
+	for (; cc > 0; cc--, cp++) {
+		const char* tp;
+
+		if (isprint(*cp)) {
+			fputc(*cp, fd);
+			continue;
+		}
+		for (tp = "\tt\bb\rr\nn\vv"; *tp; tp++)
+			if (*tp++ == *cp)
+				break;
+		if (*tp)
+			fprintf(fd, "\\%c", *tp);
+		else if (*cp)
+			fprintf(fd, "\\%03o", *cp);
+		else
+			fprintf(fd, "\\0");
+	}
+}
+
+static void
+PrintData(FILE* fd, uint16 type, uint32 count, unsigned char* data)
+{
+	char* sep = "";
+
+	switch (type) {
+	case TIFF_BYTE:
+		while (count-- > 0)
+			fprintf(fd, bytefmt, sep, *data++), sep = " ";
+		break;
+	case TIFF_SBYTE:
+		while (count-- > 0)
+			fprintf(fd, sbytefmt, sep, *(char *)data++), sep = " ";
+		break;
+	case TIFF_UNDEFINED:
+		while (count-- > 0)
+			fprintf(fd, bytefmt, sep, *data++), sep = " ";
+		break;
+	case TIFF_ASCII:
+		PrintASCII(fd, count, data);
+		break;
+	case TIFF_SHORT: {
+		uint16 *wp = (uint16*)data;
+		while (count-- > 0)
+			fprintf(fd, shortfmt, sep, *wp++), sep = " ";
+		break;
+	}
+	case TIFF_SSHORT: {
+		int16 *wp = (int16*)data;
+		while (count-- > 0)
+			fprintf(fd, sshortfmt, sep, *wp++), sep = " ";
+		break;
+	}
+	case TIFF_LONG: {
+		uint32 *lp = (uint32*)data;
+		while (count-- > 0) {
+			fprintf(fd, longfmt, sep, (unsigned long) *lp++);
+			sep = " ";
+		}
+		break;
+	}
+	case TIFF_SLONG: {
+		int32 *lp = (int32*)data;
+		while (count-- > 0)
+			fprintf(fd, slongfmt, sep, (long) *lp++), sep = " ";
+		break;
+	}
+	case TIFF_LONG8: {
+		uint64 *llp = (uint64*)data;
+		while (count-- > 0) {
+                        uint64 val;
+                        memcpy(&val, llp, sizeof(uint64));
+                        llp ++;
+			fprintf(fd, long8fmt, sep, val);
+			sep = " ";
+		}
+		break;
+	}
+	case TIFF_SLONG8: {
+		int64 *llp = (int64*)data;
+		while (count-- > 0) {
+                        int64 val;
+                        memcpy(&val, llp, sizeof(int64));
+                        llp ++;
+                        fprintf(fd, slong8fmt, sep, val);
+                        sep = " ";
+                }
+		break;
+	}
+	case TIFF_RATIONAL: {
+		uint32 *lp = (uint32*)data;
+		while (count-- > 0) {
+			if (lp[1] == 0)
+				fprintf(fd, "%sNan (%lu/%lu)", sep,
+				    (unsigned long) lp[0],
+				    (unsigned long) lp[1]);
+			else
+				fprintf(fd, rationalfmt, sep,
+				    (double)lp[0] / (double)lp[1]);
+			sep = " ";
+			lp += 2;
+		}
+		break;
+	}
+	case TIFF_SRATIONAL: {
+		int32 *lp = (int32*)data;
+		while (count-- > 0) {
+			if (lp[1] == 0)
+				fprintf(fd, "%sNan (%ld/%ld)", sep,
+				    (long) lp[0], (long) lp[1]);
+			else
+				fprintf(fd, srationalfmt, sep,
+				    (double)lp[0] / (double)lp[1]);
+			sep = " ";
+			lp += 2;
+		}
+		break;
+	}
+	case TIFF_FLOAT: {
+		float *fp = (float *)data;
+		while (count-- > 0)
+			fprintf(fd, floatfmt, sep, *fp++), sep = " ";
+		break;
+	}
+	case TIFF_DOUBLE: {
+		double *dp = (double *)data;
+		while (count-- > 0)
+			fprintf(fd, doublefmt, sep, *dp++), sep = " ";
+		break;
+	}
+	case TIFF_IFD: {
+		uint32 *lp = (uint32*)data;
+		while (count-- > 0) {
+			fprintf(fd, ifdfmt, sep, (unsigned long) *lp++);
+			sep = " ";
+		}
+		break;
+	}
+	case TIFF_IFD8: {
+		uint64 *llp = (uint64*)data;
+		while (count-- > 0) {
+#if defined(__WIN32__) && defined(_MSC_VER)
+			fprintf(fd, ifd8fmt, sep, (unsigned __int64) *llp++);
+#else
+			fprintf(fd, ifd8fmt, sep, (unsigned long long) *llp++);
+#endif
+			sep = " ";
+		}
+		break;
+	}
+	}
+}
+
+static void
+ReadError(char* what)
+{
+	Fatal("Error while reading %s", what);
+}
+
+#include <stdarg.h>
+
+static void
+vError(FILE* fd, const char* fmt, va_list ap)
+{
+	fprintf(fd, "%s: ", curfile);
+	vfprintf(fd, fmt, ap);
+	fprintf(fd, ".\n");
+}
+
+static void
+Error(const char* fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	vError(stderr, fmt, ap);
+	va_end(ap);
+}
+
+static void
+Fatal(const char* fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	vError(stderr, fmt, ap);
+	va_end(ap);
+	exit(-1);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */