1 /* $Id: tif_dir.c,v 1.113 2012-06-14 20:32:53 fwarmerdam 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 Tag Get & Set Routines. 31 * (and also some miscellaneous stuff) 32 */ 33 #include "tiffiop.h" 34 35 /* 36 * These are used in the backwards compatibility code... 37 */ 38 #define DATATYPE_VOID 0 /* !untyped data */ 39 #define DATATYPE_INT 1 /* !signed integer data */ 40 #define DATATYPE_UINT 2 /* !unsigned integer data */ 41 #define DATATYPE_IEEEFP 3 /* !IEEE floating point data */ 42 43 static void 44 setByteArray(void** vpp, void* vp, size_t nmemb, size_t elem_size) 45 { 46 if (*vpp) 47 _TIFFfree(*vpp), *vpp = 0; 48 if (vp) { 49 tmsize_t bytes = (tmsize_t)(nmemb * elem_size); 50 if (elem_size && bytes / elem_size == nmemb) 51 *vpp = (void*) _TIFFmalloc(bytes); 52 if (*vpp) 53 _TIFFmemcpy(*vpp, vp, bytes); 54 } 55 } 56 void _TIFFsetByteArray(void** vpp, void* vp, uint32 n) 57 { setByteArray(vpp, vp, n, 1); } 58 void _TIFFsetString(char** cpp, char* cp) 59 { setByteArray((void**) cpp, (void*) cp, strlen(cp)+1, 1); } 60 void _TIFFsetNString(char** cpp, char* cp, uint32 n) 61 { setByteArray((void**) cpp, (void*) cp, n, 1); } 62 void _TIFFsetShortArray(uint16** wpp, uint16* wp, uint32 n) 63 { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); } 64 void _TIFFsetLongArray(uint32** lpp, uint32* lp, uint32 n) 65 { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); } 66 void _TIFFsetLong8Array(uint64** lpp, uint64* lp, uint32 n) 67 { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint64)); } 68 void _TIFFsetFloatArray(float** fpp, float* fp, uint32 n) 69 { setByteArray((void**) fpp, (void*) fp, n, sizeof (float)); } 70 void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n) 71 { setByteArray((void**) dpp, (void*) dp, n, sizeof (double)); } 72 73 static void 74 setDoubleArrayOneValue(double** vpp, double value, size_t nmemb) 75 { 76 if (*vpp) 77 _TIFFfree(*vpp); 78 *vpp = _TIFFmalloc(nmemb*sizeof(double)); 79 if (*vpp) 80 { 81 while (nmemb--) 82 ((double*)*vpp)[nmemb] = value; 83 } 84 } 85 86 /* 87 * Install extra samples information. 88 */ 89 static int 90 setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v) 91 { 92 /* XXX: Unassociated alpha data == 999 is a known Corel Draw bug, see below */ 93 #define EXTRASAMPLE_COREL_UNASSALPHA 999 94 95 uint16* va; 96 uint32 i; 97 98 *v = (uint16) va_arg(ap, uint16_vap); 99 if ((uint16) *v > td->td_samplesperpixel) 100 return 0; 101 va = va_arg(ap, uint16*); 102 if (*v > 0 && va == NULL) /* typically missing param */ 103 return 0; 104 for (i = 0; i < *v; i++) { 105 if (va[i] > EXTRASAMPLE_UNASSALPHA) { 106 /* 107 * XXX: Corel Draw is known to produce incorrect 108 * ExtraSamples tags which must be patched here if we 109 * want to be able to open some of the damaged TIFF 110 * files: 111 */ 112 if (va[i] == EXTRASAMPLE_COREL_UNASSALPHA) 113 va[i] = EXTRASAMPLE_UNASSALPHA; 114 else 115 return 0; 116 } 117 } 118 td->td_extrasamples = (uint16) *v; 119 _TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples); 120 return 1; 121 122 #undef EXTRASAMPLE_COREL_UNASSALPHA 123 } 124 125 /* 126 * Confirm we have "samplesperpixel" ink names separated by \0. Returns 127 * zero if the ink names are not as expected. 128 */ 129 static uint32 130 checkInkNamesString(TIFF* tif, uint32 slen, const char* s) 131 { 132 TIFFDirectory* td = &tif->tif_dir; 133 uint16 i = td->td_samplesperpixel; 134 135 if (slen > 0) { 136 const char* ep = s+slen; 137 const char* cp = s; 138 for (; i > 0; i--) { 139 for (; cp < ep && *cp != '\0'; cp++) {} 140 if (cp >= ep) 141 goto bad; 142 cp++; /* skip \0 */ 143 } 144 return ((uint32)(cp-s)); 145 } 146 bad: 147 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", 148 "%s: Invalid InkNames value; expecting %d names, found %d", 149 tif->tif_name, 150 td->td_samplesperpixel, 151 td->td_samplesperpixel-i); 152 return (0); 153 } 154 155 static int 156 _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap) 157 { 158 static const char module[] = "_TIFFVSetField"; 159 160 TIFFDirectory* td = &tif->tif_dir; 161 int status = 1; 162 uint32 v32, i, v; 163 char* s; 164 const TIFFField *fip = TIFFFindField(tif, tag, TIFF_ANY); 165 uint32 standard_tag = tag; 166 167 /* 168 * We want to force the custom code to be used for custom 169 * fields even if the tag happens to match a well known 170 * one - important for reinterpreted handling of standard 171 * tag values in custom directories (ie. EXIF) 172 */ 173 if (fip->field_bit == FIELD_CUSTOM) { 174 standard_tag = 0; 175 } 176 177 switch (standard_tag) { 178 case TIFFTAG_SUBFILETYPE: 179 td->td_subfiletype = (uint32) va_arg(ap, uint32); 180 break; 181 case TIFFTAG_IMAGEWIDTH: 182 td->td_imagewidth = (uint32) va_arg(ap, uint32); 183 break; 184 case TIFFTAG_IMAGELENGTH: 185 td->td_imagelength = (uint32) va_arg(ap, uint32); 186 break; 187 case TIFFTAG_BITSPERSAMPLE: 188 td->td_bitspersample = (uint16) va_arg(ap, uint16_vap); 189 /* 190 * If the data require post-decoding processing to byte-swap 191 * samples, set it up here. Note that since tags are required 192 * to be ordered, compression code can override this behaviour 193 * in the setup method if it wants to roll the post decoding 194 * work in with its normal work. 195 */ 196 if (tif->tif_flags & TIFF_SWAB) { 197 if (td->td_bitspersample == 8) 198 tif->tif_postdecode = _TIFFNoPostDecode; 199 else if (td->td_bitspersample == 16) 200 tif->tif_postdecode = _TIFFSwab16BitData; 201 else if (td->td_bitspersample == 24) 202 tif->tif_postdecode = _TIFFSwab24BitData; 203 else if (td->td_bitspersample == 32) 204 tif->tif_postdecode = _TIFFSwab32BitData; 205 else if (td->td_bitspersample == 64) 206 tif->tif_postdecode = _TIFFSwab64BitData; 207 else if (td->td_bitspersample == 128) /* two 64's */ 208 tif->tif_postdecode = _TIFFSwab64BitData; 209 } 210 break; 211 case TIFFTAG_COMPRESSION: 212 v = (uint16) va_arg(ap, uint16_vap); 213 /* 214 * If we're changing the compression scheme, the notify the 215 * previous module so that it can cleanup any state it's 216 * setup. 217 */ 218 if (TIFFFieldSet(tif, FIELD_COMPRESSION)) { 219 if ((uint32)td->td_compression == v) 220 break; 221 (*tif->tif_cleanup)(tif); 222 tif->tif_flags &= ~TIFF_CODERSETUP; 223 } 224 /* 225 * Setup new compression routine state. 226 */ 227 if( (status = TIFFSetCompressionScheme(tif, v)) != 0 ) 228 td->td_compression = (uint16) v; 229 else 230 status = 0; 231 break; 232 case TIFFTAG_PHOTOMETRIC: 233 td->td_photometric = (uint16) va_arg(ap, uint16_vap); 234 break; 235 case TIFFTAG_THRESHHOLDING: 236 td->td_threshholding = (uint16) va_arg(ap, uint16_vap); 237 break; 238 case TIFFTAG_FILLORDER: 239 v = (uint16) va_arg(ap, uint16_vap); 240 if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB) 241 goto badvalue; 242 td->td_fillorder = (uint16) v; 243 break; 244 case TIFFTAG_ORIENTATION: 245 v = (uint16) va_arg(ap, uint16_vap); 246 if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) 247 goto badvalue; 248 else 249 td->td_orientation = (uint16) v; 250 break; 251 case TIFFTAG_SAMPLESPERPIXEL: 252 v = (uint16) va_arg(ap, uint16_vap); 253 if (v == 0) 254 goto badvalue; 255 td->td_samplesperpixel = (uint16) v; 256 break; 257 case TIFFTAG_ROWSPERSTRIP: 258 v32 = (uint32) va_arg(ap, uint32); 259 if (v32 == 0) 260 goto badvalue32; 261 td->td_rowsperstrip = v32; 262 if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) { 263 td->td_tilelength = v32; 264 td->td_tilewidth = td->td_imagewidth; 265 } 266 break; 267 case TIFFTAG_MINSAMPLEVALUE: 268 td->td_minsamplevalue = (uint16) va_arg(ap, uint16_vap); 269 break; 270 case TIFFTAG_MAXSAMPLEVALUE: 271 td->td_maxsamplevalue = (uint16) va_arg(ap, uint16_vap); 272 break; 273 case TIFFTAG_SMINSAMPLEVALUE: 274 if (tif->tif_flags & TIFF_PERSAMPLE) 275 _TIFFsetDoubleArray(&td->td_sminsamplevalue, va_arg(ap, double*), td->td_samplesperpixel); 276 else 277 setDoubleArrayOneValue(&td->td_sminsamplevalue, va_arg(ap, double), td->td_samplesperpixel); 278 break; 279 case TIFFTAG_SMAXSAMPLEVALUE: 280 if (tif->tif_flags & TIFF_PERSAMPLE) 281 _TIFFsetDoubleArray(&td->td_smaxsamplevalue, va_arg(ap, double*), td->td_samplesperpixel); 282 else 283 setDoubleArrayOneValue(&td->td_smaxsamplevalue, va_arg(ap, double), td->td_samplesperpixel); 284 break; 285 case TIFFTAG_XRESOLUTION: 286 td->td_xresolution = (float) va_arg(ap, double); 287 break; 288 case TIFFTAG_YRESOLUTION: 289 td->td_yresolution = (float) va_arg(ap, double); 290 break; 291 case TIFFTAG_PLANARCONFIG: 292 v = (uint16) va_arg(ap, uint16_vap); 293 if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE) 294 goto badvalue; 295 td->td_planarconfig = (uint16) v; 296 break; 297 case TIFFTAG_XPOSITION: 298 td->td_xposition = (float) va_arg(ap, double); 299 break; 300 case TIFFTAG_YPOSITION: 301 td->td_yposition = (float) va_arg(ap, double); 302 break; 303 case TIFFTAG_RESOLUTIONUNIT: 304 v = (uint16) va_arg(ap, uint16_vap); 305 if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v) 306 goto badvalue; 307 td->td_resolutionunit = (uint16) v; 308 break; 309 case TIFFTAG_PAGENUMBER: 310 td->td_pagenumber[0] = (uint16) va_arg(ap, uint16_vap); 311 td->td_pagenumber[1] = (uint16) va_arg(ap, uint16_vap); 312 break; 313 case TIFFTAG_HALFTONEHINTS: 314 td->td_halftonehints[0] = (uint16) va_arg(ap, uint16_vap); 315 td->td_halftonehints[1] = (uint16) va_arg(ap, uint16_vap); 316 break; 317 case TIFFTAG_COLORMAP: 318 v32 = (uint32)(1L<<td->td_bitspersample); 319 _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32); 320 _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32); 321 _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32); 322 break; 323 case TIFFTAG_EXTRASAMPLES: 324 if (!setExtraSamples(td, ap, &v)) 325 goto badvalue; 326 break; 327 case TIFFTAG_MATTEING: 328 td->td_extrasamples = (((uint16) va_arg(ap, uint16_vap)) != 0); 329 if (td->td_extrasamples) { 330 uint16 sv = EXTRASAMPLE_ASSOCALPHA; 331 _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1); 332 } 333 break; 334 case TIFFTAG_TILEWIDTH: 335 v32 = (uint32) va_arg(ap, uint32); 336 if (v32 % 16) { 337 if (tif->tif_mode != O_RDONLY) 338 goto badvalue32; 339 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, 340 "Nonstandard tile width %d, convert file", v32); 341 } 342 td->td_tilewidth = v32; 343 tif->tif_flags |= TIFF_ISTILED; 344 break; 345 case TIFFTAG_TILELENGTH: 346 v32 = (uint32) va_arg(ap, uint32); 347 if (v32 % 16) { 348 if (tif->tif_mode != O_RDONLY) 349 goto badvalue32; 350 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, 351 "Nonstandard tile length %d, convert file", v32); 352 } 353 td->td_tilelength = v32; 354 tif->tif_flags |= TIFF_ISTILED; 355 break; 356 case TIFFTAG_TILEDEPTH: 357 v32 = (uint32) va_arg(ap, uint32); 358 if (v32 == 0) 359 goto badvalue32; 360 td->td_tiledepth = v32; 361 break; 362 case TIFFTAG_DATATYPE: 363 v = (uint16) va_arg(ap, uint16_vap); 364 switch (v) { 365 case DATATYPE_VOID: v = SAMPLEFORMAT_VOID; break; 366 case DATATYPE_INT: v = SAMPLEFORMAT_INT; break; 367 case DATATYPE_UINT: v = SAMPLEFORMAT_UINT; break; 368 case DATATYPE_IEEEFP: v = SAMPLEFORMAT_IEEEFP;break; 369 default: goto badvalue; 370 } 371 td->td_sampleformat = (uint16) v; 372 break; 373 case TIFFTAG_SAMPLEFORMAT: 374 v = (uint16) va_arg(ap, uint16_vap); 375 if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_COMPLEXIEEEFP < v) 376 goto badvalue; 377 td->td_sampleformat = (uint16) v; 378 379 /* Try to fix up the SWAB function for complex data. */ 380 if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT 381 && td->td_bitspersample == 32 382 && tif->tif_postdecode == _TIFFSwab32BitData ) 383 tif->tif_postdecode = _TIFFSwab16BitData; 384 else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT 385 || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP) 386 && td->td_bitspersample == 64 387 && tif->tif_postdecode == _TIFFSwab64BitData ) 388 tif->tif_postdecode = _TIFFSwab32BitData; 389 break; 390 case TIFFTAG_IMAGEDEPTH: 391 td->td_imagedepth = (uint32) va_arg(ap, uint32); 392 break; 393 case TIFFTAG_SUBIFD: 394 if ((tif->tif_flags & TIFF_INSUBIFD) == 0) { 395 td->td_nsubifd = (uint16) va_arg(ap, uint16_vap); 396 _TIFFsetLong8Array(&td->td_subifd, (uint64*) va_arg(ap, uint64*), 397 (long) td->td_nsubifd); 398 } else { 399 TIFFErrorExt(tif->tif_clientdata, module, 400 "%s: Sorry, cannot nest SubIFDs", 401 tif->tif_name); 402 status = 0; 403 } 404 break; 405 case TIFFTAG_YCBCRPOSITIONING: 406 td->td_ycbcrpositioning = (uint16) va_arg(ap, uint16_vap); 407 break; 408 case TIFFTAG_YCBCRSUBSAMPLING: 409 td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, uint16_vap); 410 td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, uint16_vap); 411 break; 412 case TIFFTAG_TRANSFERFUNCTION: 413 v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1; 414 for (i = 0; i < v; i++) 415 _TIFFsetShortArray(&td->td_transferfunction[i], 416 va_arg(ap, uint16*), 1L<<td->td_bitspersample); 417 break; 418 case TIFFTAG_REFERENCEBLACKWHITE: 419 /* XXX should check for null range */ 420 _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6); 421 break; 422 case TIFFTAG_INKNAMES: 423 v = (uint16) va_arg(ap, uint16_vap); 424 s = va_arg(ap, char*); 425 v = checkInkNamesString(tif, v, s); 426 status = v > 0; 427 if( v > 0 ) { 428 _TIFFsetNString(&td->td_inknames, s, v); 429 td->td_inknameslen = v; 430 } 431 break; 432 case TIFFTAG_PERSAMPLE: 433 v = (uint16) va_arg(ap, uint16_vap); 434 if( v == PERSAMPLE_MULTI ) 435 tif->tif_flags |= TIFF_PERSAMPLE; 436 else 437 tif->tif_flags &= ~TIFF_PERSAMPLE; 438 break; 439 default: { 440 TIFFTagValue *tv; 441 int tv_size, iCustom; 442 443 /* 444 * This can happen if multiple images are open with different 445 * codecs which have private tags. The global tag information 446 * table may then have tags that are valid for one file but not 447 * the other. If the client tries to set a tag that is not valid 448 * for the image's codec then we'll arrive here. This 449 * happens, for example, when tiffcp is used to convert between 450 * compression schemes and codec-specific tags are blindly copied. 451 */ 452 if(fip == NULL || fip->field_bit != FIELD_CUSTOM) { 453 TIFFErrorExt(tif->tif_clientdata, module, 454 "%s: Invalid %stag \"%s\" (not supported by codec)", 455 tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", 456 fip ? fip->field_name : "Unknown"); 457 status = 0; 458 break; 459 } 460 461 /* 462 * Find the existing entry for this custom value. 463 */ 464 tv = NULL; 465 for (iCustom = 0; iCustom < td->td_customValueCount; iCustom++) { 466 if (td->td_customValues[iCustom].info->field_tag == tag) { 467 tv = td->td_customValues + iCustom; 468 if (tv->value != NULL) { 469 _TIFFfree(tv->value); 470 tv->value = NULL; 471 } 472 break; 473 } 474 } 475 476 /* 477 * Grow the custom list if the entry was not found. 478 */ 479 if(tv == NULL) { 480 TIFFTagValue *new_customValues; 481 482 td->td_customValueCount++; 483 new_customValues = (TIFFTagValue *) 484 _TIFFrealloc(td->td_customValues, 485 sizeof(TIFFTagValue) * td->td_customValueCount); 486 if (!new_customValues) { 487 TIFFErrorExt(tif->tif_clientdata, module, 488 "%s: Failed to allocate space for list of custom values", 489 tif->tif_name); 490 status = 0; 491 goto end; 492 } 493 494 td->td_customValues = new_customValues; 495 496 tv = td->td_customValues + (td->td_customValueCount - 1); 497 tv->info = fip; 498 tv->value = NULL; 499 tv->count = 0; 500 } 501 502 /* 503 * Set custom value ... save a copy of the custom tag value. 504 */ 505 tv_size = _TIFFDataSize(fip->field_type); 506 if (tv_size == 0) { 507 status = 0; 508 TIFFErrorExt(tif->tif_clientdata, module, 509 "%s: Bad field type %d for \"%s\"", 510 tif->tif_name, fip->field_type, 511 fip->field_name); 512 goto end; 513 } 514 515 if (fip->field_type == TIFF_ASCII) 516 { 517 uint32 ma; 518 char* mb; 519 if (fip->field_passcount) 520 { 521 assert(fip->field_writecount==TIFF_VARIABLE2); 522 ma=(uint32)va_arg(ap,uint32); 523 mb=(char*)va_arg(ap,char*); 524 } 525 else 526 { 527 mb=(char*)va_arg(ap,char*); 528 ma=(uint32)(strlen(mb)+1); 529 } 530 tv->count=ma; 531 setByteArray(&tv->value,mb,ma,1); 532 } 533 else 534 { 535 if (fip->field_passcount) { 536 if (fip->field_writecount == TIFF_VARIABLE2) 537 tv->count = (uint32) va_arg(ap, uint32); 538 else 539 tv->count = (int) va_arg(ap, int); 540 } else if (fip->field_writecount == TIFF_VARIABLE 541 || fip->field_writecount == TIFF_VARIABLE2) 542 tv->count = 1; 543 else if (fip->field_writecount == TIFF_SPP) 544 tv->count = td->td_samplesperpixel; 545 else 546 tv->count = fip->field_writecount; 547 548 if (tv->count == 0) { 549 status = 0; 550 TIFFErrorExt(tif->tif_clientdata, module, 551 "%s: Null count for \"%s\" (type " 552 "%d, writecount %d, passcount %d)", 553 tif->tif_name, 554 fip->field_name, 555 fip->field_type, 556 fip->field_writecount, 557 fip->field_passcount); 558 goto end; 559 } 560 561 tv->value = _TIFFCheckMalloc(tif, tv->count, tv_size, 562 "custom tag binary object"); 563 if (!tv->value) { 564 status = 0; 565 goto end; 566 } 567 568 if (fip->field_tag == TIFFTAG_DOTRANGE 569 && strcmp(fip->field_name,"DotRange") == 0) { 570 /* TODO: This is an evil exception and should not have been 571 handled this way ... likely best if we move it into 572 the directory structure with an explicit field in 573 libtiff 4.1 and assign it a FIELD_ value */ 574 uint16 v[2]; 575 v[0] = (uint16)va_arg(ap, int); 576 v[1] = (uint16)va_arg(ap, int); 577 _TIFFmemcpy(tv->value, &v, 4); 578 } 579 580 else if (fip->field_passcount 581 || fip->field_writecount == TIFF_VARIABLE 582 || fip->field_writecount == TIFF_VARIABLE2 583 || fip->field_writecount == TIFF_SPP 584 || tv->count > 1) { 585 _TIFFmemcpy(tv->value, va_arg(ap, void *), 586 tv->count * tv_size); 587 } else { 588 char *val = (char *)tv->value; 589 assert( tv->count == 1 ); 590 591 switch (fip->field_type) { 592 case TIFF_BYTE: 593 case TIFF_UNDEFINED: 594 { 595 uint8 v = (uint8)va_arg(ap, int); 596 _TIFFmemcpy(val, &v, tv_size); 597 } 598 break; 599 case TIFF_SBYTE: 600 { 601 int8 v = (int8)va_arg(ap, int); 602 _TIFFmemcpy(val, &v, tv_size); 603 } 604 break; 605 case TIFF_SHORT: 606 { 607 uint16 v = (uint16)va_arg(ap, int); 608 _TIFFmemcpy(val, &v, tv_size); 609 } 610 break; 611 case TIFF_SSHORT: 612 { 613 int16 v = (int16)va_arg(ap, int); 614 _TIFFmemcpy(val, &v, tv_size); 615 } 616 break; 617 case TIFF_LONG: 618 case TIFF_IFD: 619 { 620 uint32 v = va_arg(ap, uint32); 621 _TIFFmemcpy(val, &v, tv_size); 622 } 623 break; 624 case TIFF_SLONG: 625 { 626 int32 v = va_arg(ap, int32); 627 _TIFFmemcpy(val, &v, tv_size); 628 } 629 break; 630 case TIFF_LONG8: 631 case TIFF_IFD8: 632 { 633 uint64 v = va_arg(ap, uint64); 634 _TIFFmemcpy(val, &v, tv_size); 635 } 636 break; 637 case TIFF_SLONG8: 638 { 639 int64 v = va_arg(ap, int64); 640 _TIFFmemcpy(val, &v, tv_size); 641 } 642 break; 643 case TIFF_RATIONAL: 644 case TIFF_SRATIONAL: 645 case TIFF_FLOAT: 646 { 647 float v = (float)va_arg(ap, double); 648 _TIFFmemcpy(val, &v, tv_size); 649 } 650 break; 651 case TIFF_DOUBLE: 652 { 653 double v = va_arg(ap, double); 654 _TIFFmemcpy(val, &v, tv_size); 655 } 656 break; 657 default: 658 _TIFFmemset(val, 0, tv_size); 659 status = 0; 660 break; 661 } 662 } 663 } 664 } 665 } 666 if (status) { 667 const TIFFField* fip=TIFFFieldWithTag(tif,tag); 668 if (fip) 669 TIFFSetFieldBit(tif, fip->field_bit); 670 tif->tif_flags |= TIFF_DIRTYDIRECT; 671 } 672 673 end: 674 va_end(ap); 675 return (status); 676 badvalue: 677 { 678 const TIFFField* fip=TIFFFieldWithTag(tif,tag); 679 TIFFErrorExt(tif->tif_clientdata, module, 680 "%s: Bad value %u for \"%s\" tag", 681 tif->tif_name, v, 682 fip ? fip->field_name : "Unknown"); 683 va_end(ap); 684 } 685 return (0); 686 badvalue32: 687 { 688 const TIFFField* fip=TIFFFieldWithTag(tif,tag); 689 TIFFErrorExt(tif->tif_clientdata, module, 690 "%s: Bad value %u for \"%s\" tag", 691 tif->tif_name, v32, 692 fip ? fip->field_name : "Unknown"); 693 va_end(ap); 694 } 695 return (0); 696 } 697 698 /* 699 * Return 1/0 according to whether or not 700 * it is permissible to set the tag's value. 701 * Note that we allow ImageLength to be changed 702 * so that we can append and extend to images. 703 * Any other tag may not be altered once writing 704 * has commenced, unless its value has no effect 705 * on the format of the data that is written. 706 */ 707 static int 708 OkToChangeTag(TIFF* tif, uint32 tag) 709 { 710 const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); 711 if (!fip) { /* unknown tag */ 712 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", "%s: Unknown %stag %u", 713 tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag); 714 return (0); 715 } 716 if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) && 717 !fip->field_oktochange) { 718 /* 719 * Consult info table to see if tag can be changed 720 * after we've started writing. We only allow changes 721 * to those tags that don't/shouldn't affect the 722 * compression and/or format of the data. 723 */ 724 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", 725 "%s: Cannot modify tag \"%s\" while writing", 726 tif->tif_name, fip->field_name); 727 return (0); 728 } 729 return (1); 730 } 731 732 /* 733 * Record the value of a field in the 734 * internal directory structure. The 735 * field will be written to the file 736 * when/if the directory structure is 737 * updated. 738 */ 739 int 740 TIFFSetField(TIFF* tif, uint32 tag, ...) 741 { 742 va_list ap; 743 int status; 744 745 va_start(ap, tag); 746 status = TIFFVSetField(tif, tag, ap); 747 va_end(ap); 748 return (status); 749 } 750 751 /* 752 * Clear the contents of the field in the internal structure. 753 */ 754 int 755 TIFFUnsetField(TIFF* tif, uint32 tag) 756 { 757 const TIFFField *fip = TIFFFieldWithTag(tif, tag); 758 TIFFDirectory* td = &tif->tif_dir; 759 760 if( !fip ) 761 return 0; 762 763 if( fip->field_bit != FIELD_CUSTOM ) 764 TIFFClrFieldBit(tif, fip->field_bit); 765 else 766 { 767 TIFFTagValue *tv = NULL; 768 int i; 769 770 for (i = 0; i < td->td_customValueCount; i++) { 771 772 tv = td->td_customValues + i; 773 if( tv->info->field_tag == tag ) 774 break; 775 } 776 777 if( i < td->td_customValueCount ) 778 { 779 _TIFFfree(tv->value); 780 for( ; i < td->td_customValueCount-1; i++) { 781 td->td_customValues[i] = td->td_customValues[i+1]; 782 } 783 td->td_customValueCount--; 784 } 785 } 786 787 tif->tif_flags |= TIFF_DIRTYDIRECT; 788 789 return (1); 790 } 791 792 /* 793 * Like TIFFSetField, but taking a varargs 794 * parameter list. This routine is useful 795 * for building higher-level interfaces on 796 * top of the library. 797 */ 798 int 799 TIFFVSetField(TIFF* tif, uint32 tag, va_list ap) 800 { 801 return OkToChangeTag(tif, tag) ? 802 (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0; 803 } 804 805 static int 806 _TIFFVGetField(TIFF* tif, uint32 tag, va_list ap) 807 { 808 TIFFDirectory* td = &tif->tif_dir; 809 int ret_val = 1; 810 uint32 standard_tag = tag; 811 const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); 812 813 /* 814 * We want to force the custom code to be used for custom 815 * fields even if the tag happens to match a well known 816 * one - important for reinterpreted handling of standard 817 * tag values in custom directories (ie. EXIF) 818 */ 819 if (fip->field_bit == FIELD_CUSTOM) { 820 standard_tag = 0; 821 } 822 823 switch (standard_tag) { 824 case TIFFTAG_SUBFILETYPE: 825 *va_arg(ap, uint32*) = td->td_subfiletype; 826 break; 827 case TIFFTAG_IMAGEWIDTH: 828 *va_arg(ap, uint32*) = td->td_imagewidth; 829 break; 830 case TIFFTAG_IMAGELENGTH: 831 *va_arg(ap, uint32*) = td->td_imagelength; 832 break; 833 case TIFFTAG_BITSPERSAMPLE: 834 *va_arg(ap, uint16*) = td->td_bitspersample; 835 break; 836 case TIFFTAG_COMPRESSION: 837 *va_arg(ap, uint16*) = td->td_compression; 838 break; 839 case TIFFTAG_PHOTOMETRIC: 840 *va_arg(ap, uint16*) = td->td_photometric; 841 break; 842 case TIFFTAG_THRESHHOLDING: 843 *va_arg(ap, uint16*) = td->td_threshholding; 844 break; 845 case TIFFTAG_FILLORDER: 846 *va_arg(ap, uint16*) = td->td_fillorder; 847 break; 848 case TIFFTAG_ORIENTATION: 849 *va_arg(ap, uint16*) = td->td_orientation; 850 break; 851 case TIFFTAG_SAMPLESPERPIXEL: 852 *va_arg(ap, uint16*) = td->td_samplesperpixel; 853 break; 854 case TIFFTAG_ROWSPERSTRIP: 855 *va_arg(ap, uint32*) = td->td_rowsperstrip; 856 break; 857 case TIFFTAG_MINSAMPLEVALUE: 858 *va_arg(ap, uint16*) = td->td_minsamplevalue; 859 break; 860 case TIFFTAG_MAXSAMPLEVALUE: 861 *va_arg(ap, uint16*) = td->td_maxsamplevalue; 862 break; 863 case TIFFTAG_SMINSAMPLEVALUE: 864 if (tif->tif_flags & TIFF_PERSAMPLE) 865 *va_arg(ap, double**) = td->td_sminsamplevalue; 866 else 867 { 868 /* libtiff historially treats this as a single value. */ 869 uint16 i; 870 double v = td->td_sminsamplevalue[0]; 871 for (i=1; i < td->td_samplesperpixel; ++i) 872 if( td->td_sminsamplevalue[i] < v ) 873 v = td->td_sminsamplevalue[i]; 874 *va_arg(ap, double*) = v; 875 } 876 break; 877 case TIFFTAG_SMAXSAMPLEVALUE: 878 if (tif->tif_flags & TIFF_PERSAMPLE) 879 *va_arg(ap, double**) = td->td_smaxsamplevalue; 880 else 881 { 882 /* libtiff historially treats this as a single value. */ 883 uint16 i; 884 double v = td->td_smaxsamplevalue[0]; 885 for (i=1; i < td->td_samplesperpixel; ++i) 886 if( td->td_smaxsamplevalue[i] > v ) 887 v = td->td_smaxsamplevalue[i]; 888 *va_arg(ap, double*) = v; 889 } 890 break; 891 case TIFFTAG_XRESOLUTION: 892 *va_arg(ap, float*) = td->td_xresolution; 893 break; 894 case TIFFTAG_YRESOLUTION: 895 *va_arg(ap, float*) = td->td_yresolution; 896 break; 897 case TIFFTAG_PLANARCONFIG: 898 *va_arg(ap, uint16*) = td->td_planarconfig; 899 break; 900 case TIFFTAG_XPOSITION: 901 *va_arg(ap, float*) = td->td_xposition; 902 break; 903 case TIFFTAG_YPOSITION: 904 *va_arg(ap, float*) = td->td_yposition; 905 break; 906 case TIFFTAG_RESOLUTIONUNIT: 907 *va_arg(ap, uint16*) = td->td_resolutionunit; 908 break; 909 case TIFFTAG_PAGENUMBER: 910 *va_arg(ap, uint16*) = td->td_pagenumber[0]; 911 *va_arg(ap, uint16*) = td->td_pagenumber[1]; 912 break; 913 case TIFFTAG_HALFTONEHINTS: 914 *va_arg(ap, uint16*) = td->td_halftonehints[0]; 915 *va_arg(ap, uint16*) = td->td_halftonehints[1]; 916 break; 917 case TIFFTAG_COLORMAP: 918 *va_arg(ap, uint16**) = td->td_colormap[0]; 919 *va_arg(ap, uint16**) = td->td_colormap[1]; 920 *va_arg(ap, uint16**) = td->td_colormap[2]; 921 break; 922 case TIFFTAG_STRIPOFFSETS: 923 case TIFFTAG_TILEOFFSETS: 924 _TIFFFillStriles( tif ); 925 *va_arg(ap, uint64**) = td->td_stripoffset; 926 break; 927 case TIFFTAG_STRIPBYTECOUNTS: 928 case TIFFTAG_TILEBYTECOUNTS: 929 _TIFFFillStriles( tif ); 930 *va_arg(ap, uint64**) = td->td_stripbytecount; 931 break; 932 case TIFFTAG_MATTEING: 933 *va_arg(ap, uint16*) = 934 (td->td_extrasamples == 1 && 935 td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA); 936 break; 937 case TIFFTAG_EXTRASAMPLES: 938 *va_arg(ap, uint16*) = td->td_extrasamples; 939 *va_arg(ap, uint16**) = td->td_sampleinfo; 940 break; 941 case TIFFTAG_TILEWIDTH: 942 *va_arg(ap, uint32*) = td->td_tilewidth; 943 break; 944 case TIFFTAG_TILELENGTH: 945 *va_arg(ap, uint32*) = td->td_tilelength; 946 break; 947 case TIFFTAG_TILEDEPTH: 948 *va_arg(ap, uint32*) = td->td_tiledepth; 949 break; 950 case TIFFTAG_DATATYPE: 951 switch (td->td_sampleformat) { 952 case SAMPLEFORMAT_UINT: 953 *va_arg(ap, uint16*) = DATATYPE_UINT; 954 break; 955 case SAMPLEFORMAT_INT: 956 *va_arg(ap, uint16*) = DATATYPE_INT; 957 break; 958 case SAMPLEFORMAT_IEEEFP: 959 *va_arg(ap, uint16*) = DATATYPE_IEEEFP; 960 break; 961 case SAMPLEFORMAT_VOID: 962 *va_arg(ap, uint16*) = DATATYPE_VOID; 963 break; 964 } 965 break; 966 case TIFFTAG_SAMPLEFORMAT: 967 *va_arg(ap, uint16*) = td->td_sampleformat; 968 break; 969 case TIFFTAG_IMAGEDEPTH: 970 *va_arg(ap, uint32*) = td->td_imagedepth; 971 break; 972 case TIFFTAG_SUBIFD: 973 *va_arg(ap, uint16*) = td->td_nsubifd; 974 *va_arg(ap, uint64**) = td->td_subifd; 975 break; 976 case TIFFTAG_YCBCRPOSITIONING: 977 *va_arg(ap, uint16*) = td->td_ycbcrpositioning; 978 break; 979 case TIFFTAG_YCBCRSUBSAMPLING: 980 *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0]; 981 *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1]; 982 break; 983 case TIFFTAG_TRANSFERFUNCTION: 984 *va_arg(ap, uint16**) = td->td_transferfunction[0]; 985 if (td->td_samplesperpixel - td->td_extrasamples > 1) { 986 *va_arg(ap, uint16**) = td->td_transferfunction[1]; 987 *va_arg(ap, uint16**) = td->td_transferfunction[2]; 988 } 989 break; 990 case TIFFTAG_REFERENCEBLACKWHITE: 991 *va_arg(ap, float**) = td->td_refblackwhite; 992 break; 993 case TIFFTAG_INKNAMES: 994 *va_arg(ap, char**) = td->td_inknames; 995 break; 996 default: 997 { 998 int i; 999 1000 /* 1001 * This can happen if multiple images are open 1002 * with different codecs which have private 1003 * tags. The global tag information table may 1004 * then have tags that are valid for one file 1005 * but not the other. If the client tries to 1006 * get a tag that is not valid for the image's 1007 * codec then we'll arrive here. 1008 */ 1009 if( fip == NULL || fip->field_bit != FIELD_CUSTOM ) 1010 { 1011 TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField", 1012 "%s: Invalid %stag \"%s\" " 1013 "(not supported by codec)", 1014 tif->tif_name, 1015 isPseudoTag(tag) ? "pseudo-" : "", 1016 fip ? fip->field_name : "Unknown"); 1017 ret_val = 0; 1018 break; 1019 } 1020 1021 /* 1022 * Do we have a custom value? 1023 */ 1024 ret_val = 0; 1025 for (i = 0; i < td->td_customValueCount; i++) { 1026 TIFFTagValue *tv = td->td_customValues + i; 1027 1028 if (tv->info->field_tag != tag) 1029 continue; 1030 1031 if (fip->field_passcount) { 1032 if (fip->field_readcount == TIFF_VARIABLE2) 1033 *va_arg(ap, uint32*) = (uint32)tv->count; 1034 else /* Assume TIFF_VARIABLE */ 1035 *va_arg(ap, uint16*) = (uint16)tv->count; 1036 *va_arg(ap, void **) = tv->value; 1037 ret_val = 1; 1038 } else if (fip->field_tag == TIFFTAG_DOTRANGE 1039 && strcmp(fip->field_name,"DotRange") == 0) { 1040 /* TODO: This is an evil exception and should not have been 1041 handled this way ... likely best if we move it into 1042 the directory structure with an explicit field in 1043 libtiff 4.1 and assign it a FIELD_ value */ 1044 *va_arg(ap, uint16*) = ((uint16 *)tv->value)[0]; 1045 *va_arg(ap, uint16*) = ((uint16 *)tv->value)[1]; 1046 ret_val = 1; 1047 } else { 1048 if (fip->field_type == TIFF_ASCII 1049 || fip->field_readcount == TIFF_VARIABLE 1050 || fip->field_readcount == TIFF_VARIABLE2 1051 || fip->field_readcount == TIFF_SPP 1052 || tv->count > 1) { 1053 *va_arg(ap, void **) = tv->value; 1054 ret_val = 1; 1055 } else { 1056 char *val = (char *)tv->value; 1057 assert( tv->count == 1 ); 1058 switch (fip->field_type) { 1059 case TIFF_BYTE: 1060 case TIFF_UNDEFINED: 1061 *va_arg(ap, uint8*) = 1062 *(uint8 *)val; 1063 ret_val = 1; 1064 break; 1065 case TIFF_SBYTE: 1066 *va_arg(ap, int8*) = 1067 *(int8 *)val; 1068 ret_val = 1; 1069 break; 1070 case TIFF_SHORT: 1071 *va_arg(ap, uint16*) = 1072 *(uint16 *)val; 1073 ret_val = 1; 1074 break; 1075 case TIFF_SSHORT: 1076 *va_arg(ap, int16*) = 1077 *(int16 *)val; 1078 ret_val = 1; 1079 break; 1080 case TIFF_LONG: 1081 case TIFF_IFD: 1082 *va_arg(ap, uint32*) = 1083 *(uint32 *)val; 1084 ret_val = 1; 1085 break; 1086 case TIFF_SLONG: 1087 *va_arg(ap, int32*) = 1088 *(int32 *)val; 1089 ret_val = 1; 1090 break; 1091 case TIFF_LONG8: 1092 case TIFF_IFD8: 1093 *va_arg(ap, uint64*) = 1094 *(uint64 *)val; 1095 ret_val = 1; 1096 break; 1097 case TIFF_SLONG8: 1098 *va_arg(ap, int64*) = 1099 *(int64 *)val; 1100 ret_val = 1; 1101 break; 1102 case TIFF_RATIONAL: 1103 case TIFF_SRATIONAL: 1104 case TIFF_FLOAT: 1105 *va_arg(ap, float*) = 1106 *(float *)val; 1107 ret_val = 1; 1108 break; 1109 case TIFF_DOUBLE: 1110 *va_arg(ap, double*) = 1111 *(double *)val; 1112 ret_val = 1; 1113 break; 1114 default: 1115 ret_val = 0; 1116 break; 1117 } 1118 } 1119 } 1120 break; 1121 } 1122 } 1123 } 1124 return(ret_val); 1125 } 1126 1127 /* 1128 * Return the value of a field in the 1129 * internal directory structure. 1130 */ 1131 int 1132 TIFFGetField(TIFF* tif, uint32 tag, ...) 1133 { 1134 int status; 1135 va_list ap; 1136 1137 va_start(ap, tag); 1138 status = TIFFVGetField(tif, tag, ap); 1139 va_end(ap); 1140 return (status); 1141 } 1142 1143 /* 1144 * Like TIFFGetField, but taking a varargs 1145 * parameter list. This routine is useful 1146 * for building higher-level interfaces on 1147 * top of the library. 1148 */ 1149 int 1150 TIFFVGetField(TIFF* tif, uint32 tag, va_list ap) 1151 { 1152 const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); 1153 return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ? 1154 (*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0); 1155 } 1156 1157 #define CleanupField(member) { \ 1158 if (td->member) { \ 1159 _TIFFfree(td->member); \ 1160 td->member = 0; \ 1161 } \ 1162 } 1163 1164 /* 1165 * Release storage associated with a directory. 1166 */ 1167 void 1168 TIFFFreeDirectory(TIFF* tif) 1169 { 1170 TIFFDirectory *td = &tif->tif_dir; 1171 int i; 1172 1173 _TIFFmemset(td->td_fieldsset, 0, FIELD_SETLONGS); 1174 CleanupField(td_sminsamplevalue); 1175 CleanupField(td_smaxsamplevalue); 1176 CleanupField(td_colormap[0]); 1177 CleanupField(td_colormap[1]); 1178 CleanupField(td_colormap[2]); 1179 CleanupField(td_sampleinfo); 1180 CleanupField(td_subifd); 1181 CleanupField(td_inknames); 1182 CleanupField(td_refblackwhite); 1183 CleanupField(td_transferfunction[0]); 1184 CleanupField(td_transferfunction[1]); 1185 CleanupField(td_transferfunction[2]); 1186 CleanupField(td_stripoffset); 1187 CleanupField(td_stripbytecount); 1188 TIFFClrFieldBit(tif, FIELD_YCBCRSUBSAMPLING); 1189 TIFFClrFieldBit(tif, FIELD_YCBCRPOSITIONING); 1190 1191 /* Cleanup custom tag values */ 1192 for( i = 0; i < td->td_customValueCount; i++ ) { 1193 if (td->td_customValues[i].value) 1194 _TIFFfree(td->td_customValues[i].value); 1195 } 1196 1197 td->td_customValueCount = 0; 1198 CleanupField(td_customValues); 1199 1200 #if defined(DEFER_STRILE_LOAD) 1201 _TIFFmemset( &(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry)); 1202 _TIFFmemset( &(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry)); 1203 #endif 1204 } 1205 #undef CleanupField 1206 1207 /* 1208 * Client Tag extension support (from Niles Ritter). 1209 */ 1210 static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL; 1211 1212 TIFFExtendProc 1213 TIFFSetTagExtender(TIFFExtendProc extender) 1214 { 1215 TIFFExtendProc prev = _TIFFextender; 1216 _TIFFextender = extender; 1217 return (prev); 1218 } 1219 1220 /* 1221 * Setup for a new directory. Should we automatically call 1222 * TIFFWriteDirectory() if the current one is dirty? 1223 * 1224 * The newly created directory will not exist on the file till 1225 * TIFFWriteDirectory(), TIFFFlush() or TIFFClose() is called. 1226 */ 1227 int 1228 TIFFCreateDirectory(TIFF* tif) 1229 { 1230 TIFFDefaultDirectory(tif); 1231 tif->tif_diroff = 0; 1232 tif->tif_nextdiroff = 0; 1233 tif->tif_curoff = 0; 1234 tif->tif_row = (uint32) -1; 1235 tif->tif_curstrip = (uint32) -1; 1236 1237 return 0; 1238 } 1239 1240 int 1241 TIFFCreateCustomDirectory(TIFF* tif, const TIFFFieldArray* infoarray) 1242 { 1243 TIFFDefaultDirectory(tif); 1244 1245 /* 1246 * Reset the field definitions to match the application provided list. 1247 * Hopefully TIFFDefaultDirectory() won't have done anything irreversable 1248 * based on it's assumption this is an image directory. 1249 */ 1250 _TIFFSetupFields(tif, infoarray); 1251 1252 tif->tif_diroff = 0; 1253 tif->tif_nextdiroff = 0; 1254 tif->tif_curoff = 0; 1255 tif->tif_row = (uint32) -1; 1256 tif->tif_curstrip = (uint32) -1; 1257 1258 return 0; 1259 } 1260 1261 int 1262 TIFFCreateEXIFDirectory(TIFF* tif) 1263 { 1264 const TIFFFieldArray* exifFieldArray; 1265 exifFieldArray = _TIFFGetExifFields(); 1266 return TIFFCreateCustomDirectory(tif, exifFieldArray); 1267 } 1268 1269 /* 1270 * Setup a default directory structure. 1271 */ 1272 int 1273 TIFFDefaultDirectory(TIFF* tif) 1274 { 1275 register TIFFDirectory* td = &tif->tif_dir; 1276 const TIFFFieldArray* tiffFieldArray; 1277 1278 tiffFieldArray = _TIFFGetFields(); 1279 _TIFFSetupFields(tif, tiffFieldArray); 1280 1281 _TIFFmemset(td, 0, sizeof (*td)); 1282 td->td_fillorder = FILLORDER_MSB2LSB; 1283 td->td_bitspersample = 1; 1284 td->td_threshholding = THRESHHOLD_BILEVEL; 1285 td->td_orientation = ORIENTATION_TOPLEFT; 1286 td->td_samplesperpixel = 1; 1287 td->td_rowsperstrip = (uint32) -1; 1288 td->td_tilewidth = 0; 1289 td->td_tilelength = 0; 1290 td->td_tiledepth = 1; 1291 td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */ 1292 td->td_resolutionunit = RESUNIT_INCH; 1293 td->td_sampleformat = SAMPLEFORMAT_UINT; 1294 td->td_imagedepth = 1; 1295 td->td_ycbcrsubsampling[0] = 2; 1296 td->td_ycbcrsubsampling[1] = 2; 1297 td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED; 1298 tif->tif_postdecode = _TIFFNoPostDecode; 1299 tif->tif_foundfield = NULL; 1300 tif->tif_tagmethods.vsetfield = _TIFFVSetField; 1301 tif->tif_tagmethods.vgetfield = _TIFFVGetField; 1302 tif->tif_tagmethods.printdir = NULL; 1303 /* 1304 * Give client code a chance to install their own 1305 * tag extensions & methods, prior to compression overloads. 1306 */ 1307 if (_TIFFextender) 1308 (*_TIFFextender)(tif); 1309 (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE); 1310 /* 1311 * NB: The directory is marked dirty as a result of setting 1312 * up the default compression scheme. However, this really 1313 * isn't correct -- we want TIFF_DIRTYDIRECT to be set only 1314 * if the user does something. We could just do the setup 1315 * by hand, but it seems better to use the normal mechanism 1316 * (i.e. TIFFSetField). 1317 */ 1318 tif->tif_flags &= ~TIFF_DIRTYDIRECT; 1319 1320 /* 1321 * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19 1322 * we clear the ISTILED flag when setting up a new directory. 1323 * Should we also be clearing stuff like INSUBIFD? 1324 */ 1325 tif->tif_flags &= ~TIFF_ISTILED; 1326 1327 return (1); 1328 } 1329 1330 static int 1331 TIFFAdvanceDirectory(TIFF* tif, uint64* nextdir, uint64* off) 1332 { 1333 static const char module[] = "TIFFAdvanceDirectory"; 1334 if (isMapped(tif)) 1335 { 1336 uint64 poff=*nextdir; 1337 if (!(tif->tif_flags&TIFF_BIGTIFF)) 1338 { 1339 tmsize_t poffa,poffb,poffc,poffd; 1340 uint16 dircount; 1341 uint32 nextdir32; 1342 poffa=(tmsize_t)poff; 1343 poffb=poffa+sizeof(uint16); 1344 if (((uint64)poffa!=poff)||(poffb<poffa)||(poffb<(tmsize_t)sizeof(uint16))||(poffb>tif->tif_size)) 1345 { 1346 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory count"); 1347 return(0); 1348 } 1349 _TIFFmemcpy(&dircount,tif->tif_base+poffa,sizeof(uint16)); 1350 if (tif->tif_flags&TIFF_SWAB) 1351 TIFFSwabShort(&dircount); 1352 poffc=poffb+dircount*12; 1353 poffd=poffc+sizeof(uint32); 1354 if ((poffc<poffb)||(poffc<dircount*12)||(poffd<poffc)||(poffd<(tmsize_t)sizeof(uint32))||(poffd>tif->tif_size)) 1355 { 1356 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory link"); 1357 return(0); 1358 } 1359 if (off!=NULL) 1360 *off=(uint64)poffc; 1361 _TIFFmemcpy(&nextdir32,tif->tif_base+poffc,sizeof(uint32)); 1362 if (tif->tif_flags&TIFF_SWAB) 1363 TIFFSwabLong(&nextdir32); 1364 *nextdir=nextdir32; 1365 } 1366 else 1367 { 1368 tmsize_t poffa,poffb,poffc,poffd; 1369 uint64 dircount64; 1370 uint16 dircount16; 1371 poffa=(tmsize_t)poff; 1372 poffb=poffa+sizeof(uint64); 1373 if (((uint64)poffa!=poff)||(poffb<poffa)||(poffb<(tmsize_t)sizeof(uint64))||(poffb>tif->tif_size)) 1374 { 1375 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory count"); 1376 return(0); 1377 } 1378 _TIFFmemcpy(&dircount64,tif->tif_base+poffa,sizeof(uint64)); 1379 if (tif->tif_flags&TIFF_SWAB) 1380 TIFFSwabLong8(&dircount64); 1381 if (dircount64>0xFFFF) 1382 { 1383 TIFFErrorExt(tif->tif_clientdata,module,"Sanity check on directory count failed"); 1384 return(0); 1385 } 1386 dircount16=(uint16)dircount64; 1387 poffc=poffb+dircount16*20; 1388 poffd=poffc+sizeof(uint64); 1389 if ((poffc<poffb)||(poffc<dircount16*20)||(poffd<poffc)||(poffd<(tmsize_t)sizeof(uint64))||(poffd>tif->tif_size)) 1390 { 1391 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory link"); 1392 return(0); 1393 } 1394 if (off!=NULL) 1395 *off=(uint64)poffc; 1396 _TIFFmemcpy(nextdir,tif->tif_base+poffc,sizeof(uint64)); 1397 if (tif->tif_flags&TIFF_SWAB) 1398 TIFFSwabLong8(nextdir); 1399 } 1400 return(1); 1401 } 1402 else 1403 { 1404 if (!(tif->tif_flags&TIFF_BIGTIFF)) 1405 { 1406 uint16 dircount; 1407 uint32 nextdir32; 1408 if (!SeekOK(tif, *nextdir) || 1409 !ReadOK(tif, &dircount, sizeof (uint16))) { 1410 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count", 1411 tif->tif_name); 1412 return (0); 1413 } 1414 if (tif->tif_flags & TIFF_SWAB) 1415 TIFFSwabShort(&dircount); 1416 if (off != NULL) 1417 *off = TIFFSeekFile(tif, 1418 dircount*12, SEEK_CUR); 1419 else 1420 (void) TIFFSeekFile(tif, 1421 dircount*12, SEEK_CUR); 1422 if (!ReadOK(tif, &nextdir32, sizeof (uint32))) { 1423 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link", 1424 tif->tif_name); 1425 return (0); 1426 } 1427 if (tif->tif_flags & TIFF_SWAB) 1428 TIFFSwabLong(&nextdir32); 1429 *nextdir=nextdir32; 1430 } 1431 else 1432 { 1433 uint64 dircount64; 1434 uint16 dircount16; 1435 if (!SeekOK(tif, *nextdir) || 1436 !ReadOK(tif, &dircount64, sizeof (uint64))) { 1437 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count", 1438 tif->tif_name); 1439 return (0); 1440 } 1441 if (tif->tif_flags & TIFF_SWAB) 1442 TIFFSwabLong8(&dircount64); 1443 if (dircount64>0xFFFF) 1444 { 1445 TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count"); 1446 return(0); 1447 } 1448 dircount16 = (uint16)dircount64; 1449 if (off != NULL) 1450 *off = TIFFSeekFile(tif, 1451 dircount16*20, SEEK_CUR); 1452 else 1453 (void) TIFFSeekFile(tif, 1454 dircount16*20, SEEK_CUR); 1455 if (!ReadOK(tif, nextdir, sizeof (uint64))) { 1456 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link", 1457 tif->tif_name); 1458 return (0); 1459 } 1460 if (tif->tif_flags & TIFF_SWAB) 1461 TIFFSwabLong8(nextdir); 1462 } 1463 return (1); 1464 } 1465 } 1466 1467 /* 1468 * Count the number of directories in a file. 1469 */ 1470 uint16 1471 TIFFNumberOfDirectories(TIFF* tif) 1472 { 1473 uint64 nextdir; 1474 uint16 n; 1475 if (!(tif->tif_flags&TIFF_BIGTIFF)) 1476 nextdir = tif->tif_header.classic.tiff_diroff; 1477 else 1478 nextdir = tif->tif_header.big.tiff_diroff; 1479 n = 0; 1480 while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL)) 1481 n++; 1482 return (n); 1483 } 1484 1485 /* 1486 * Set the n-th directory as the current directory. 1487 * NB: Directories are numbered starting at 0. 1488 */ 1489 int 1490 TIFFSetDirectory(TIFF* tif, uint16 dirn) 1491 { 1492 uint64 nextdir; 1493 uint16 n; 1494 1495 if (!(tif->tif_flags&TIFF_BIGTIFF)) 1496 nextdir = tif->tif_header.classic.tiff_diroff; 1497 else 1498 nextdir = tif->tif_header.big.tiff_diroff; 1499 for (n = dirn; n > 0 && nextdir != 0; n--) 1500 if (!TIFFAdvanceDirectory(tif, &nextdir, NULL)) 1501 return (0); 1502 tif->tif_nextdiroff = nextdir; 1503 /* 1504 * Set curdir to the actual directory index. The 1505 * -1 is because TIFFReadDirectory will increment 1506 * tif_curdir after successfully reading the directory. 1507 */ 1508 tif->tif_curdir = (dirn - n) - 1; 1509 /* 1510 * Reset tif_dirnumber counter and start new list of seen directories. 1511 * We need this to prevent IFD loops. 1512 */ 1513 tif->tif_dirnumber = 0; 1514 return (TIFFReadDirectory(tif)); 1515 } 1516 1517 /* 1518 * Set the current directory to be the directory 1519 * located at the specified file offset. This interface 1520 * is used mainly to access directories linked with 1521 * the SubIFD tag (e.g. thumbnail images). 1522 */ 1523 int 1524 TIFFSetSubDirectory(TIFF* tif, uint64 diroff) 1525 { 1526 tif->tif_nextdiroff = diroff; 1527 /* 1528 * Reset tif_dirnumber counter and start new list of seen directories. 1529 * We need this to prevent IFD loops. 1530 */ 1531 tif->tif_dirnumber = 0; 1532 return (TIFFReadDirectory(tif)); 1533 } 1534 1535 /* 1536 * Return file offset of the current directory. 1537 */ 1538 uint64 1539 TIFFCurrentDirOffset(TIFF* tif) 1540 { 1541 return (tif->tif_diroff); 1542 } 1543 1544 /* 1545 * Return an indication of whether or not we are 1546 * at the last directory in the file. 1547 */ 1548 int 1549 TIFFLastDirectory(TIFF* tif) 1550 { 1551 return (tif->tif_nextdiroff == 0); 1552 } 1553 1554 /* 1555 * Unlink the specified directory from the directory chain. 1556 */ 1557 int 1558 TIFFUnlinkDirectory(TIFF* tif, uint16 dirn) 1559 { 1560 static const char module[] = "TIFFUnlinkDirectory"; 1561 uint64 nextdir; 1562 uint64 off; 1563 uint16 n; 1564 1565 if (tif->tif_mode == O_RDONLY) { 1566 TIFFErrorExt(tif->tif_clientdata, module, 1567 "Can not unlink directory in read-only file"); 1568 return (0); 1569 } 1570 /* 1571 * Go to the directory before the one we want 1572 * to unlink and nab the offset of the link 1573 * field we'll need to patch. 1574 */ 1575 if (!(tif->tif_flags&TIFF_BIGTIFF)) 1576 { 1577 nextdir = tif->tif_header.classic.tiff_diroff; 1578 off = 4; 1579 } 1580 else 1581 { 1582 nextdir = tif->tif_header.big.tiff_diroff; 1583 off = 8; 1584 } 1585 for (n = dirn-1; n > 0; n--) { 1586 if (nextdir == 0) { 1587 TIFFErrorExt(tif->tif_clientdata, module, "Directory %d does not exist", dirn); 1588 return (0); 1589 } 1590 if (!TIFFAdvanceDirectory(tif, &nextdir, &off)) 1591 return (0); 1592 } 1593 /* 1594 * Advance to the directory to be unlinked and fetch 1595 * the offset of the directory that follows. 1596 */ 1597 if (!TIFFAdvanceDirectory(tif, &nextdir, NULL)) 1598 return (0); 1599 /* 1600 * Go back and patch the link field of the preceding 1601 * directory to point to the offset of the directory 1602 * that follows. 1603 */ 1604 (void) TIFFSeekFile(tif, off, SEEK_SET); 1605 if (!(tif->tif_flags&TIFF_BIGTIFF)) 1606 { 1607 uint32 nextdir32; 1608 nextdir32=(uint32)nextdir; 1609 assert((uint64)nextdir32==nextdir); 1610 if (tif->tif_flags & TIFF_SWAB) 1611 TIFFSwabLong(&nextdir32); 1612 if (!WriteOK(tif, &nextdir32, sizeof (uint32))) { 1613 TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link"); 1614 return (0); 1615 } 1616 } 1617 else 1618 { 1619 if (tif->tif_flags & TIFF_SWAB) 1620 TIFFSwabLong8(&nextdir); 1621 if (!WriteOK(tif, &nextdir, sizeof (uint64))) { 1622 TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link"); 1623 return (0); 1624 } 1625 } 1626 /* 1627 * Leave directory state setup safely. We don't have 1628 * facilities for doing inserting and removing directories, 1629 * so it's safest to just invalidate everything. This 1630 * means that the caller can only append to the directory 1631 * chain. 1632 */ 1633 (*tif->tif_cleanup)(tif); 1634 if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) { 1635 _TIFFfree(tif->tif_rawdata); 1636 tif->tif_rawdata = NULL; 1637 tif->tif_rawcc = 0; 1638 tif->tif_rawdataoff = 0; 1639 tif->tif_rawdataloaded = 0; 1640 } 1641 tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE|TIFF_BUF4WRITE); 1642 TIFFFreeDirectory(tif); 1643 TIFFDefaultDirectory(tif); 1644 tif->tif_diroff = 0; /* force link on next write */ 1645 tif->tif_nextdiroff = 0; /* next write must be at end */ 1646 tif->tif_curoff = 0; 1647 tif->tif_row = (uint32) -1; 1648 tif->tif_curstrip = (uint32) -1; 1649 return (1); 1650 } 1651 1652 /* vim: set ts=8 sts=8 sw=8 noet: */ 1653 /* 1654 * Local Variables: 1655 * mode: c 1656 * c-basic-offset: 8 1657 * fill-column: 78 1658 * End: 1659 */ 1660
