1
2 /*
3 * Copyright (c) 1988-1997 Sam Leffler
4 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and
7 * its documentation for any purpose is hereby granted without fee, provided
8 * that (i) the above copyright notices and this permission notice appear in
9 * all copies of the software and related documentation, and (ii) the names of
10 * Sam Leffler and Silicon Graphics may not be used in any advertising or
11 * publicity relating to the software without the specific, prior written
12 * permission of Sam Leffler and Silicon Graphics.
13 *
14 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
15 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
16 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
17 *
18 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
19 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
20 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
21 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
22 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
23 * OF THIS SOFTWARE.
24 */
25
26 #include "tif_config.h"
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #ifdef HAVE_UNISTD_H
33 # include <unistd.h>
34 #endif
35
36 #ifdef HAVE_FCNTL_H
37 # include <fcntl.h>
38 #endif
39
40 #ifdef HAVE_SYS_TYPES_H
41 # include <sys/types.h>
42 #endif
43
44 #ifdef HAVE_IO_H
45 # include <io.h>
46 #endif
47
48 #ifdef NEED_LIBPORT
49 # include "libport.h"
50 #endif
51
52 #ifndef HAVE_GETOPT
53 extern int getopt(int, char**, char*);
54 #endif
55
56 #include "tiffio.h"
57
58 #ifndef O_BINARY
59 # define O_BINARY 0
60 #endif
61
62 static union
63 {
64 TIFFHeaderClassic classic;
65 TIFFHeaderBig big;
66 TIFFHeaderCommon common;
67 } hdr;
68 char* appname;
69 char* curfile;
70 int swabflag;
71 int bigendian;
72 int bigtiff;
73 uint32 maxitems = 24; /* maximum indirect data items to print */
74
75 const char* bytefmt = "%s%#02x"; /* BYTE */
76 const char* sbytefmt = "%s%d"; /* SBYTE */
77 const char* shortfmt = "%s%u"; /* SHORT */
78 const char* sshortfmt = "%s%d"; /* SSHORT */
79 const char* longfmt = "%s%lu"; /* LONG */
80 const char* slongfmt = "%s%ld"; /* SLONG */
81 const char* ifdfmt = "%s%#04lx"; /* IFD offset */
82 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
83 const char* long8fmt = "%s%I64u"; /* LONG8 */
84 const char* slong8fmt = "%s%I64d"; /* SLONG8 */
85 const char* ifd8fmt = "%s%#08I64x"; /* IFD offset8*/
86 #else
87 const char* long8fmt = "%s%llu"; /* LONG8 */
88 const char* slong8fmt = "%s%lld"; /* SLONG8 */
89 const char* ifd8fmt = "%s%#08llx"; /* IFD offset8*/
90 #endif
91 const char* rationalfmt = "%s%g"; /* RATIONAL */
92 const char* srationalfmt = "%s%g"; /* SRATIONAL */
93 const char* floatfmt = "%s%g"; /* FLOAT */
94 const char* doublefmt = "%s%g"; /* DOUBLE */
95
96 static void dump(int, uint64);
97 extern int optind;
98 extern char* optarg;
99
100 void
usage()101 usage()
102 {
103 fprintf(stderr, "usage: %s [-h] [-o offset] [-m maxitems] file.tif ...\n", appname);
104 exit(-1);
105 }
106
107 int
main(int argc,char * argv[])108 main(int argc, char* argv[])
109 {
110 int one = 1, fd;
111 int multiplefiles = (argc > 1);
112 int c;
113 uint64 diroff = 0;
114 bigendian = (*(char *)&one == 0);
115
116 appname = argv[0];
117 while ((c = getopt(argc, argv, "m:o:h")) != -1) {
118 switch (c) {
119 case 'h': /* print values in hex */
120 shortfmt = "%s%#x";
121 sshortfmt = "%s%#x";
122 longfmt = "%s%#lx";
123 slongfmt = "%s%#lx";
124 break;
125 case 'o':
126 diroff = (uint64) strtoul(optarg, NULL, 0);
127 break;
128 case 'm':
129 maxitems = strtoul(optarg, NULL, 0);
130 break;
131 default:
132 usage();
133 }
134 }
135 if (optind >= argc)
136 usage();
137 for (; optind < argc; optind++) {
138 fd = open(argv[optind], O_RDONLY|O_BINARY, 0);
139 if (fd < 0) {
140 perror(argv[0]);
141 return (-1);
142 }
143 if (multiplefiles)
144 printf("%s:\n", argv[optind]);
145 curfile = argv[optind];
146 swabflag = 0;
147 bigtiff = 0;
148 dump(fd, diroff);
149 close(fd);
150 }
151 return (0);
152 }
153
154 #define ord(e) ((int)e)
155
156 static uint64 ReadDirectory(int, unsigned, uint64);
157 static void ReadError(char*);
158 static void Error(const char*, ...);
159 static void Fatal(const char*, ...);
160
161 static void
dump(int fd,uint64 diroff)162 dump(int fd, uint64 diroff)
163 {
164 unsigned i;
165
166 lseek(fd, (off_t) 0, 0);
167 if (read(fd, (char*) &hdr, sizeof (TIFFHeaderCommon)) != sizeof (TIFFHeaderCommon))
168 ReadError("TIFF header");
169 if (hdr.common.tiff_magic != TIFF_BIGENDIAN
170 && hdr.common.tiff_magic != TIFF_LITTLEENDIAN &&
171 #if HOST_BIGENDIAN
172 /* MDI is sensitive to the host byte order, unlike TIFF */
173 MDI_BIGENDIAN != hdr.common.tiff_magic
174 #else
175 MDI_LITTLEENDIAN != hdr.common.tiff_magic
176 #endif
177 ) {
178 Fatal("Not a TIFF or MDI file, bad magic number %u (%#x)",
179 hdr.common.tiff_magic, hdr.common.tiff_magic);
180 }
181 if (hdr.common.tiff_magic == TIFF_BIGENDIAN
182 || hdr.common.tiff_magic == MDI_BIGENDIAN)
183 swabflag = !bigendian;
184 else
185 swabflag = bigendian;
186 if (swabflag)
187 TIFFSwabShort(&hdr.common.tiff_version);
188 if (hdr.common.tiff_version==42)
189 {
190 if (read(fd, (char*) &hdr.classic.tiff_diroff, 4) != 4)
191 ReadError("TIFF header");
192 if (swabflag)
193 TIFFSwabLong(&hdr.classic.tiff_diroff);
194 printf("Magic: %#x <%s-endian> Version: %#x <%s>\n",
195 hdr.classic.tiff_magic,
196 hdr.classic.tiff_magic == TIFF_BIGENDIAN ? "big" : "little",
197 42,"ClassicTIFF");
198 if (diroff == 0)
199 diroff = hdr.classic.tiff_diroff;
200 }
201 else if (hdr.common.tiff_version==43)
202 {
203 if (read(fd, (char*) &hdr.big.tiff_offsetsize, 12) != 12)
204 ReadError("TIFF header");
205 if (swabflag)
206 {
207 TIFFSwabShort(&hdr.big.tiff_offsetsize);
208 TIFFSwabShort(&hdr.big.tiff_unused);
209 TIFFSwabLong8(&hdr.big.tiff_diroff);
210 }
211 printf("Magic: %#x <%s-endian> Version: %#x <%s>\n",
212 hdr.big.tiff_magic,
213 hdr.big.tiff_magic == TIFF_BIGENDIAN ? "big" : "little",
214 43,"BigTIFF");
215 printf("OffsetSize: %#x Unused: %#x\n",
216 hdr.big.tiff_offsetsize,hdr.big.tiff_unused);
217 if (diroff == 0)
218 diroff = hdr.big.tiff_diroff;
219 bigtiff = 1;
220 }
221 else
222 Fatal("Not a TIFF file, bad version number %u (%#x)",
223 hdr.common.tiff_version, hdr.common.tiff_version);
224 for (i = 0; diroff != 0; i++) {
225 if (i > 0)
226 putchar('\n');
227 diroff = ReadDirectory(fd, i, diroff);
228 }
229 }
230
231 static const int datawidth[] = {
232 0, /* 00 = undefined */
233 1, /* 01 = TIFF_BYTE */
234 1, /* 02 = TIFF_ASCII */
235 2, /* 03 = TIFF_SHORT */
236 4, /* 04 = TIFF_LONG */
237 8, /* 05 = TIFF_RATIONAL */
238 1, /* 06 = TIFF_SBYTE */
239 1, /* 07 = TIFF_UNDEFINED */
240 2, /* 08 = TIFF_SSHORT */
241 4, /* 09 = TIFF_SLONG */
242 8, /* 10 = TIFF_SRATIONAL */
243 4, /* 11 = TIFF_FLOAT */
244 8, /* 12 = TIFF_DOUBLE */
245 4, /* 13 = TIFF_IFD */
246 0, /* 14 = undefined */
247 0, /* 15 = undefined */
248 8, /* 16 = TIFF_LONG8 */
249 8, /* 17 = TIFF_SLONG8 */
250 8, /* 18 = TIFF_IFD8 */
251 };
252 #define NWIDTHS (sizeof (datawidth) / sizeof (datawidth[0]))
253 static void PrintTag(FILE*, uint16);
254 static void PrintType(FILE*, uint16);
255 static void PrintData(FILE*, uint16, uint32, unsigned char*);
256
257 /*
258 * Read the next TIFF directory from a file
259 * and convert it to the internal format.
260 * We read directories sequentially.
261 */
262 static uint64
ReadDirectory(int fd,unsigned int ix,uint64 off)263 ReadDirectory(int fd, unsigned int ix, uint64 off)
264 {
265 uint16 dircount;
266 uint32 direntrysize;
267 void* dirmem = NULL;
268 uint64 nextdiroff = 0;
269 uint32 n;
270 uint8* dp;
271
272 if (off == 0) /* no more directories */
273 goto done;
274 #if defined(__WIN32__) && defined(_MSC_VER)
275 if (_lseeki64(fd, (__int64)off, SEEK_SET) != (__int64)off) {
276 #else
277 if (lseek(fd, (off_t)off, SEEK_SET) != (off_t)off) {
278 #endif
279 Fatal("Seek error accessing TIFF directory");
280 goto done;
281 }
282 if (!bigtiff) {
283 if (read(fd, (char*) &dircount, sizeof (uint16)) != sizeof (uint16)) {
284 ReadError("directory count");
285 goto done;
286 }
287 if (swabflag)
288 TIFFSwabShort(&dircount);
289 direntrysize = 12;
290 } else {
291 uint64 dircount64 = 0;
292 if (read(fd, (char*) &dircount64, sizeof (uint64)) != sizeof (uint64)) {
293 ReadError("directory count");
294 goto done;
295 }
296 if (swabflag)
297 TIFFSwabLong8(&dircount64);
298 if (dircount64>0xFFFF) {
299 Error("Sanity check on directory count failed");
300 goto done;
301 }
302 dircount = (uint16)dircount64;
303 direntrysize = 20;
304 }
305 dirmem = _TIFFmalloc(dircount * direntrysize);
306 if (dirmem == NULL) {
307 Fatal("No space for TIFF directory");
308 goto done;
309 }
310 n = read(fd, (char*) dirmem, dircount*direntrysize);
311 if (n != dircount*direntrysize) {
312 n /= direntrysize;
313 Error(
314 #if defined(__WIN32__) && defined(_MSC_VER)
315 "Could only read %lu of %u entries in directory at offset %#I64x",
316 (unsigned long)n, dircount, (unsigned __int64) off);
317 #else
318 "Could only read %lu of %u entries in directory at offset %#llx",
319 (unsigned long)n, dircount, (unsigned long long) off);
320 #endif
321 dircount = n;
322 nextdiroff = 0;
323 } else {
324 if (!bigtiff) {
325 uint32 nextdiroff32;
326 if (read(fd, (char*) &nextdiroff32, sizeof (uint32)) != sizeof (uint32))
327 nextdiroff32 = 0;
328 if (swabflag)
329 TIFFSwabLong(&nextdiroff32);
330 nextdiroff = nextdiroff32;
331 } else {
332 if (read(fd, (char*) &nextdiroff, sizeof (uint64)) != sizeof (uint64))
333 nextdiroff = 0;
334 if (swabflag)
335 TIFFSwabLong8(&nextdiroff);
336 }
337 }
338 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
339 printf("Directory %u: offset %I64u (%#I64x) next %I64u (%#I64x)\n", ix,
340 (unsigned __int64)off, (unsigned __int64)off,
341 (unsigned __int64)nextdiroff, (unsigned __int64)nextdiroff);
342 #else
343 printf("Directory %u: offset %llu (%#llx) next %llu (%#llx)\n", ix,
344 (unsigned long long)off, (unsigned long long)off,
345 (unsigned long long)nextdiroff, (unsigned long long)nextdiroff);
346 #endif
347 for (dp = (uint8*)dirmem, n = dircount; n > 0; n--) {
348 uint16 tag;
349 uint16 type;
350 uint16 typewidth;
351 uint64 count;
352 uint64 datasize;
353 int datafits;
354 void* datamem;
355 uint64 dataoffset;
356 int datatruncated;
357 tag = *(uint16*)dp;
358 if (swabflag)
359 TIFFSwabShort(&tag);
360 dp += sizeof(uint16);
361 type = *(uint16*)dp;
362 dp += sizeof(uint16);
363 if (swabflag)
364 TIFFSwabShort(&type);
365 PrintTag(stdout, tag);
366 putchar(' ');
367 PrintType(stdout, type);
368 putchar(' ');
369 if (!bigtiff)
370 {
371 uint32 count32;
372 count32 = *(uint32*)dp;
373 if (swabflag)
374 TIFFSwabLong(&count32);
375 dp += sizeof(uint32);
376 count = count32;
377 }
378 else
379 {
380 count = *(uint64*)dp;
381 if (swabflag)
382 TIFFSwabLong8(&count);
383 dp += sizeof(uint64);
384 }
385 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
386 printf("%I64u<", (unsigned __int64)count);
387 #else
388 printf("%llu<", (unsigned long long)count);
389 #endif
390 if (type >= NWIDTHS)
391 typewidth = 0;
392 else
393 typewidth = datawidth[type];
394 datasize = count*typewidth;
395 datafits = 1;
396 datamem = dp;
397 dataoffset = 0;
398 datatruncated = 0;
399 if (!bigtiff)
400 {
401 if (datasize>4)
402 {
403 uint32 dataoffset32;
404 datafits = 0;
405 datamem = NULL;
406 dataoffset32 = *(uint32*)dp;
407 if (swabflag)
408 TIFFSwabLong(&dataoffset32);
409 dataoffset = dataoffset32;
410 }
411 dp += sizeof(uint32);
412 }
413 else
414 {
415 if (datasize>8)
416 {
417 datafits = 0;
418 datamem = NULL;
419 dataoffset = *(uint64*)dp;
420 if (swabflag)
421 TIFFSwabLong8(&dataoffset);
422 }
423 dp += sizeof(uint64);
424 }
425 if (datasize>0x10000)
426 {
427 datatruncated = 1;
428 count = 0x10000/typewidth;
429 datasize = count*typewidth;
430 }
431 if (count>maxitems)
432 {
433 datatruncated = 1;
434 count = maxitems;
435 datasize = count*typewidth;
436 }
437 if (!datafits)
438 {
439 datamem = _TIFFmalloc((uint32)datasize);
440 if (datamem) {
441 #if defined(__WIN32__) && defined(_MSC_VER)
442 if (_lseeki64(fd, (__int64)dataoffset, SEEK_SET)
443 != (__int64)dataoffset)
444 #else
445 if (lseek(fd, (off_t)dataoffset, 0) !=
446 (off_t)dataoffset)
447 #endif
448 {
449 Error(
450 "Seek error accessing tag %u value", tag);
451 _TIFFfree(datamem);
452 datamem = NULL;
453 }
454 if (read(fd, datamem, (size_t)datasize) != (TIFF_SSIZE_T)datasize)
455 {
456 Error(
457 "Read error accessing tag %u value", tag);
458 _TIFFfree(datamem);
459 datamem = NULL;
460 }
461 } else
462 Error("No space for data for tag %u",tag);
463 }
464 if (datamem)
465 {
466 if (swabflag)
467 {
468 switch (type)
469 {
470 case TIFF_BYTE:
471 case TIFF_ASCII:
472 case TIFF_SBYTE:
473 case TIFF_UNDEFINED:
474 break;
475 case TIFF_SHORT:
476 case TIFF_SSHORT:
477 TIFFSwabArrayOfShort((uint16*)datamem,(tmsize_t)count);
478 break;
479 case TIFF_LONG:
480 case TIFF_SLONG:
481 case TIFF_FLOAT:
482 case TIFF_IFD:
483 TIFFSwabArrayOfLong((uint32*)datamem,(tmsize_t)count);
484 break;
485 case TIFF_RATIONAL:
486 case TIFF_SRATIONAL:
487 TIFFSwabArrayOfLong((uint32*)datamem,(tmsize_t)count*2);
488 break;
489 case TIFF_DOUBLE:
490 case TIFF_LONG8:
491 case TIFF_SLONG8:
492 case TIFF_IFD8:
493 TIFFSwabArrayOfLong8((uint64*)datamem,(tmsize_t)count);
494 break;
495 }
496 }
497 PrintData(stdout,type,(uint32)count,datamem);
498 if (datatruncated)
499 printf(" ...");
500 if (!datafits)
501 _TIFFfree(datamem);
502 }
503 printf(">\n");
504 }
505 done:
506 if (dirmem)
507 _TIFFfree((char *)dirmem);
508 return (nextdiroff);
509 }
510
511 static const struct tagname {
512 uint16 tag;
513 const char* name;
514 } tagnames[] = {
515 { TIFFTAG_SUBFILETYPE, "SubFileType" },
516 { TIFFTAG_OSUBFILETYPE, "OldSubFileType" },
517 { TIFFTAG_IMAGEWIDTH, "ImageWidth" },
518 { TIFFTAG_IMAGELENGTH, "ImageLength" },
519 { TIFFTAG_BITSPERSAMPLE, "BitsPerSample" },
520 { TIFFTAG_COMPRESSION, "Compression" },
521 { TIFFTAG_PHOTOMETRIC, "Photometric" },
522 { TIFFTAG_THRESHHOLDING, "Threshholding" },
523 { TIFFTAG_CELLWIDTH, "CellWidth" },
524 { TIFFTAG_CELLLENGTH, "CellLength" },
525 { TIFFTAG_FILLORDER, "FillOrder" },
526 { TIFFTAG_DOCUMENTNAME, "DocumentName" },
527 { TIFFTAG_IMAGEDESCRIPTION, "ImageDescription" },
528 { TIFFTAG_MAKE, "Make" },
529 { TIFFTAG_MODEL, "Model" },
530 { TIFFTAG_STRIPOFFSETS, "StripOffsets" },
531 { TIFFTAG_ORIENTATION, "Orientation" },
532 { TIFFTAG_SAMPLESPERPIXEL, "SamplesPerPixel" },
533 { TIFFTAG_ROWSPERSTRIP, "RowsPerStrip" },
534 { TIFFTAG_STRIPBYTECOUNTS, "StripByteCounts" },
535 { TIFFTAG_MINSAMPLEVALUE, "MinSampleValue" },
536 { TIFFTAG_MAXSAMPLEVALUE, "MaxSampleValue" },
537 { TIFFTAG_XRESOLUTION, "XResolution" },
538 { TIFFTAG_YRESOLUTION, "YResolution" },
539 { TIFFTAG_PLANARCONFIG, "PlanarConfig" },
540 { TIFFTAG_PAGENAME, "PageName" },
541 { TIFFTAG_XPOSITION, "XPosition" },
542 { TIFFTAG_YPOSITION, "YPosition" },
543 { TIFFTAG_FREEOFFSETS, "FreeOffsets" },
544 { TIFFTAG_FREEBYTECOUNTS, "FreeByteCounts" },
545 { TIFFTAG_GRAYRESPONSEUNIT, "GrayResponseUnit" },
546 { TIFFTAG_GRAYRESPONSECURVE,"GrayResponseCurve" },
547 { TIFFTAG_GROUP3OPTIONS, "Group3Options" },
548 { TIFFTAG_GROUP4OPTIONS, "Group4Options" },
549 { TIFFTAG_RESOLUTIONUNIT, "ResolutionUnit" },
550 { TIFFTAG_PAGENUMBER, "PageNumber" },
551 { TIFFTAG_COLORRESPONSEUNIT,"ColorResponseUnit" },
552 { TIFFTAG_TRANSFERFUNCTION, "TransferFunction" },
553 { TIFFTAG_SOFTWARE, "Software" },
554 { TIFFTAG_DATETIME, "DateTime" },
555 { TIFFTAG_ARTIST, "Artist" },
556 { TIFFTAG_HOSTCOMPUTER, "HostComputer" },
557 { TIFFTAG_PREDICTOR, "Predictor" },
558 { TIFFTAG_WHITEPOINT, "Whitepoint" },
559 { TIFFTAG_PRIMARYCHROMATICITIES,"PrimaryChromaticities" },
560 { TIFFTAG_COLORMAP, "Colormap" },
561 { TIFFTAG_HALFTONEHINTS, "HalftoneHints" },
562 { TIFFTAG_TILEWIDTH, "TileWidth" },
563 { TIFFTAG_TILELENGTH, "TileLength" },
564 { TIFFTAG_TILEOFFSETS, "TileOffsets" },
565 { TIFFTAG_TILEBYTECOUNTS, "TileByteCounts" },
566 { TIFFTAG_BADFAXLINES, "BadFaxLines" },
567 { TIFFTAG_CLEANFAXDATA, "CleanFaxData" },
568 { TIFFTAG_CONSECUTIVEBADFAXLINES, "ConsecutiveBadFaxLines" },
569 { TIFFTAG_SUBIFD, "SubIFD" },
570 { TIFFTAG_INKSET, "InkSet" },
571 { TIFFTAG_INKNAMES, "InkNames" },
572 { TIFFTAG_NUMBEROFINKS, "NumberOfInks" },
573 { TIFFTAG_DOTRANGE, "DotRange" },
574 { TIFFTAG_TARGETPRINTER, "TargetPrinter" },
575 { TIFFTAG_EXTRASAMPLES, "ExtraSamples" },
576 { TIFFTAG_SAMPLEFORMAT, "SampleFormat" },
577 { TIFFTAG_SMINSAMPLEVALUE, "SMinSampleValue" },
578 { TIFFTAG_SMAXSAMPLEVALUE, "SMaxSampleValue" },
579 { TIFFTAG_JPEGPROC, "JPEGProcessingMode" },
580 { TIFFTAG_JPEGIFOFFSET, "JPEGInterchangeFormat" },
581 { TIFFTAG_JPEGIFBYTECOUNT, "JPEGInterchangeFormatLength" },
582 { TIFFTAG_JPEGRESTARTINTERVAL,"JPEGRestartInterval" },
583 { TIFFTAG_JPEGLOSSLESSPREDICTORS,"JPEGLosslessPredictors" },
584 { TIFFTAG_JPEGPOINTTRANSFORM,"JPEGPointTransform" },
585 { TIFFTAG_JPEGTABLES, "JPEGTables" },
586 { TIFFTAG_JPEGQTABLES, "JPEGQTables" },
587 { TIFFTAG_JPEGDCTABLES, "JPEGDCTables" },
588 { TIFFTAG_JPEGACTABLES, "JPEGACTables" },
589 { TIFFTAG_YCBCRCOEFFICIENTS,"YCbCrCoefficients" },
590 { TIFFTAG_YCBCRSUBSAMPLING, "YCbCrSubsampling" },
591 { TIFFTAG_YCBCRPOSITIONING, "YCbCrPositioning" },
592 { TIFFTAG_REFERENCEBLACKWHITE, "ReferenceBlackWhite" },
593 { TIFFTAG_REFPTS, "IgReferencePoints (Island Graphics)" },
594 { TIFFTAG_REGIONTACKPOINT, "IgRegionTackPoint (Island Graphics)" },
595 { TIFFTAG_REGIONWARPCORNERS,"IgRegionWarpCorners (Island Graphics)" },
596 { TIFFTAG_REGIONAFFINE, "IgRegionAffine (Island Graphics)" },
597 { TIFFTAG_MATTEING, "OBSOLETE Matteing (Silicon Graphics)" },
598 { TIFFTAG_DATATYPE, "OBSOLETE DataType (Silicon Graphics)" },
599 { TIFFTAG_IMAGEDEPTH, "ImageDepth (Silicon Graphics)" },
600 { TIFFTAG_TILEDEPTH, "TileDepth (Silicon Graphics)" },
601 { 32768, "OLD BOGUS Matteing tag" },
602 { TIFFTAG_COPYRIGHT, "Copyright" },
603 { TIFFTAG_ICCPROFILE, "ICC Profile" },
604 { TIFFTAG_JBIGOPTIONS, "JBIG Options" },
605 { TIFFTAG_STONITS, "StoNits" },
606 };
607 #define NTAGS (sizeof (tagnames) / sizeof (tagnames[0]))
608
609 static void
610 PrintTag(FILE* fd, uint16 tag)
611 {
612 const struct tagname *tp;
613
614 for (tp = tagnames; tp < &tagnames[NTAGS]; tp++)
615 if (tp->tag == tag) {
616 fprintf(fd, "%s (%u)", tp->name, tag);
617 return;
618 }
619 fprintf(fd, "%u (%#x)", tag, tag);
620 }
621
622 static void
623 PrintType(FILE* fd, uint16 type)
624 {
625 static const char *typenames[] = {
626 "0",
627 "BYTE",
628 "ASCII",
629 "SHORT",
630 "LONG",
631 "RATIONAL",
632 "SBYTE",
633 "UNDEFINED",
634 "SSHORT",
635 "SLONG",
636 "SRATIONAL",
637 "FLOAT",
638 "DOUBLE",
639 "IFD",
640 "14",
641 "15",
642 "LONG8",
643 "SLONG8",
644 "IFD8"
645 };
646 #define NTYPES (sizeof (typenames) / sizeof (typenames[0]))
647
648 if (type < NTYPES)
649 fprintf(fd, "%s (%u)", typenames[type], type);
650 else
651 fprintf(fd, "%u (%#x)", type, type);
652 }
653 #undef NTYPES
654
655 #include <ctype.h>
656
657 static void
658 PrintASCII(FILE* fd, uint32 cc, const unsigned char* cp)
659 {
660 for (; cc > 0; cc--, cp++) {
661 const char* tp;
662
663 if (isprint(*cp)) {
664 fputc(*cp, fd);
665 continue;
666 }
667 for (tp = "\tt\bb\rr\nn\vv"; *tp; tp++)
668 if (*tp++ == *cp)
669 break;
670 if (*tp)
671 fprintf(fd, "\\%c", *tp);
672 else if (*cp)
673 fprintf(fd, "\\%03o", *cp);
674 else
675 fprintf(fd, "\\0");
676 }
677 }
678
679 static void
680 PrintData(FILE* fd, uint16 type, uint32 count, unsigned char* data)
681 {
682 char* sep = "";
683
684 switch (type) {
685 case TIFF_BYTE:
686 while (count-- > 0)
687 fprintf(fd, bytefmt, sep, *data++), sep = " ";
688 break;
689 case TIFF_SBYTE:
690 while (count-- > 0)
691 fprintf(fd, sbytefmt, sep, *(char *)data++), sep = " ";
692 break;
693 case TIFF_UNDEFINED:
694 while (count-- > 0)
695 fprintf(fd, bytefmt, sep, *data++), sep = " ";
696 break;
697 case TIFF_ASCII:
698 PrintASCII(fd, count, data);
699 break;
700 case TIFF_SHORT: {
701 uint16 *wp = (uint16*)data;
702 while (count-- > 0)
703 fprintf(fd, shortfmt, sep, *wp++), sep = " ";
704 break;
705 }
706 case TIFF_SSHORT: {
707 int16 *wp = (int16*)data;
708 while (count-- > 0)
709 fprintf(fd, sshortfmt, sep, *wp++), sep = " ";
710 break;
711 }
712 case TIFF_LONG: {
713 uint32 *lp = (uint32*)data;
714 while (count-- > 0) {
715 fprintf(fd, longfmt, sep, (unsigned long) *lp++);
716 sep = " ";
717 }
718 break;
719 }
720 case TIFF_SLONG: {
721 int32 *lp = (int32*)data;
722 while (count-- > 0)
723 fprintf(fd, slongfmt, sep, (long) *lp++), sep = " ";
724 break;
725 }
726 case TIFF_LONG8: {
727 uint64 *llp = (uint64*)data;
728 while (count-- > 0) {
729 #if defined(__WIN32__) && defined(_MSC_VER)
730 fprintf(fd, long8fmt, sep, (unsigned __int64) *llp++);
731 #else
732 fprintf(fd, long8fmt, sep, (unsigned long long) *llp++);
733 #endif
734 sep = " ";
735 }
736 break;
737 }
738 case TIFF_SLONG8: {
739 int64 *llp = (int64*)data;
740 while (count-- > 0)
741 #if defined(__WIN32__) && defined(_MSC_VER)
742 fprintf(fd, slong8fmt, sep, (__int64) *llp++), sep = " ";
743 #else
744 fprintf(fd, slong8fmt, sep, (long long) *llp++), sep = " ";
745 #endif
746 break;
747 }
748 case TIFF_RATIONAL: {
749 uint32 *lp = (uint32*)data;
750 while (count-- > 0) {
751 if (lp[1] == 0)
752 fprintf(fd, "%sNan (%lu/%lu)", sep,
753 (unsigned long) lp[0],
754 (unsigned long) lp[1]);
755 else
756 fprintf(fd, rationalfmt, sep,
757 (double)lp[0] / (double)lp[1]);
758 sep = " ";
759 lp += 2;
760 }
761 break;
762 }
763 case TIFF_SRATIONAL: {
764 int32 *lp = (int32*)data;
765 while (count-- > 0) {
766 if (lp[1] == 0)
767 fprintf(fd, "%sNan (%ld/%ld)", sep,
768 (long) lp[0], (long) lp[1]);
769 else
770 fprintf(fd, srationalfmt, sep,
771 (double)lp[0] / (double)lp[1]);
772 sep = " ";
773 lp += 2;
774 }
775 break;
776 }
777 case TIFF_FLOAT: {
778 float *fp = (float *)data;
779 while (count-- > 0)
780 fprintf(fd, floatfmt, sep, *fp++), sep = " ";
781 break;
782 }
783 case TIFF_DOUBLE: {
784 double *dp = (double *)data;
785 while (count-- > 0)
786 fprintf(fd, doublefmt, sep, *dp++), sep = " ";
787 break;
788 }
789 case TIFF_IFD: {
790 uint32 *lp = (uint32*)data;
791 while (count-- > 0) {
792 fprintf(fd, ifdfmt, sep, (unsigned long) *lp++);
793 sep = " ";
794 }
795 break;
796 }
797 case TIFF_IFD8: {
798 uint64 *llp = (uint64*)data;
799 while (count-- > 0) {
800 #if defined(__WIN32__) && defined(_MSC_VER)
801 fprintf(fd, ifd8fmt, sep, (unsigned __int64) *llp++);
802 #else
803 fprintf(fd, ifd8fmt, sep, (unsigned long long) *llp++);
804 #endif
805 sep = " ";
806 }
807 break;
808 }
809 }
810 }
811
812 static void
813 ReadError(char* what)
814 {
815 Fatal("Error while reading %s", what);
816 }
817
818 #include <stdarg.h>
819
820 static void
821 vError(FILE* fd, const char* fmt, va_list ap)
822 {
823 fprintf(fd, "%s: ", curfile);
824 vfprintf(fd, fmt, ap);
825 fprintf(fd, ".\n");
826 }
827
828 static void
829 Error(const char* fmt, ...)
830 {
831 va_list ap;
832 va_start(ap, fmt);
833 vError(stderr, fmt, ap);
834 va_end(ap);
835 }
836
837 static void
838 Fatal(const char* fmt, ...)
839 {
840 va_list ap;
841 va_start(ap, fmt);
842 vError(stderr, fmt, ap);
843 va_end(ap);
844 exit(-1);
845 }
846
847 /* vim: set ts=8 sts=8 sw=8 noet: */
848 /*
849 * Local Variables:
850 * mode: c
851 * c-basic-offset: 8
852 * fill-column: 78
853 * End:
854 */
855