summaryrefslogtreecommitdiff
path: root/tiff/tools/tiffdump.c
diff options
context:
space:
mode:
Diffstat (limited to 'tiff/tools/tiffdump.c')
-rw-r--r--tiff/tools/tiffdump.c785
1 files changed, 785 insertions, 0 deletions
diff --git a/tiff/tools/tiffdump.c b/tiff/tools/tiffdump.c
new file mode 100644
index 0000000..5161189
--- /dev/null
+++ b/tiff/tools/tiffdump.c
@@ -0,0 +1,785 @@
+/* $Id: tiffdump.c,v 1.13.2.1 2010-06-08 18:50:44 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 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
+
+#include "tiffio.h"
+
+#ifndef O_BINARY
+# define O_BINARY 0
+#endif
+
+char* appname;
+char* curfile;
+int swabflag;
+int bigendian;
+int typeshift[14]; /* data type shift counts */
+long typemask[14]; /* data type masks */
+uint32 maxitems = 24; /* maximum indirect data items to print */
+
+char* bytefmt = "%s%#02x"; /* BYTE */
+char* sbytefmt = "%s%d"; /* SBYTE */
+char* shortfmt = "%s%u"; /* SHORT */
+char* sshortfmt = "%s%d"; /* SSHORT */
+char* longfmt = "%s%lu"; /* LONG */
+char* slongfmt = "%s%ld"; /* SLONG */
+char* rationalfmt = "%s%g"; /* RATIONAL */
+char* srationalfmt = "%s%g"; /* SRATIONAL */
+char* floatfmt = "%s%g"; /* FLOAT */
+char* doublefmt = "%s%g"; /* DOUBLE */
+char* ifdfmt = "%s%#04x"; /* IFD offset */
+
+static void dump(int, off_t);
+extern int optind;
+extern char* optarg;
+
+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;
+ uint32 diroff = (uint32) 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 = (uint32) 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;
+ dump(fd, diroff);
+ close(fd);
+ }
+ return (0);
+}
+
+static TIFFHeader hdr;
+
+#define ord(e) ((int)e)
+
+/*
+ * Initialize shift & mask tables and byte
+ * swapping state according to the file
+ * byte order.
+ */
+static void
+InitByteOrder(int magic)
+{
+ typemask[0] = 0;
+ typemask[ord(TIFF_BYTE)] = 0xff;
+ typemask[ord(TIFF_SBYTE)] = 0xff;
+ typemask[ord(TIFF_UNDEFINED)] = 0xff;
+ typemask[ord(TIFF_SHORT)] = 0xffff;
+ typemask[ord(TIFF_SSHORT)] = 0xffff;
+ typemask[ord(TIFF_LONG)] = 0xffffffff;
+ typemask[ord(TIFF_SLONG)] = 0xffffffff;
+ typemask[ord(TIFF_IFD)] = 0xffffffff;
+ typemask[ord(TIFF_RATIONAL)] = 0xffffffff;
+ typemask[ord(TIFF_SRATIONAL)] = 0xffffffff;
+ typemask[ord(TIFF_FLOAT)] = 0xffffffff;
+ typemask[ord(TIFF_DOUBLE)] = 0xffffffff;
+ typeshift[0] = 0;
+ typeshift[ord(TIFF_LONG)] = 0;
+ typeshift[ord(TIFF_SLONG)] = 0;
+ typeshift[ord(TIFF_IFD)] = 0;
+ typeshift[ord(TIFF_RATIONAL)] = 0;
+ typeshift[ord(TIFF_SRATIONAL)] = 0;
+ typeshift[ord(TIFF_FLOAT)] = 0;
+ typeshift[ord(TIFF_DOUBLE)] = 0;
+ if (magic == TIFF_BIGENDIAN || magic == MDI_BIGENDIAN) {
+ typeshift[ord(TIFF_BYTE)] = 24;
+ typeshift[ord(TIFF_SBYTE)] = 24;
+ typeshift[ord(TIFF_SHORT)] = 16;
+ typeshift[ord(TIFF_SSHORT)] = 16;
+ swabflag = !bigendian;
+ } else {
+ typeshift[ord(TIFF_BYTE)] = 0;
+ typeshift[ord(TIFF_SBYTE)] = 0;
+ typeshift[ord(TIFF_SHORT)] = 0;
+ typeshift[ord(TIFF_SSHORT)] = 0;
+ swabflag = bigendian;
+ }
+}
+
+static off_t ReadDirectory(int, unsigned, off_t);
+static void ReadError(char*);
+static void Error(const char*, ...);
+static void Fatal(const char*, ...);
+
+static void
+dump(int fd, off_t diroff)
+{
+ unsigned i;
+
+ lseek(fd, (off_t) 0, 0);
+ if (read(fd, (char*) &hdr, sizeof (hdr)) != sizeof (hdr))
+ ReadError("TIFF header");
+ /*
+ * Setup the byte order handling.
+ */
+ if (hdr.tiff_magic != TIFF_BIGENDIAN && hdr.tiff_magic != TIFF_LITTLEENDIAN &&
+#if HOST_BIGENDIAN
+ // MDI is sensitive to the host byte order, unlike TIFF
+ MDI_BIGENDIAN != hdr.tiff_magic )
+#else
+ MDI_LITTLEENDIAN != hdr.tiff_magic )
+#endif
+ Fatal("Not a TIFF or MDI file, bad magic number %u (%#x)",
+ hdr.tiff_magic, hdr.tiff_magic);
+ InitByteOrder(hdr.tiff_magic);
+ /*
+ * Swap header if required.
+ */
+ if (swabflag) {
+ TIFFSwabShort(&hdr.tiff_version);
+ TIFFSwabLong(&hdr.tiff_diroff);
+ }
+ /*
+ * Now check version (if needed, it's been byte-swapped).
+ * Note that this isn't actually a version number, it's a
+ * magic number that doesn't change (stupid).
+ */
+ if (hdr.tiff_version != TIFF_VERSION)
+ Fatal("Not a TIFF file, bad version number %u (%#x)",
+ hdr.tiff_version, hdr.tiff_version);
+ printf("Magic: %#x <%s-endian> Version: %#x\n",
+ hdr.tiff_magic,
+ hdr.tiff_magic == TIFF_BIGENDIAN ? "big" : "little",
+ hdr.tiff_version);
+ if (diroff == 0)
+ diroff = hdr.tiff_diroff;
+ for (i = 0; diroff != 0; i++) {
+ if (i > 0)
+ putchar('\n');
+ diroff = ReadDirectory(fd, i, diroff);
+ }
+}
+
+static int datawidth[] = {
+ 0, /* nothing */
+ 1, /* TIFF_BYTE */
+ 1, /* TIFF_ASCII */
+ 2, /* TIFF_SHORT */
+ 4, /* TIFF_LONG */
+ 8, /* TIFF_RATIONAL */
+ 1, /* TIFF_SBYTE */
+ 1, /* TIFF_UNDEFINED */
+ 2, /* TIFF_SSHORT */
+ 4, /* TIFF_SLONG */
+ 8, /* TIFF_SRATIONAL */
+ 4, /* TIFF_FLOAT */
+ 8, /* TIFF_DOUBLE */
+ 4 /* TIFF_IFD */
+};
+#define NWIDTHS (sizeof (datawidth) / sizeof (datawidth[0]))
+static int TIFFFetchData(int, TIFFDirEntry*, void*);
+static void PrintTag(FILE*, uint16);
+static void PrintType(FILE*, uint16);
+static void PrintData(FILE*, uint16, uint32, unsigned char*);
+static void PrintByte(FILE*, const char*, TIFFDirEntry*);
+static void PrintShort(FILE*, const char*, TIFFDirEntry*);
+static void PrintLong(FILE*, const char*, TIFFDirEntry*);
+
+/*
+ * Read the next TIFF directory from a file
+ * and convert it to the internal format.
+ * We read directories sequentially.
+ */
+static off_t
+ReadDirectory(int fd, unsigned ix, off_t off)
+{
+ register TIFFDirEntry *dp;
+ register unsigned int n;
+ TIFFDirEntry *dir = 0;
+ uint16 dircount;
+ int space;
+ uint32 nextdiroff = 0;
+
+ if (off == 0) /* no more directories */
+ goto done;
+ if (lseek(fd, (off_t) off, 0) != off) {
+ Fatal("Seek error accessing TIFF directory");
+ goto done;
+ }
+ if (read(fd, (char*) &dircount, sizeof (uint16)) != sizeof (uint16)) {
+ ReadError("directory count");
+ goto done;
+ }
+ if (swabflag)
+ TIFFSwabShort(&dircount);
+ dir = (TIFFDirEntry *)_TIFFmalloc(dircount * sizeof (TIFFDirEntry));
+ if (dir == NULL) {
+ Fatal("No space for TIFF directory");
+ goto done;
+ }
+ n = read(fd, (char*) dir, dircount*sizeof (*dp));
+ if (n != dircount*sizeof (*dp)) {
+ n /= sizeof (*dp);
+ Error(
+ "Could only read %u of %u entries in directory at offset %#lx",
+ n, dircount, (unsigned long) off);
+ dircount = n;
+ }
+ if (read(fd, (char*) &nextdiroff, sizeof (uint32)) != sizeof (uint32))
+ nextdiroff = 0;
+ if (swabflag)
+ TIFFSwabLong(&nextdiroff);
+ printf("Directory %u: offset %lu (%#lx) next %lu (%#lx)\n", ix,
+ (unsigned long)off, (unsigned long)off,
+ (unsigned long)nextdiroff, (unsigned long)nextdiroff);
+ for (dp = dir, n = dircount; n > 0; n--, dp++) {
+ if (swabflag) {
+ TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
+ TIFFSwabArrayOfLong(&dp->tdir_count, 2);
+ }
+ PrintTag(stdout, dp->tdir_tag);
+ putchar(' ');
+ PrintType(stdout, dp->tdir_type);
+ putchar(' ');
+ printf("%lu<", (unsigned long) dp->tdir_count);
+ if (dp->tdir_type >= NWIDTHS) {
+ printf(">\n");
+ continue;
+ }
+ space = dp->tdir_count * datawidth[dp->tdir_type];
+ if (space <= 0) {
+ printf(">\n");
+ Error("Invalid count for tag %u", dp->tdir_tag);
+ continue;
+ }
+ if (space <= 4) {
+ switch (dp->tdir_type) {
+ case TIFF_FLOAT:
+ case TIFF_UNDEFINED:
+ case TIFF_ASCII: {
+ unsigned char data[4];
+ _TIFFmemcpy(data, &dp->tdir_offset, 4);
+ if (swabflag)
+ TIFFSwabLong((uint32*) data);
+ PrintData(stdout,
+ dp->tdir_type, dp->tdir_count, data);
+ break;
+ }
+ case TIFF_BYTE:
+ PrintByte(stdout, bytefmt, dp);
+ break;
+ case TIFF_SBYTE:
+ PrintByte(stdout, sbytefmt, dp);
+ break;
+ case TIFF_SHORT:
+ PrintShort(stdout, shortfmt, dp);
+ break;
+ case TIFF_SSHORT:
+ PrintShort(stdout, sshortfmt, dp);
+ break;
+ case TIFF_LONG:
+ PrintLong(stdout, longfmt, dp);
+ break;
+ case TIFF_SLONG:
+ PrintLong(stdout, slongfmt, dp);
+ break;
+ case TIFF_IFD:
+ PrintLong(stdout, ifdfmt, dp);
+ break;
+ }
+ } else {
+ unsigned char *data = (unsigned char *)_TIFFmalloc(space);
+ if (data) {
+ if (TIFFFetchData(fd, dp, data)) {
+ if (dp->tdir_count > maxitems) {
+ PrintData(stdout, dp->tdir_type,
+ maxitems, data);
+ printf(" ...");
+ } else
+ PrintData(stdout, dp->tdir_type,
+ dp->tdir_count, data);
+ }
+ _TIFFfree(data);
+ } else
+ Error("No space for data for tag %u",
+ dp->tdir_tag);
+ }
+ printf(">\n");
+ }
+done:
+ if (dir)
+ _TIFFfree((char *)dir);
+ return (nextdiroff);
+}
+
+static struct tagname {
+ uint16 tag;
+ 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)
+{
+ register 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 char *typenames[] = {
+ "0",
+ "BYTE",
+ "ASCII",
+ "SHORT",
+ "LONG",
+ "RATIONAL",
+ "SBYTE",
+ "UNDEFINED",
+ "SSHORT",
+ "SLONG",
+ "SRATIONAL",
+ "FLOAT",
+ "DOUBLE"
+ };
+#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
+
+static void
+PrintByte(FILE* fd, const char* fmt, TIFFDirEntry* dp)
+{
+ char* sep = "";
+
+ if (hdr.tiff_magic == TIFF_BIGENDIAN) {
+ switch ((int)dp->tdir_count) {
+ case 4: fprintf(fd, fmt, sep, dp->tdir_offset&0xff);
+ sep = " ";
+ case 3: fprintf(fd, fmt, sep, (dp->tdir_offset>>8)&0xff);
+ sep = " ";
+ case 2: fprintf(fd, fmt, sep, (dp->tdir_offset>>16)&0xff);
+ sep = " ";
+ case 1: fprintf(fd, fmt, sep, dp->tdir_offset>>24);
+ }
+ } else {
+ switch ((int)dp->tdir_count) {
+ case 4: fprintf(fd, fmt, sep, dp->tdir_offset>>24);
+ sep = " ";
+ case 3: fprintf(fd, fmt, sep, (dp->tdir_offset>>16)&0xff);
+ sep = " ";
+ case 2: fprintf(fd, fmt, sep, (dp->tdir_offset>>8)&0xff);
+ sep = " ";
+ case 1: fprintf(fd, fmt, sep, dp->tdir_offset&0xff);
+ }
+ }
+}
+
+static void
+PrintShort(FILE* fd, const char* fmt, TIFFDirEntry* dp)
+{
+ char *sep = "";
+
+ if (hdr.tiff_magic == TIFF_BIGENDIAN) {
+ switch (dp->tdir_count) {
+ case 2: fprintf(fd, fmt, sep, dp->tdir_offset&0xffff);
+ sep = " ";
+ case 1: fprintf(fd, fmt, sep, dp->tdir_offset>>16);
+ }
+ } else {
+ switch (dp->tdir_count) {
+ case 2: fprintf(fd, fmt, sep, dp->tdir_offset>>16);
+ sep = " ";
+ case 1: fprintf(fd, fmt, sep, dp->tdir_offset&0xffff);
+ }
+ }
+}
+
+static void
+PrintLong(FILE* fd, const char* fmt, TIFFDirEntry* dp)
+{
+ fprintf(fd, fmt, "", (long) dp->tdir_offset);
+}
+
+#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_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;
+ }
+ }
+}
+
+/*
+ * Fetch a contiguous directory item.
+ */
+static int
+TIFFFetchData(int fd, TIFFDirEntry* dir, void* cp)
+{
+ int cc, w;
+
+ w = (dir->tdir_type < NWIDTHS ? datawidth[dir->tdir_type] : 0);
+ cc = dir->tdir_count * w;
+ if (lseek(fd, (off_t)dir->tdir_offset, 0) != (off_t)-1
+ && read(fd, cp, cc) != -1) {
+ if (swabflag) {
+ switch (dir->tdir_type) {
+ case TIFF_SHORT:
+ case TIFF_SSHORT:
+ TIFFSwabArrayOfShort((uint16*) cp,
+ dir->tdir_count);
+ break;
+ case TIFF_LONG:
+ case TIFF_SLONG:
+ case TIFF_FLOAT:
+ case TIFF_IFD:
+ TIFFSwabArrayOfLong((uint32*) cp,
+ dir->tdir_count);
+ break;
+ case TIFF_RATIONAL:
+ TIFFSwabArrayOfLong((uint32*) cp,
+ 2*dir->tdir_count);
+ break;
+ case TIFF_DOUBLE:
+ TIFFSwabArrayOfDouble((double*) cp,
+ dir->tdir_count);
+ break;
+ }
+ }
+ return (cc);
+ }
+ Error("Error while reading data for tag %u", dir->tdir_tag);
+ return (0);
+}
+
+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:
+ */