| OLD | NEW |
|---|
| (Empty) |
| 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 _TIFFPrintField(FILE* fd, const TIFFField *fip, | |
| 70 uint32 value_count, void *raw_data) | |
| 71 { | |
| 72 uint32 j; | |
| 73 | |
| 74 fprintf(fd, " %s: ", fip->field_name); | |
| 75 | |
| 76 for(j = 0; j < value_count; j++) { | |
| 77 if(fip->field_type == TIFF_BYTE) | |
| 78 fprintf(fd, "%u", ((uint8 *) raw_data)[j]); | |
| 79 else if(fip->field_type == TIFF_UNDEFINED) | |
| 80 fprintf(fd, "0x%x", | |
| 81 (unsigned int) ((unsigned char *) raw_data)[j]); | |
| 82 else if(fip->field_type == TIFF_SBYTE) | |
| 83 fprintf(fd, "%d", ((int8 *) raw_data)[j]); | |
| 84 else if(fip->field_type == TIFF_SHORT) | |
| 85 fprintf(fd, "%u", ((uint16 *) raw_data)[j]); | |
| 86 else if(fip->field_type == TIFF_SSHORT) | |
| 87 fprintf(fd, "%d", ((int16 *) raw_data)[j]); | |
| 88 else if(fip->field_type == TIFF_LONG) | |
| 89 fprintf(fd, "%lu", | |
| 90 (unsigned long)((uint32 *) raw_data)[j]); | |
| 91 else if(fip->field_type == TIFF_SLONG) | |
| 92 fprintf(fd, "%ld", (long)((int32 *) raw_data)[j]); | |
| 93 else if(fip->field_type == TIFF_IFD) | |
| 94 fprintf(fd, "0x%lx", | |
| 95 (unsigned long)((uint32 *) raw_data)[j]); | |
| 96 else if(fip->field_type == TIFF_RATIONAL | |
| 97 || fip->field_type == TIFF_SRATIONAL | |
| 98 || fip->field_type == TIFF_FLOAT) | |
| 99 fprintf(fd, "%f", ((float *) raw_data)[j]); | |
| 100 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 fprintf(fd, "%llu", | |
| 106 (unsigned long long)((uint64 *) raw_data)[j]); | |
| 107 #endif | |
| 108 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 fprintf(fd, "%lld", (long long)((int64 *) raw_data)[j]); | |
| 113 #endif | |
| 114 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 fprintf(fd, "0x%llx", | |
| 120 (unsigned long long)((uint64 *) raw_data)[j]); | |
| 121 #endif | |
| 122 else if(fip->field_type == TIFF_FLOAT) | |
| 123 fprintf(fd, "%f", ((float *)raw_data)[j]); | |
| 124 else if(fip->field_type == TIFF_DOUBLE) | |
| 125 fprintf(fd, "%f", ((double *) raw_data)[j]); | |
| 126 else if(fip->field_type == TIFF_ASCII) { | |
| 127 fprintf(fd, "%s", (char *) raw_data); | |
| 128 break; | |
| 129 } | |
| 130 else { | |
| 131 fprintf(fd, "<unsupported data type in TIFFPrint>"); | |
| 132 break; | |
| 133 } | |
| 134 | |
| 135 if(j < value_count - 1) | |
| 136 fprintf(fd, ","); | |
| 137 } | |
| 138 | |
| 139 fprintf(fd, "\n"); | |
| 140 } | |
| 141 | |
| 142 static int | |
| 143 _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 if (strncmp(fip->field_name,"Tag ", 4) == 0) { | |
| 150 return 0; | |
| 151 } | |
| 152 | |
| 153 switch (tag) | |
| 154 { | |
| 155 case TIFFTAG_INKSET: | |
| 156 if (value_count == 2 && fip->field_type == TIFF_SHORT) { | |
| 157 fprintf(fd, " Ink Set: "); | |
| 158 switch (*((uint16*)raw_data)) { | |
| 159 case INKSET_CMYK: | |
| 160 fprintf(fd, "CMYK\n"); | |
| 161 break; | |
| 162 default: | |
| 163 fprintf(fd, "%u (0x%x)\n", | |
| 164 *((uint16*)raw_data), | |
| 165 *((uint16*)raw_data)); | |
| 166 break; | |
| 167 } | |
| 168 return 1; | |
| 169 } | |
| 170 return 0; | |
| 171 | |
| 172 case TIFFTAG_DOTRANGE: | |
| 173 if (value_count == 2 && fip->field_type == TIFF_SHORT) { | |
| 174 fprintf(fd, " Dot Range: %u-%u\n", | |
| 175 ((uint16*)raw_data)[0], ((uint16*)raw_da
ta)[1]); | |
| 176 return 1; | |
| 177 } | |
| 178 return 0; | |
| 179 | |
| 180 case TIFFTAG_WHITEPOINT: | |
| 181 if (value_count == 2 && fip->field_type == TIFF_RATIONAL
) { | |
| 182 fprintf(fd, " White Point: %g-%g\n", | |
| 183 ((float *)raw_data)[0], ((float *)raw_da
ta)[1]); | |
| 184 return 1; | |
| 185 } | |
| 186 return 0; | |
| 187 | |
| 188 case TIFFTAG_XMLPACKET: | |
| 189 { | |
| 190 uint32 i; | |
| 191 | |
| 192 fprintf(fd, " XMLPacket (XMP Metadata):\n" ); | |
| 193 for(i = 0; i < value_count; i++) | |
| 194 fputc(((char *)raw_data)[i], fd); | |
| 195 fprintf( fd, "\n" ); | |
| 196 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 fprintf(fd, | |
| 204 " RichTIFFIPTC Data: <present>, %lu bytes\n", | |
| 205 (unsigned long) value_count * 4); | |
| 206 return 1; | |
| 207 | |
| 208 case TIFFTAG_PHOTOSHOP: | |
| 209 fprintf(fd, " Photoshop Data: <present>, %lu bytes\n", | |
| 210 (unsigned long) value_count); | |
| 211 return 1; | |
| 212 | |
| 213 case TIFFTAG_ICCPROFILE: | |
| 214 fprintf(fd, " ICC Profile: <present>, %lu bytes\n", | |
| 215 (unsigned long) value_count); | |
| 216 return 1; | |
| 217 | |
| 218 case TIFFTAG_STONITS: | |
| 219 if (value_count == 1 && fip->field_type == TIFF_DOUBLE)
{ | |
| 220 fprintf(fd, | |
| 221 " Sample to Nits conversion factor: %.4
e\n", | |
| 222 *((double*)raw_data)); | |
| 223 return 1; | |
| 224 } | |
| 225 return 0; | |
| 226 } | |
| 227 | |
| 228 return 0; | |
| 229 } | |
| 230 | |
| 231 /* | |
| 232 * Print the contents of the current directory | |
| 233 * to the specified stdio file stream. | |
| 234 */ | |
| 235 void | |
| 236 TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) | |
| 237 { | |
| 238 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 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 if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) { | |
| 253 fprintf(fd, " Subfile Type:"); | |
| 254 sep = " "; | |
| 255 if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) { | |
| 256 fprintf(fd, "%sreduced-resolution image", sep); | |
| 257 sep = "/"; | |
| 258 } | |
| 259 if (td->td_subfiletype & FILETYPE_PAGE) { | |
| 260 fprintf(fd, "%smulti-page document", sep); | |
| 261 sep = "/"; | |
| 262 } | |
| 263 if (td->td_subfiletype & FILETYPE_MASK) | |
| 264 fprintf(fd, "%stransparency mask", sep); | |
| 265 fprintf(fd, " (%lu = 0x%lx)\n", | |
| 266 (long) td->td_subfiletype, (long) td->td_subfiletype); | |
| 267 } | |
| 268 if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) { | |
| 269 fprintf(fd, " Image Width: %lu Image Length: %lu", | |
| 270 (unsigned long) td->td_imagewidth, (unsigned long) td->td_im
agelength); | |
| 271 if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH)) | |
| 272 fprintf(fd, " Image Depth: %lu", | |
| 273 (unsigned long) td->td_imagedepth); | |
| 274 fprintf(fd, "\n"); | |
| 275 } | |
| 276 if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) { | |
| 277 fprintf(fd, " Tile Width: %lu Tile Length: %lu", | |
| 278 (unsigned long) td->td_tilewidth, (unsigned long) td->td_til
elength); | |
| 279 if (TIFFFieldSet(tif,FIELD_TILEDEPTH)) | |
| 280 fprintf(fd, " Tile Depth: %lu", | |
| 281 (unsigned long) td->td_tiledepth); | |
| 282 fprintf(fd, "\n"); | |
| 283 } | |
| 284 if (TIFFFieldSet(tif,FIELD_RESOLUTION)) { | |
| 285 fprintf(fd, " Resolution: %g, %g", | |
| 286 td->td_xresolution, td->td_yresolution); | |
| 287 if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) { | |
| 288 switch (td->td_resolutionunit) { | |
| 289 case RESUNIT_NONE: | |
| 290 fprintf(fd, " (unitless)"); | |
| 291 break; | |
| 292 case RESUNIT_INCH: | |
| 293 fprintf(fd, " pixels/inch"); | |
| 294 break; | |
| 295 case RESUNIT_CENTIMETER: | |
| 296 fprintf(fd, " pixels/cm"); | |
| 297 break; | |
| 298 default: | |
| 299 fprintf(fd, " (unit %u = 0x%x)", | |
| 300 td->td_resolutionunit, | |
| 301 td->td_resolutionunit); | |
| 302 break; | |
| 303 } | |
| 304 } | |
| 305 fprintf(fd, "\n"); | |
| 306 } | |
| 307 if (TIFFFieldSet(tif,FIELD_POSITION)) | |
| 308 fprintf(fd, " Position: %g, %g\n", | |
| 309 td->td_xposition, td->td_yposition); | |
| 310 if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE)) | |
| 311 fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample); | |
| 312 if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) { | |
| 313 fprintf(fd, " Sample Format: "); | |
| 314 switch (td->td_sampleformat) { | |
| 315 case SAMPLEFORMAT_VOID: | |
| 316 fprintf(fd, "void\n"); | |
| 317 break; | |
| 318 case SAMPLEFORMAT_INT: | |
| 319 fprintf(fd, "signed integer\n"); | |
| 320 break; | |
| 321 case SAMPLEFORMAT_UINT: | |
| 322 fprintf(fd, "unsigned integer\n"); | |
| 323 break; | |
| 324 case SAMPLEFORMAT_IEEEFP: | |
| 325 fprintf(fd, "IEEE floating point\n"); | |
| 326 break; | |
| 327 case SAMPLEFORMAT_COMPLEXINT: | |
| 328 fprintf(fd, "complex signed integer\n"); | |
| 329 break; | |
| 330 case SAMPLEFORMAT_COMPLEXIEEEFP: | |
| 331 fprintf(fd, "complex IEEE floating point\n"); | |
| 332 break; | |
| 333 default: | |
| 334 fprintf(fd, "%u (0x%x)\n", | |
| 335 td->td_sampleformat, td->td_sampleformat); | |
| 336 break; | |
| 337 } | |
| 338 } | |
| 339 if (TIFFFieldSet(tif,FIELD_COMPRESSION)) { | |
| 340 const TIFFCodec* c = TIFFFindCODEC(td->td_compression); | |
| 341 fprintf(fd, " Compression Scheme: "); | |
| 342 if (c) | |
| 343 fprintf(fd, "%s\n", c->name); | |
| 344 else | |
| 345 fprintf(fd, "%u (0x%x)\n", | |
| 346 td->td_compression, td->td_compression); | |
| 347 } | |
| 348 if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) { | |
| 349 fprintf(fd, " Photometric Interpretation: "); | |
| 350 if (td->td_photometric < NPHOTONAMES) | |
| 351 fprintf(fd, "%s\n", photoNames[td->td_photometric]); | |
| 352 else { | |
| 353 switch (td->td_photometric) { | |
| 354 case PHOTOMETRIC_LOGL: | |
| 355 fprintf(fd, "CIE Log2(L)\n"); | |
| 356 break; | |
| 357 case PHOTOMETRIC_LOGLUV: | |
| 358 fprintf(fd, "CIE Log2(L) (u',v')\n"); | |
| 359 break; | |
| 360 default: | |
| 361 fprintf(fd, "%u (0x%x)\n", | |
| 362 td->td_photometric, td->td_photometric); | |
| 363 break; | |
| 364 } | |
| 365 } | |
| 366 } | |
| 367 if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) { | |
| 368 fprintf(fd, " Extra Samples: %u<", td->td_extrasamples); | |
| 369 sep = ""; | |
| 370 for (i = 0; i < td->td_extrasamples; i++) { | |
| 371 switch (td->td_sampleinfo[i]) { | |
| 372 case EXTRASAMPLE_UNSPECIFIED: | |
| 373 fprintf(fd, "%sunspecified", sep); | |
| 374 break; | |
| 375 case EXTRASAMPLE_ASSOCALPHA: | |
| 376 fprintf(fd, "%sassoc-alpha", sep); | |
| 377 break; | |
| 378 case EXTRASAMPLE_UNASSALPHA: | |
| 379 fprintf(fd, "%sunassoc-alpha", sep); | |
| 380 break; | |
| 381 default: | |
| 382 fprintf(fd, "%s%u (0x%x)", sep, | |
| 383 td->td_sampleinfo[i], td->td_sampleinfo[i]); | |
| 384 break; | |
| 385 } | |
| 386 sep = ", "; | |
| 387 } | |
| 388 fprintf(fd, ">\n"); | |
| 389 } | |
| 390 if (TIFFFieldSet(tif,FIELD_INKNAMES)) { | |
| 391 char* cp; | |
| 392 fprintf(fd, " Ink Names: "); | |
| 393 i = td->td_samplesperpixel; | |
| 394 sep = ""; | |
| 395 for (cp = td->td_inknames; | |
| 396 i > 0 && cp < td->td_inknames + td->td_inknameslen; | |
| 397 cp = strchr(cp,'\0')+1, i--) { | |
| 398 int max_chars = | |
| 399 (int)(td->td_inknameslen - (cp - td->td_inknames
)); | |
| 400 fputs(sep, fd); | |
| 401 _TIFFprintAsciiBounded(fd, cp, max_chars); | |
| 402 sep = ", "; | |
| 403 } | |
| 404 fputs("\n", fd); | |
| 405 } | |
| 406 if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) { | |
| 407 fprintf(fd, " Thresholding: "); | |
| 408 switch (td->td_threshholding) { | |
| 409 case THRESHHOLD_BILEVEL: | |
| 410 fprintf(fd, "bilevel art scan\n"); | |
| 411 break; | |
| 412 case THRESHHOLD_HALFTONE: | |
| 413 fprintf(fd, "halftone or dithered scan\n"); | |
| 414 break; | |
| 415 case THRESHHOLD_ERRORDIFFUSE: | |
| 416 fprintf(fd, "error diffused\n"); | |
| 417 break; | |
| 418 default: | |
| 419 fprintf(fd, "%u (0x%x)\n", | |
| 420 td->td_threshholding, td->td_threshholding); | |
| 421 break; | |
| 422 } | |
| 423 } | |
| 424 if (TIFFFieldSet(tif,FIELD_FILLORDER)) { | |
| 425 fprintf(fd, " FillOrder: "); | |
| 426 switch (td->td_fillorder) { | |
| 427 case FILLORDER_MSB2LSB: | |
| 428 fprintf(fd, "msb-to-lsb\n"); | |
| 429 break; | |
| 430 case FILLORDER_LSB2MSB: | |
| 431 fprintf(fd, "lsb-to-msb\n"); | |
| 432 break; | |
| 433 default: | |
| 434 fprintf(fd, "%u (0x%x)\n", | |
| 435 td->td_fillorder, td->td_fillorder); | |
| 436 break; | |
| 437 } | |
| 438 } | |
| 439 if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING)) | |
| 440 { | |
| 441 fprintf(fd, " YCbCr Subsampling: %u, %u\n", | |
| 442 td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1] )
; | |
| 443 } | |
| 444 if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) { | |
| 445 fprintf(fd, " YCbCr Positioning: "); | |
| 446 switch (td->td_ycbcrpositioning) { | |
| 447 case YCBCRPOSITION_CENTERED: | |
| 448 fprintf(fd, "centered\n"); | |
| 449 break; | |
| 450 case YCBCRPOSITION_COSITED: | |
| 451 fprintf(fd, "cosited\n"); | |
| 452 break; | |
| 453 default: | |
| 454 fprintf(fd, "%u (0x%x)\n", | |
| 455 td->td_ycbcrpositioning, td->td_ycbcrpositioning); | |
| 456 break; | |
| 457 } | |
| 458 } | |
| 459 if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS)) | |
| 460 fprintf(fd, " Halftone Hints: light %u dark %u\n", | |
| 461 td->td_halftonehints[0], td->td_halftonehints[1]); | |
| 462 if (TIFFFieldSet(tif,FIELD_ORIENTATION)) { | |
| 463 fprintf(fd, " Orientation: "); | |
| 464 if (td->td_orientation < NORIENTNAMES) | |
| 465 fprintf(fd, "%s\n", orientNames[td->td_orientation]); | |
| 466 else | |
| 467 fprintf(fd, "%u (0x%x)\n", | |
| 468 td->td_orientation, td->td_orientation); | |
| 469 } | |
| 470 if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL)) | |
| 471 fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel); | |
| 472 if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) { | |
| 473 fprintf(fd, " Rows/Strip: "); | |
| 474 if (td->td_rowsperstrip == (uint32) -1) | |
| 475 fprintf(fd, "(infinite)\n"); | |
| 476 else | |
| 477 fprintf(fd, "%lu\n", (unsigned long) td->td_rowsperstrip
); | |
| 478 } | |
| 479 if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE)) | |
| 480 fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue); | |
| 481 if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE)) | |
| 482 fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue); | |
| 483 if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) { | |
| 484 int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplespe
rpixel : 1; | |
| 485 fprintf(fd, " SMin Sample Value:"); | |
| 486 for (i = 0; i < count; ++i) | |
| 487 fprintf(fd, " %g", td->td_sminsamplevalue[i]); | |
| 488 fprintf(fd, "\n"); | |
| 489 } | |
| 490 if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) { | |
| 491 int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplespe
rpixel : 1; | |
| 492 fprintf(fd, " SMax Sample Value:"); | |
| 493 for (i = 0; i < count; ++i) | |
| 494 fprintf(fd, " %g", td->td_smaxsamplevalue[i]); | |
| 495 fprintf(fd, "\n"); | |
| 496 } | |
| 497 if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) { | |
| 498 fprintf(fd, " Planar Configuration: "); | |
| 499 switch (td->td_planarconfig) { | |
| 500 case PLANARCONFIG_CONTIG: | |
| 501 fprintf(fd, "single image plane\n"); | |
| 502 break; | |
| 503 case PLANARCONFIG_SEPARATE: | |
| 504 fprintf(fd, "separate image planes\n"); | |
| 505 break; | |
| 506 default: | |
| 507 fprintf(fd, "%u (0x%x)\n", | |
| 508 td->td_planarconfig, td->td_planarconfig); | |
| 509 break; | |
| 510 } | |
| 511 } | |
| 512 if (TIFFFieldSet(tif,FIELD_PAGENUMBER)) | |
| 513 fprintf(fd, " Page Number: %u-%u\n", | |
| 514 td->td_pagenumber[0], td->td_pagenumber[1]); | |
| 515 if (TIFFFieldSet(tif,FIELD_COLORMAP)) { | |
| 516 fprintf(fd, " Color Map: "); | |
| 517 if (flags & TIFFPRINT_COLORMAP) { | |
| 518 fprintf(fd, "\n"); | |
| 519 n = 1L<<td->td_bitspersample; | |
| 520 for (l = 0; l < n; l++) | |
| 521 fprintf(fd, " %5lu: %5u %5u %5u\n", | |
| 522 l, | |
| 523 td->td_colormap[0][l], | |
| 524 td->td_colormap[1][l], | |
| 525 td->td_colormap[2][l]); | |
| 526 } else | |
| 527 fprintf(fd, "(present)\n"); | |
| 528 } | |
| 529 if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) { | |
| 530 fprintf(fd, " Reference Black/White:\n"); | |
| 531 for (i = 0; i < 3; i++) | |
| 532 fprintf(fd, " %2d: %5g %5g\n", i, | |
| 533 td->td_refblackwhite[2*i+0], | |
| 534 td->td_refblackwhite[2*i+1]); | |
| 535 } | |
| 536 if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) { | |
| 537 fprintf(fd, " Transfer Function: "); | |
| 538 if (flags & TIFFPRINT_CURVES) { | |
| 539 fprintf(fd, "\n"); | |
| 540 n = 1L<<td->td_bitspersample; | |
| 541 for (l = 0; l < n; l++) { | |
| 542 fprintf(fd, " %2lu: %5u", | |
| 543 l, td->td_transferfunction[0][l]); | |
| 544 for (i = 1; i < td->td_samplesperpixel; i++) | |
| 545 fprintf(fd, " %5u", | |
| 546 td->td_transferfunction[i][l]); | |
| 547 fputc('\n', fd); | |
| 548 } | |
| 549 } else | |
| 550 fprintf(fd, "(present)\n"); | |
| 551 } | |
| 552 if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) { | |
| 553 fprintf(fd, " SubIFD Offsets:"); | |
| 554 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 fprintf(fd, " %5llu", | |
| 560 (unsigned long long) td->td_subifd[i]); | |
| 561 #endif | |
| 562 fputc('\n', fd); | |
| 563 } | |
| 564 | |
| 565 /* | |
| 566 ** Custom tag support. | |
| 567 */ | |
| 568 { | |
| 569 int i; | |
| 570 short count; | |
| 571 | |
| 572 count = (short) TIFFGetTagListCount(tif); | |
| 573 for(i = 0; i < count; i++) { | |
| 574 uint32 tag = TIFFGetTagListEntry(tif, i); | |
| 575 const TIFFField *fip; | |
| 576 uint32 value_count; | |
| 577 int mem_alloc = 0; | |
| 578 void *raw_data; | |
| 579 | |
| 580 fip = TIFFFieldWithTag(tif, tag); | |
| 581 if(fip == NULL) | |
| 582 continue; | |
| 583 | |
| 584 if(fip->field_passcount) { | |
| 585 if (fip->field_readcount == TIFF_VARIABLE ) { | |
| 586 if(TIFFGetField(tif, tag, &value_count,
&raw_data) != 1) | |
| 587 continue; | |
| 588 } else if (fip->field_readcount == TIFF_VARIABLE
2 ) { | |
| 589 uint16 small_value_count; | |
| 590 if(TIFFGetField(tif, tag, &small_value_c
ount, &raw_data) != 1) | |
| 591 continue; | |
| 592 value_count = small_value_count; | |
| 593 } else { | |
| 594 assert (fip->field_readcount == TIFF_VAR
IABLE | |
| 595 || fip->field_readcount == TIFF_
VARIABLE2); | |
| 596 continue; | |
| 597 } | |
| 598 } else { | |
| 599 if (fip->field_readcount == TIFF_VARIABLE | |
| 600 || fip->field_readcount == TIFF_VARIABLE2) | |
| 601 value_count = 1; | |
| 602 else if (fip->field_readcount == TIFF_SPP) | |
| 603 value_count = td->td_samplesperpixel; | |
| 604 else | |
| 605 value_count = fip->field_readcount; | |
| 606 if (fip->field_tag == TIFFTAG_DOTRANGE | |
| 607 && strcmp(fip->field_name,"DotRange") == 0)
{ | |
| 608 /* TODO: This is an evil exception and s
hould not have been | |
| 609 handled this way ... likely best if w
e move it into | |
| 610 the directory structure with an expli
cit field in | |
| 611 libtiff 4.1 and assign it a FIELD_ va
lue */ | |
| 612 static uint16 dotrange[2]; | |
| 613 raw_data = dotrange; | |
| 614 TIFFGetField(tif, tag, dotrange+0, dotra
nge+1); | |
| 615 } else if (fip->field_type == TIFF_ASCII | |
| 616 || fip->field_readcount == TIFF_VARIA
BLE | |
| 617 || fip->field_readcount == TIFF_VARIA
BLE2 | |
| 618 || fip->field_readcount == TIFF_SPP | |
| 619 || value_count > 1) { | |
| 620 if(TIFFGetField(tif, tag, &raw_data) !=
1) | |
| 621 continue; | |
| 622 } else { | |
| 623 raw_data = _TIFFmalloc( | |
| 624 _TIFFDataSize(fip->field_type) | |
| 625 * value_count); | |
| 626 mem_alloc = 1; | |
| 627 if(TIFFGetField(tif, tag, raw_data) != 1
) { | |
| 628 _TIFFfree(raw_data); | |
| 629 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 if (!_TIFFPrettyPrintField(tif, fip, fd, tag, value_coun
t, raw_data)) | |
| 641 _TIFFPrintField(fd, fip, value_count, raw_data); | |
| 642 | |
| 643 if(mem_alloc) | |
| 644 _TIFFfree(raw_data); | |
| 645 } | |
| 646 } | |
| 647 | |
| 648 if (tif->tif_tagmethods.printdir) | |
| 649 (*tif->tif_tagmethods.printdir)(tif, fd, flags); | |
| 650 | |
| 651 _TIFFFillStriles( tif ); | |
| 652 | |
| 653 if ((flags & TIFFPRINT_STRIPS) && | |
| 654 TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) { | |
| 655 uint32 s; | |
| 656 | |
| 657 fprintf(fd, " %lu %s:\n", | |
| 658 (long) td->td_nstrips, | |
| 659 isTiled(tif) ? "Tiles" : "Strips"); | |
| 660 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 fprintf(fd, " %3lu: [%8llu, %8llu]\n", | |
| 668 (unsigned long) s, | |
| 669 (unsigned long long) td->td_stripoffset[s], | |
| 670 (unsigned long long) td->td_stripbytecount[s]); | |
| 671 #endif | |
| 672 } | |
| 673 } | |
| 674 | |
| 675 void | |
| 676 _TIFFprintAscii(FILE* fd, const char* cp) | |
| 677 { | |
| 678 _TIFFprintAsciiBounded( fd, cp, (int)strlen(cp)); | |
| 679 } | |
| 680 | |
| 681 static void | |
| 682 _TIFFprintAsciiBounded(FILE* fd, const char* cp, int max_chars) | |
| 683 { | |
| 684 for (; max_chars > 0 && *cp != '\0'; cp++, max_chars--) { | |
| 685 const char* tp; | |
| 686 | |
| 687 if (isprint((int)*cp)) { | |
| 688 fputc(*cp, fd); | |
| 689 continue; | |
| 690 } | |
| 691 for (tp = "\tt\bb\rr\nn\vv"; *tp; tp++) | |
| 692 if (*tp++ == *cp) | |
| 693 break; | |
| 694 if (*tp) | |
| 695 fprintf(fd, "\\%c", *tp); | |
| 696 else | |
| 697 fprintf(fd, "\\%03o", *cp & 0xff); | |
| 698 } | |
| 699 } | |
| 700 | |
| 701 void | |
| 702 _TIFFprintAsciiTag(FILE* fd, const char* name, const char* value) | |
| 703 { | |
| 704 fprintf(fd, " %s: \"", name); | |
| 705 _TIFFprintAscii(fd, value); | |
| 706 fprintf(fd, "\"\n"); | |
| 707 } | |
| 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 */ | |
| 717 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1563103002:
XFA: Upgrade to libtiff 4.0.6. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@xfa