1 : /* $Id: tif_print.c,v 1.60 2012-08-19 16:56:35 bfriesen Exp $ */
2 :
3 : /*
4 : * Copyright (c) 1988-1997 Sam Leffler
5 : * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6 : *
7 : * Permission to use, copy, modify, distribute, and sell this software and
8 : * its documentation for any purpose is hereby granted without fee, provided
9 : * that (i) the above copyright notices and this permission notice appear in
10 : * all copies of the software and related documentation, and (ii) the names of
11 : * Sam Leffler and Silicon Graphics may not be used in any advertising or
12 : * publicity relating to the software without the specific, prior written
13 : * permission of Sam Leffler and Silicon Graphics.
14 : *
15 : * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 : * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 : * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18 : *
19 : * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20 : * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 : * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 : * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 : * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 : * OF THIS SOFTWARE.
25 : */
26 :
27 : /*
28 : * TIFF Library.
29 : *
30 : * Directory Printing Support
31 : */
32 : #include "tiffiop.h"
33 : #include <stdio.h>
34 :
35 : #include <ctype.h>
36 :
37 : static void
38 : _TIFFprintAsciiBounded(FILE* fd, const char* cp, int max_chars);
39 :
40 : static const char *photoNames[] = {
41 : "min-is-white", /* PHOTOMETRIC_MINISWHITE */
42 : "min-is-black", /* PHOTOMETRIC_MINISBLACK */
43 : "RGB color", /* PHOTOMETRIC_RGB */
44 : "palette color (RGB from colormap)", /* PHOTOMETRIC_PALETTE */
45 : "transparency mask", /* PHOTOMETRIC_MASK */
46 : "separated", /* PHOTOMETRIC_SEPARATED */
47 : "YCbCr", /* PHOTOMETRIC_YCBCR */
48 : "7 (0x7)",
49 : "CIE L*a*b*", /* PHOTOMETRIC_CIELAB */
50 : "ICC L*a*b*", /* PHOTOMETRIC_ICCLAB */
51 : "ITU L*a*b*" /* PHOTOMETRIC_ITULAB */
52 : };
53 : #define NPHOTONAMES (sizeof (photoNames) / sizeof (photoNames[0]))
54 :
55 : static const char *orientNames[] = {
56 : "0 (0x0)",
57 : "row 0 top, col 0 lhs", /* ORIENTATION_TOPLEFT */
58 : "row 0 top, col 0 rhs", /* ORIENTATION_TOPRIGHT */
59 : "row 0 bottom, col 0 rhs", /* ORIENTATION_BOTRIGHT */
60 : "row 0 bottom, col 0 lhs", /* ORIENTATION_BOTLEFT */
61 : "row 0 lhs, col 0 top", /* ORIENTATION_LEFTTOP */
62 : "row 0 rhs, col 0 top", /* ORIENTATION_RIGHTTOP */
63 : "row 0 rhs, col 0 bottom", /* ORIENTATION_RIGHTBOT */
64 : "row 0 lhs, col 0 bottom", /* ORIENTATION_LEFTBOT */
65 : };
66 : #define NORIENTNAMES (sizeof (orientNames) / sizeof (orientNames[0]))
67 :
68 : static void
69 0 : _TIFFPrintField(FILE* fd, const TIFFField *fip,
70 : uint32 value_count, void *raw_data)
71 : {
72 : uint32 j;
73 :
74 0 : fprintf(fd, " %s: ", fip->field_name);
75 :
76 0 : for(j = 0; j < value_count; j++) {
77 0 : if(fip->field_type == TIFF_BYTE)
78 0 : fprintf(fd, "%u", ((uint8 *) raw_data)[j]);
79 0 : else if(fip->field_type == TIFF_UNDEFINED)
80 0 : fprintf(fd, "0x%x",
81 0 : (unsigned int) ((unsigned char *) raw_data)[j]);
82 0 : else if(fip->field_type == TIFF_SBYTE)
83 0 : fprintf(fd, "%d", ((int8 *) raw_data)[j]);
84 0 : else if(fip->field_type == TIFF_SHORT)
85 0 : fprintf(fd, "%u", ((uint16 *) raw_data)[j]);
86 0 : else if(fip->field_type == TIFF_SSHORT)
87 0 : fprintf(fd, "%d", ((int16 *) raw_data)[j]);
88 0 : else if(fip->field_type == TIFF_LONG)
89 0 : fprintf(fd, "%lu",
90 0 : (unsigned long)((uint32 *) raw_data)[j]);
91 0 : else if(fip->field_type == TIFF_SLONG)
92 0 : fprintf(fd, "%ld", (long)((int32 *) raw_data)[j]);
93 0 : else if(fip->field_type == TIFF_IFD)
94 0 : fprintf(fd, "0x%lx",
95 0 : (unsigned long)((uint32 *) raw_data)[j]);
96 0 : else if(fip->field_type == TIFF_RATIONAL
97 0 : || fip->field_type == TIFF_SRATIONAL
98 0 : || fip->field_type == TIFF_FLOAT)
99 0 : fprintf(fd, "%f", ((float *) raw_data)[j]);
100 0 : else if(fip->field_type == TIFF_LONG8)
101 : #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
102 : fprintf(fd, "%I64u",
103 : (unsigned __int64)((uint64 *) raw_data)[j]);
104 : #else
105 0 : fprintf(fd, "%llu",
106 0 : (unsigned long long)((uint64 *) raw_data)[j]);
107 : #endif
108 0 : else if(fip->field_type == TIFF_SLONG8)
109 : #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
110 : fprintf(fd, "%I64d", (__int64)((int64 *) raw_data)[j]);
111 : #else
112 0 : fprintf(fd, "%lld", (long long)((int64 *) raw_data)[j]);
113 : #endif
114 0 : else if(fip->field_type == TIFF_IFD8)
115 : #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
116 : fprintf(fd, "0x%I64x",
117 : (unsigned __int64)((uint64 *) raw_data)[j]);
118 : #else
119 0 : fprintf(fd, "0x%llx",
120 0 : (unsigned long long)((uint64 *) raw_data)[j]);
121 : #endif
122 0 : else if(fip->field_type == TIFF_FLOAT)
123 0 : fprintf(fd, "%f", ((float *)raw_data)[j]);
124 0 : else if(fip->field_type == TIFF_DOUBLE)
125 0 : fprintf(fd, "%f", ((double *) raw_data)[j]);
126 0 : else if(fip->field_type == TIFF_ASCII) {
127 0 : fprintf(fd, "%s", (char *) raw_data);
128 0 : break;
129 : }
130 : else {
131 0 : fprintf(fd, "<unsupported data type in TIFFPrint>");
132 0 : break;
133 : }
134 :
135 0 : if(j < value_count - 1)
136 0 : fprintf(fd, ",");
137 : }
138 :
139 0 : fprintf(fd, "\n");
140 0 : }
141 :
142 : static int
143 0 : _TIFFPrettyPrintField(TIFF* tif, const TIFFField *fip, FILE* fd, uint32 tag,
144 : uint32 value_count, void *raw_data)
145 : {
146 : (void) tif;
147 :
148 : /* do not try to pretty print auto-defined fields */
149 0 : if (strncmp(fip->field_name,"Tag ", 4) == 0) {
150 0 : return 0;
151 : }
152 :
153 0 : switch (tag)
154 : {
155 : case TIFFTAG_INKSET:
156 0 : if (value_count == 2 && fip->field_type == TIFF_SHORT) {
157 0 : fprintf(fd, " Ink Set: ");
158 0 : switch (*((uint16*)raw_data)) {
159 : case INKSET_CMYK:
160 0 : fprintf(fd, "CMYK\n");
161 0 : break;
162 : default:
163 0 : fprintf(fd, "%u (0x%x)\n",
164 0 : *((uint16*)raw_data),
165 0 : *((uint16*)raw_data));
166 : break;
167 : }
168 0 : return 1;
169 : }
170 0 : return 0;
171 :
172 : case TIFFTAG_DOTRANGE:
173 0 : if (value_count == 2 && fip->field_type == TIFF_SHORT) {
174 0 : fprintf(fd, " Dot Range: %u-%u\n",
175 0 : ((uint16*)raw_data)[0], ((uint16*)raw_data)[1]);
176 0 : return 1;
177 : }
178 0 : return 0;
179 :
180 : case TIFFTAG_WHITEPOINT:
181 0 : if (value_count == 2 && fip->field_type == TIFF_RATIONAL) {
182 0 : fprintf(fd, " White Point: %g-%g\n",
183 0 : ((float *)raw_data)[0], ((float *)raw_data)[1]);
184 0 : return 1;
185 : }
186 0 : return 0;
187 :
188 : case TIFFTAG_XMLPACKET:
189 : {
190 : uint32 i;
191 :
192 0 : fprintf(fd, " XMLPacket (XMP Metadata):\n" );
193 0 : for(i = 0; i < value_count; i++)
194 0 : fputc(((char *)raw_data)[i], fd);
195 0 : fprintf( fd, "\n" );
196 0 : return 1;
197 : }
198 : case TIFFTAG_RICHTIFFIPTC:
199 : /*
200 : * XXX: for some weird reason RichTIFFIPTC tag
201 : * defined as array of LONG values.
202 : */
203 0 : fprintf(fd,
204 : " RichTIFFIPTC Data: <present>, %lu bytes\n",
205 : (unsigned long) value_count * 4);
206 0 : return 1;
207 :
208 : case TIFFTAG_PHOTOSHOP:
209 0 : fprintf(fd, " Photoshop Data: <present>, %lu bytes\n",
210 : (unsigned long) value_count);
211 0 : return 1;
212 :
213 : case TIFFTAG_ICCPROFILE:
214 0 : fprintf(fd, " ICC Profile: <present>, %lu bytes\n",
215 : (unsigned long) value_count);
216 0 : return 1;
217 :
218 : case TIFFTAG_STONITS:
219 0 : if (value_count == 1 && fip->field_type == TIFF_DOUBLE) {
220 0 : fprintf(fd,
221 : " Sample to Nits conversion factor: %.4e\n",
222 0 : *((double*)raw_data));
223 0 : return 1;
224 : }
225 0 : return 0;
226 : }
227 :
228 0 : return 0;
229 : }
230 :
231 : /*
232 : * Print the contents of the current directory
233 : * to the specified stdio file stream.
234 : */
235 : void
236 0 : TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
237 : {
238 0 : TIFFDirectory *td = &tif->tif_dir;
239 : char *sep;
240 : uint16 i;
241 : long l, n;
242 :
243 : #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
244 : fprintf(fd, "TIFF Directory at offset 0x%I64x (%I64u)\n",
245 : (unsigned __int64) tif->tif_diroff,
246 : (unsigned __int64) tif->tif_diroff);
247 : #else
248 0 : fprintf(fd, "TIFF Directory at offset 0x%llx (%llu)\n",
249 : (unsigned long long) tif->tif_diroff,
250 : (unsigned long long) tif->tif_diroff);
251 : #endif
252 0 : if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
253 0 : fprintf(fd, " Subfile Type:");
254 0 : sep = " ";
255 0 : if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
256 0 : fprintf(fd, "%sreduced-resolution image", sep);
257 0 : sep = "/";
258 : }
259 0 : if (td->td_subfiletype & FILETYPE_PAGE) {
260 0 : fprintf(fd, "%smulti-page document", sep);
261 0 : sep = "/";
262 : }
263 0 : if (td->td_subfiletype & FILETYPE_MASK)
264 0 : fprintf(fd, "%stransparency mask", sep);
265 0 : fprintf(fd, " (%lu = 0x%lx)\n",
266 : (long) td->td_subfiletype, (long) td->td_subfiletype);
267 : }
268 0 : if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) {
269 0 : fprintf(fd, " Image Width: %lu Image Length: %lu",
270 : (unsigned long) td->td_imagewidth, (unsigned long) td->td_imagelength);
271 0 : if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
272 0 : fprintf(fd, " Image Depth: %lu",
273 : (unsigned long) td->td_imagedepth);
274 0 : fprintf(fd, "\n");
275 : }
276 0 : if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) {
277 0 : fprintf(fd, " Tile Width: %lu Tile Length: %lu",
278 : (unsigned long) td->td_tilewidth, (unsigned long) td->td_tilelength);
279 0 : if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
280 0 : fprintf(fd, " Tile Depth: %lu",
281 : (unsigned long) td->td_tiledepth);
282 0 : fprintf(fd, "\n");
283 : }
284 0 : if (TIFFFieldSet(tif,FIELD_RESOLUTION)) {
285 0 : fprintf(fd, " Resolution: %g, %g",
286 0 : td->td_xresolution, td->td_yresolution);
287 0 : if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) {
288 0 : switch (td->td_resolutionunit) {
289 : case RESUNIT_NONE:
290 0 : fprintf(fd, " (unitless)");
291 0 : break;
292 : case RESUNIT_INCH:
293 0 : fprintf(fd, " pixels/inch");
294 0 : break;
295 : case RESUNIT_CENTIMETER:
296 0 : fprintf(fd, " pixels/cm");
297 0 : break;
298 : default:
299 0 : fprintf(fd, " (unit %u = 0x%x)",
300 0 : td->td_resolutionunit,
301 0 : td->td_resolutionunit);
302 : break;
303 : }
304 : }
305 0 : fprintf(fd, "\n");
306 : }
307 0 : if (TIFFFieldSet(tif,FIELD_POSITION))
308 0 : fprintf(fd, " Position: %g, %g\n",
309 0 : td->td_xposition, td->td_yposition);
310 0 : if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
311 0 : fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample);
312 0 : if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) {
313 0 : fprintf(fd, " Sample Format: ");
314 0 : switch (td->td_sampleformat) {
315 : case SAMPLEFORMAT_VOID:
316 0 : fprintf(fd, "void\n");
317 0 : break;
318 : case SAMPLEFORMAT_INT:
319 0 : fprintf(fd, "signed integer\n");
320 0 : break;
321 : case SAMPLEFORMAT_UINT:
322 0 : fprintf(fd, "unsigned integer\n");
323 0 : break;
324 : case SAMPLEFORMAT_IEEEFP:
325 0 : fprintf(fd, "IEEE floating point\n");
326 0 : break;
327 : case SAMPLEFORMAT_COMPLEXINT:
328 0 : fprintf(fd, "complex signed integer\n");
329 0 : break;
330 : case SAMPLEFORMAT_COMPLEXIEEEFP:
331 0 : fprintf(fd, "complex IEEE floating point\n");
332 0 : break;
333 : default:
334 0 : fprintf(fd, "%u (0x%x)\n",
335 0 : td->td_sampleformat, td->td_sampleformat);
336 : break;
337 : }
338 : }
339 0 : if (TIFFFieldSet(tif,FIELD_COMPRESSION)) {
340 0 : const TIFFCodec* c = TIFFFindCODEC(td->td_compression);
341 0 : fprintf(fd, " Compression Scheme: ");
342 0 : if (c)
343 0 : fprintf(fd, "%s\n", c->name);
344 : else
345 0 : fprintf(fd, "%u (0x%x)\n",
346 0 : td->td_compression, td->td_compression);
347 : }
348 0 : if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) {
349 0 : fprintf(fd, " Photometric Interpretation: ");
350 0 : if (td->td_photometric < NPHOTONAMES)
351 0 : fprintf(fd, "%s\n", photoNames[td->td_photometric]);
352 : else {
353 0 : switch (td->td_photometric) {
354 : case PHOTOMETRIC_LOGL:
355 0 : fprintf(fd, "CIE Log2(L)\n");
356 0 : break;
357 : case PHOTOMETRIC_LOGLUV:
358 0 : fprintf(fd, "CIE Log2(L) (u',v')\n");
359 0 : break;
360 : default:
361 0 : fprintf(fd, "%u (0x%x)\n",
362 0 : td->td_photometric, td->td_photometric);
363 : break;
364 : }
365 : }
366 : }
367 0 : if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) {
368 0 : fprintf(fd, " Extra Samples: %u<", td->td_extrasamples);
369 0 : sep = "";
370 0 : for (i = 0; i < td->td_extrasamples; i++) {
371 0 : switch (td->td_sampleinfo[i]) {
372 : case EXTRASAMPLE_UNSPECIFIED:
373 0 : fprintf(fd, "%sunspecified", sep);
374 0 : break;
375 : case EXTRASAMPLE_ASSOCALPHA:
376 0 : fprintf(fd, "%sassoc-alpha", sep);
377 0 : break;
378 : case EXTRASAMPLE_UNASSALPHA:
379 0 : fprintf(fd, "%sunassoc-alpha", sep);
380 0 : break;
381 : default:
382 0 : fprintf(fd, "%s%u (0x%x)", sep,
383 0 : td->td_sampleinfo[i], td->td_sampleinfo[i]);
384 : break;
385 : }
386 0 : sep = ", ";
387 : }
388 0 : fprintf(fd, ">\n");
389 : }
390 0 : if (TIFFFieldSet(tif,FIELD_INKNAMES)) {
391 : char* cp;
392 0 : fprintf(fd, " Ink Names: ");
393 0 : i = td->td_samplesperpixel;
394 0 : sep = "";
395 0 : for (cp = td->td_inknames;
396 0 : i > 0 && cp < td->td_inknames + td->td_inknameslen;
397 0 : cp = strchr(cp,'\0')+1, i--) {
398 : int max_chars =
399 0 : td->td_inknameslen - (cp - td->td_inknames);
400 0 : fputs(sep, fd);
401 0 : _TIFFprintAsciiBounded(fd, cp, max_chars);
402 0 : sep = ", ";
403 : }
404 0 : fputs("\n", fd);
405 : }
406 0 : if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) {
407 0 : fprintf(fd, " Thresholding: ");
408 0 : switch (td->td_threshholding) {
409 : case THRESHHOLD_BILEVEL:
410 0 : fprintf(fd, "bilevel art scan\n");
411 0 : break;
412 : case THRESHHOLD_HALFTONE:
413 0 : fprintf(fd, "halftone or dithered scan\n");
414 0 : break;
415 : case THRESHHOLD_ERRORDIFFUSE:
416 0 : fprintf(fd, "error diffused\n");
417 0 : break;
418 : default:
419 0 : fprintf(fd, "%u (0x%x)\n",
420 0 : td->td_threshholding, td->td_threshholding);
421 : break;
422 : }
423 : }
424 0 : if (TIFFFieldSet(tif,FIELD_FILLORDER)) {
425 0 : fprintf(fd, " FillOrder: ");
426 0 : switch (td->td_fillorder) {
427 : case FILLORDER_MSB2LSB:
428 0 : fprintf(fd, "msb-to-lsb\n");
429 0 : break;
430 : case FILLORDER_LSB2MSB:
431 0 : fprintf(fd, "lsb-to-msb\n");
432 0 : break;
433 : default:
434 0 : fprintf(fd, "%u (0x%x)\n",
435 0 : td->td_fillorder, td->td_fillorder);
436 : break;
437 : }
438 : }
439 0 : if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
440 : {
441 0 : fprintf(fd, " YCbCr Subsampling: %u, %u\n",
442 0 : td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1] );
443 : }
444 0 : if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
445 0 : fprintf(fd, " YCbCr Positioning: ");
446 0 : switch (td->td_ycbcrpositioning) {
447 : case YCBCRPOSITION_CENTERED:
448 0 : fprintf(fd, "centered\n");
449 0 : break;
450 : case YCBCRPOSITION_COSITED:
451 0 : fprintf(fd, "cosited\n");
452 0 : break;
453 : default:
454 0 : fprintf(fd, "%u (0x%x)\n",
455 0 : td->td_ycbcrpositioning, td->td_ycbcrpositioning);
456 : break;
457 : }
458 : }
459 0 : if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
460 0 : fprintf(fd, " Halftone Hints: light %u dark %u\n",
461 0 : td->td_halftonehints[0], td->td_halftonehints[1]);
462 0 : if (TIFFFieldSet(tif,FIELD_ORIENTATION)) {
463 0 : fprintf(fd, " Orientation: ");
464 0 : if (td->td_orientation < NORIENTNAMES)
465 0 : fprintf(fd, "%s\n", orientNames[td->td_orientation]);
466 : else
467 0 : fprintf(fd, "%u (0x%x)\n",
468 0 : td->td_orientation, td->td_orientation);
469 : }
470 0 : if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
471 0 : fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel);
472 0 : if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) {
473 0 : fprintf(fd, " Rows/Strip: ");
474 0 : if (td->td_rowsperstrip == (uint32) -1)
475 0 : fprintf(fd, "(infinite)\n");
476 : else
477 0 : fprintf(fd, "%lu\n", (unsigned long) td->td_rowsperstrip);
478 : }
479 0 : if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
480 0 : fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue);
481 0 : if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
482 0 : fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue);
483 0 : if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) {
484 0 : int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1;
485 0 : fprintf(fd, " SMin Sample Value:");
486 0 : for (i = 0; i < count; ++i)
487 0 : fprintf(fd, " %g", td->td_sminsamplevalue[i]);
488 0 : fprintf(fd, "\n");
489 : }
490 0 : if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) {
491 0 : int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1;
492 0 : fprintf(fd, " SMax Sample Value:");
493 0 : for (i = 0; i < count; ++i)
494 0 : fprintf(fd, " %g", td->td_smaxsamplevalue[i]);
495 0 : fprintf(fd, "\n");
496 : }
497 0 : if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
498 0 : fprintf(fd, " Planar Configuration: ");
499 0 : switch (td->td_planarconfig) {
500 : case PLANARCONFIG_CONTIG:
501 0 : fprintf(fd, "single image plane\n");
502 0 : break;
503 : case PLANARCONFIG_SEPARATE:
504 0 : fprintf(fd, "separate image planes\n");
505 0 : break;
506 : default:
507 0 : fprintf(fd, "%u (0x%x)\n",
508 0 : td->td_planarconfig, td->td_planarconfig);
509 : break;
510 : }
511 : }
512 0 : if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
513 0 : fprintf(fd, " Page Number: %u-%u\n",
514 0 : td->td_pagenumber[0], td->td_pagenumber[1]);
515 0 : if (TIFFFieldSet(tif,FIELD_COLORMAP)) {
516 0 : fprintf(fd, " Color Map: ");
517 0 : if (flags & TIFFPRINT_COLORMAP) {
518 0 : fprintf(fd, "\n");
519 0 : n = 1L<<td->td_bitspersample;
520 0 : for (l = 0; l < n; l++)
521 0 : fprintf(fd, " %5lu: %5u %5u %5u\n",
522 : l,
523 0 : td->td_colormap[0][l],
524 0 : td->td_colormap[1][l],
525 0 : td->td_colormap[2][l]);
526 : } else
527 0 : fprintf(fd, "(present)\n");
528 : }
529 0 : if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) {
530 0 : fprintf(fd, " Reference Black/White:\n");
531 0 : for (i = 0; i < 3; i++)
532 0 : fprintf(fd, " %2d: %5g %5g\n", i,
533 0 : td->td_refblackwhite[2*i+0],
534 0 : td->td_refblackwhite[2*i+1]);
535 : }
536 0 : if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
537 0 : fprintf(fd, " Transfer Function: ");
538 0 : if (flags & TIFFPRINT_CURVES) {
539 0 : fprintf(fd, "\n");
540 0 : n = 1L<<td->td_bitspersample;
541 0 : for (l = 0; l < n; l++) {
542 0 : fprintf(fd, " %2lu: %5u",
543 0 : l, td->td_transferfunction[0][l]);
544 0 : for (i = 1; i < td->td_samplesperpixel; i++)
545 0 : fprintf(fd, " %5u",
546 0 : td->td_transferfunction[i][l]);
547 0 : fputc('\n', fd);
548 : }
549 : } else
550 0 : fprintf(fd, "(present)\n");
551 : }
552 0 : if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) {
553 0 : fprintf(fd, " SubIFD Offsets:");
554 0 : for (i = 0; i < td->td_nsubifd; i++)
555 : #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
556 : fprintf(fd, " %5I64u",
557 : (unsigned __int64) td->td_subifd[i]);
558 : #else
559 0 : fprintf(fd, " %5llu",
560 0 : (unsigned long long) td->td_subifd[i]);
561 : #endif
562 0 : fputc('\n', fd);
563 : }
564 :
565 : /*
566 : ** Custom tag support.
567 : */
568 : {
569 : int i;
570 : short count;
571 :
572 0 : count = (short) TIFFGetTagListCount(tif);
573 0 : for(i = 0; i < count; i++) {
574 0 : uint32 tag = TIFFGetTagListEntry(tif, i);
575 : const TIFFField *fip;
576 : uint32 value_count;
577 0 : int mem_alloc = 0;
578 : void *raw_data;
579 :
580 0 : fip = TIFFFieldWithTag(tif, tag);
581 0 : if(fip == NULL)
582 0 : continue;
583 :
584 0 : if(fip->field_passcount) {
585 0 : if (fip->field_readcount == TIFF_VARIABLE ) {
586 0 : if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
587 0 : continue;
588 0 : } else if (fip->field_readcount == TIFF_VARIABLE2 ) {
589 : uint16 small_value_count;
590 0 : if(TIFFGetField(tif, tag, &small_value_count, &raw_data) != 1)
591 0 : continue;
592 0 : value_count = small_value_count;
593 : } else {
594 0 : assert (fip->field_readcount == TIFF_VARIABLE
595 : || fip->field_readcount == TIFF_VARIABLE2);
596 0 : continue;
597 : }
598 : } else {
599 0 : if (fip->field_readcount == TIFF_VARIABLE
600 0 : || fip->field_readcount == TIFF_VARIABLE2)
601 0 : value_count = 1;
602 0 : else if (fip->field_readcount == TIFF_SPP)
603 0 : value_count = td->td_samplesperpixel;
604 : else
605 0 : value_count = fip->field_readcount;
606 0 : if (fip->field_tag == TIFFTAG_DOTRANGE
607 0 : && strcmp(fip->field_name,"DotRange") == 0) {
608 : /* TODO: This is an evil exception and should not have been
609 : handled this way ... likely best if we move it into
610 : the directory structure with an explicit field in
611 : libtiff 4.1 and assign it a FIELD_ value */
612 : static uint16 dotrange[2];
613 0 : raw_data = dotrange;
614 0 : TIFFGetField(tif, tag, dotrange+0, dotrange+1);
615 0 : } else if (fip->field_type == TIFF_ASCII
616 0 : || fip->field_readcount == TIFF_VARIABLE
617 0 : || fip->field_readcount == TIFF_VARIABLE2
618 0 : || fip->field_readcount == TIFF_SPP
619 0 : || value_count > 1) {
620 0 : if(TIFFGetField(tif, tag, &raw_data) != 1)
621 0 : continue;
622 : } else {
623 0 : raw_data = _TIFFmalloc(
624 0 : _TIFFDataSize(fip->field_type)
625 : * value_count);
626 0 : mem_alloc = 1;
627 0 : if(TIFFGetField(tif, tag, raw_data) != 1) {
628 0 : _TIFFfree(raw_data);
629 0 : continue;
630 : }
631 : }
632 : }
633 :
634 : /*
635 : * Catch the tags which needs to be specially handled
636 : * and pretty print them. If tag not handled in
637 : * _TIFFPrettyPrintField() fall down and print it as
638 : * any other tag.
639 : */
640 0 : if (!_TIFFPrettyPrintField(tif, fip, fd, tag, value_count, raw_data))
641 0 : _TIFFPrintField(fd, fip, value_count, raw_data);
642 :
643 0 : if(mem_alloc)
644 0 : _TIFFfree(raw_data);
645 : }
646 : }
647 :
648 0 : if (tif->tif_tagmethods.printdir)
649 0 : (*tif->tif_tagmethods.printdir)(tif, fd, flags);
650 :
651 0 : _TIFFFillStriles( tif );
652 :
653 0 : if ((flags & TIFFPRINT_STRIPS) &&
654 0 : TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
655 : uint32 s;
656 :
657 0 : fprintf(fd, " %lu %s:\n",
658 : (long) td->td_nstrips,
659 0 : isTiled(tif) ? "Tiles" : "Strips");
660 0 : for (s = 0; s < td->td_nstrips; s++)
661 : #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
662 : fprintf(fd, " %3lu: [%8I64u, %8I64u]\n",
663 : (unsigned long) s,
664 : (unsigned __int64) td->td_stripoffset[s],
665 : (unsigned __int64) td->td_stripbytecount[s]);
666 : #else
667 0 : fprintf(fd, " %3lu: [%8llu, %8llu]\n",
668 : (unsigned long) s,
669 0 : (unsigned long long) td->td_stripoffset[s],
670 0 : (unsigned long long) td->td_stripbytecount[s]);
671 : #endif
672 : }
673 0 : }
674 :
675 : void
676 0 : _TIFFprintAscii(FILE* fd, const char* cp)
677 : {
678 0 : _TIFFprintAsciiBounded( fd, cp, strlen(cp));
679 0 : }
680 :
681 : static void
682 0 : _TIFFprintAsciiBounded(FILE* fd, const char* cp, int max_chars)
683 : {
684 0 : for (; max_chars > 0 && *cp != '\0'; cp++, max_chars--) {
685 : const char* tp;
686 :
687 0 : if (isprint((int)*cp)) {
688 0 : fputc(*cp, fd);
689 0 : continue;
690 : }
691 0 : for (tp = "\tt\bb\rr\nn\vv"; *tp; tp++)
692 0 : if (*tp++ == *cp)
693 0 : break;
694 0 : if (*tp)
695 0 : fprintf(fd, "\\%c", *tp);
696 : else
697 0 : fprintf(fd, "\\%03o", *cp & 0xff);
698 : }
699 0 : }
700 :
701 : void
702 0 : _TIFFprintAsciiTag(FILE* fd, const char* name, const char* value)
703 : {
704 0 : fprintf(fd, " %s: \"", name);
705 0 : _TIFFprintAscii(fd, value);
706 0 : fprintf(fd, "\"\n");
707 0 : }
708 :
709 : /* vim: set ts=8 sts=8 sw=8 noet: */
710 : /*
711 : * Local Variables:
712 : * mode: c
713 : * c-basic-offset: 8
714 : * fill-column: 78
715 : * End:
716 : */
|
