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