/* $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:

*/