1 /* 2 * Copyright (c) 1988-1997 Sam Leffler 3 * Copyright (c) 1991-1997 Silicon Graphics, Inc. 4 * 5 * Permission to use, copy, modify, distribute, and sell this software and 6 * its documentation for any purpose is hereby granted without fee, provided 7 * that (i) the above copyright notices and this permission notice appear in 8 * all copies of the software and related documentation, and (ii) the names of 9 * Sam Leffler and Silicon Graphics may not be used in any advertising or 10 * publicity relating to the software without the specific, prior written 11 * permission of Sam Leffler and Silicon Graphics. 12 * 13 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 14 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 15 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 16 * 17 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR 18 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, 19 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 20 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 21 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 22 * OF THIS SOFTWARE. 23 */ 24 25 /* 26 * TIFF Library. 27 * 28 * Directory Write Support Routines. 29 */ 30 #include <precomp.h> 31 #include <float.h> 32 33 #ifdef HAVE_IEEEFP 34 #define TIFFCvtNativeToIEEEFloat(tif, n, fp) 35 #define TIFFCvtNativeToIEEEDouble(tif, n, dp) 36 #else 37 extern void TIFFCvtNativeToIEEEFloat(TIFF* tif, uint32 n, float* fp); 38 extern void TIFFCvtNativeToIEEEDouble(TIFF* tif, uint32 n, double* dp); 39 #endif 40 41 static int TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff); 42 43 static int TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value); 44 #if 0 45 static int TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); 46 #endif 47 48 static int TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value); 49 static int TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); 50 #ifdef notdef 51 static int TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value); 52 #endif 53 static int TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); 54 #if 0 55 static int TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value); 56 #endif 57 #ifdef notdef 58 static int TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value); 59 #endif 60 static int TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value); 61 #if 0 62 static int TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value); 63 #endif 64 static int TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value); 65 static int TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value); 66 static int TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value); 67 #ifdef notdef 68 static int TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value); 69 #endif 70 static int TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value); 71 #if 0 72 static int TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value); 73 #endif 74 static int TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); 75 static int TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); 76 #if 0 77 static int TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); 78 #endif 79 #ifdef notdef 80 static int TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value); 81 #endif 82 static int TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value); 83 #if 0 84 static int TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value); 85 #endif 86 #ifdef notdef 87 static int TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value); 88 #endif 89 static int TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 90 #ifdef notdef 91 static int TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value); 92 #endif 93 static int TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value); 94 static int TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); 95 static int TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); 96 static int TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); 97 #ifdef notdef 98 static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value); 99 #endif 100 static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); 101 #if 0 102 static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value); 103 #endif 104 #ifdef notdef 105 static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); 106 #endif 107 static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value); 108 #if 0 109 static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); 110 #endif 111 static int TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); 112 #ifdef notdef 113 static int TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 114 #endif 115 static int TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); 116 static int TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 117 static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 118 #ifdef notdef 119 static int TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 120 #endif 121 static int TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir); 122 static int TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir); 123 static int TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir); 124 125 static int TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value); 126 static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); 127 #ifdef notdef 128 static int TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value); 129 #endif 130 static int TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); 131 #ifdef notdef 132 static int TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value); 133 #endif 134 static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value); 135 static int TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value); 136 static int TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value); 137 #ifdef notdef 138 static int TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value); 139 #endif 140 static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value); 141 static int TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); 142 static int TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); 143 #ifdef notdef 144 static int TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value); 145 #endif 146 static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value); 147 #ifdef notdef 148 static int TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value); 149 #endif 150 static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 151 #ifdef notdef 152 static int TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value); 153 #endif 154 static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value); 155 static int TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); 156 static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); 157 static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); 158 #ifdef notdef 159 static int TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value); 160 #endif 161 static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); 162 #ifdef notdef 163 static int TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); 164 #endif 165 static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value); 166 static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); 167 static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); 168 169 static int TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data); 170 171 static int TIFFLinkDirectory(TIFF*); 172 173 /* 174 * Write the contents of the current directory 175 * to the specified file. This routine doesn't 176 * handle overwriting a directory with auxiliary 177 * storage that's been changed. 178 */ 179 int 180 TIFFWriteDirectory(TIFF* tif) 181 { 182 return TIFFWriteDirectorySec(tif,TRUE,TRUE,NULL); 183 } 184 185 /* 186 * This is an advanced writing function that must be used in a particular 187 * sequence, and generally together with TIFFForceStrileArrayWriting(), 188 * to make its intended effect. Its aim is to modify the location 189 * where the [Strip/Tile][Offsets/ByteCounts] arrays are located in the file. 190 * More precisely, when TIFFWriteCheck() will be called, the tag entries for 191 * those arrays will be written with type = count = offset = 0 as a temporary 192 * value. 193 * 194 * Its effect is only valid for the current directory, and before 195 * TIFFWriteDirectory() is first called, and will be reset when 196 * changing directory. 197 * 198 * The typical sequence of calls is: 199 * TIFFOpen() 200 * [ TIFFCreateDirectory(tif) ] 201 * Set fields with calls to TIFFSetField(tif, ...) 202 * TIFFDeferStrileArrayWriting(tif) 203 * TIFFWriteCheck(tif, ...) 204 * TIFFWriteDirectory(tif) 205 * ... potentially create other directories and come back to the above directory 206 * TIFFForceStrileArrayWriting(tif): emit the arrays at the end of file 207 * 208 * Returns 1 in case of success, 0 otherwise. 209 */ 210 int TIFFDeferStrileArrayWriting(TIFF* tif) 211 { 212 static const char module[] = "TIFFDeferStrileArrayWriting"; 213 if (tif->tif_mode == O_RDONLY) 214 { 215 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, 216 "File opened in read-only mode"); 217 return 0; 218 } 219 if( tif->tif_diroff != 0 ) 220 { 221 TIFFErrorExt(tif->tif_clientdata, module, 222 "Directory has already been written"); 223 return 0; 224 } 225 226 tif->tif_dir.td_deferstrilearraywriting = TRUE; 227 return 1; 228 } 229 230 /* 231 * Similar to TIFFWriteDirectory(), writes the directory out 232 * but leaves all data structures in memory so that it can be 233 * written again. This will make a partially written TIFF file 234 * readable before it is successfully completed/closed. 235 */ 236 int 237 TIFFCheckpointDirectory(TIFF* tif) 238 { 239 int rc; 240 /* Setup the strips arrays, if they haven't already been. */ 241 if (tif->tif_dir.td_stripoffset_p == NULL) 242 (void) TIFFSetupStrips(tif); 243 rc = TIFFWriteDirectorySec(tif,TRUE,FALSE,NULL); 244 (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END)); 245 return rc; 246 } 247 248 int 249 TIFFWriteCustomDirectory(TIFF* tif, uint64* pdiroff) 250 { 251 return TIFFWriteDirectorySec(tif,FALSE,FALSE,pdiroff); 252 } 253 254 /* 255 * Similar to TIFFWriteDirectory(), but if the directory has already 256 * been written once, it is relocated to the end of the file, in case it 257 * has changed in size. Note that this will result in the loss of the 258 * previously used directory space. 259 */ 260 int 261 TIFFRewriteDirectory( TIFF *tif ) 262 { 263 static const char module[] = "TIFFRewriteDirectory"; 264 265 /* We don't need to do anything special if it hasn't been written. */ 266 if( tif->tif_diroff == 0 ) 267 return TIFFWriteDirectory( tif ); 268 269 /* 270 * Find and zero the pointer to this directory, so that TIFFLinkDirectory 271 * will cause it to be added after this directories current pre-link. 272 */ 273 274 if (!(tif->tif_flags&TIFF_BIGTIFF)) 275 { 276 if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff) 277 { 278 tif->tif_header.classic.tiff_diroff = 0; 279 tif->tif_diroff = 0; 280 281 TIFFSeekFile(tif,4,SEEK_SET); 282 if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4)) 283 { 284 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, 285 "Error updating TIFF header"); 286 return (0); 287 } 288 } 289 else 290 { 291 uint32 nextdir; 292 nextdir = tif->tif_header.classic.tiff_diroff; 293 while(1) { 294 uint16 dircount; 295 uint32 nextnextdir; 296 297 if (!SeekOK(tif, nextdir) || 298 !ReadOK(tif, &dircount, 2)) { 299 TIFFErrorExt(tif->tif_clientdata, module, 300 "Error fetching directory count"); 301 return (0); 302 } 303 if (tif->tif_flags & TIFF_SWAB) 304 TIFFSwabShort(&dircount); 305 (void) TIFFSeekFile(tif, 306 nextdir+2+dircount*12, SEEK_SET); 307 if (!ReadOK(tif, &nextnextdir, 4)) { 308 TIFFErrorExt(tif->tif_clientdata, module, 309 "Error fetching directory link"); 310 return (0); 311 } 312 if (tif->tif_flags & TIFF_SWAB) 313 TIFFSwabLong(&nextnextdir); 314 if (nextnextdir==tif->tif_diroff) 315 { 316 uint32 m; 317 m=0; 318 (void) TIFFSeekFile(tif, 319 nextdir+2+dircount*12, SEEK_SET); 320 if (!WriteOK(tif, &m, 4)) { 321 TIFFErrorExt(tif->tif_clientdata, module, 322 "Error writing directory link"); 323 return (0); 324 } 325 tif->tif_diroff=0; 326 break; 327 } 328 nextdir=nextnextdir; 329 } 330 } 331 } 332 else 333 { 334 if (tif->tif_header.big.tiff_diroff == tif->tif_diroff) 335 { 336 tif->tif_header.big.tiff_diroff = 0; 337 tif->tif_diroff = 0; 338 339 TIFFSeekFile(tif,8,SEEK_SET); 340 if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8)) 341 { 342 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, 343 "Error updating TIFF header"); 344 return (0); 345 } 346 } 347 else 348 { 349 uint64 nextdir; 350 nextdir = tif->tif_header.big.tiff_diroff; 351 while(1) { 352 uint64 dircount64; 353 uint16 dircount; 354 uint64 nextnextdir; 355 356 if (!SeekOK(tif, nextdir) || 357 !ReadOK(tif, &dircount64, 8)) { 358 TIFFErrorExt(tif->tif_clientdata, module, 359 "Error fetching directory count"); 360 return (0); 361 } 362 if (tif->tif_flags & TIFF_SWAB) 363 TIFFSwabLong8(&dircount64); 364 if (dircount64>0xFFFF) 365 { 366 TIFFErrorExt(tif->tif_clientdata, module, 367 "Sanity check on tag count failed, likely corrupt TIFF"); 368 return (0); 369 } 370 dircount=(uint16)dircount64; 371 (void) TIFFSeekFile(tif, 372 nextdir+8+dircount*20, SEEK_SET); 373 if (!ReadOK(tif, &nextnextdir, 8)) { 374 TIFFErrorExt(tif->tif_clientdata, module, 375 "Error fetching directory link"); 376 return (0); 377 } 378 if (tif->tif_flags & TIFF_SWAB) 379 TIFFSwabLong8(&nextnextdir); 380 if (nextnextdir==tif->tif_diroff) 381 { 382 uint64 m; 383 m=0; 384 (void) TIFFSeekFile(tif, 385 nextdir+8+dircount*20, SEEK_SET); 386 if (!WriteOK(tif, &m, 8)) { 387 TIFFErrorExt(tif->tif_clientdata, module, 388 "Error writing directory link"); 389 return (0); 390 } 391 tif->tif_diroff=0; 392 break; 393 } 394 nextdir=nextnextdir; 395 } 396 } 397 } 398 399 /* 400 * Now use TIFFWriteDirectory() normally. 401 */ 402 403 return TIFFWriteDirectory( tif ); 404 } 405 406 static int 407 TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff) 408 { 409 static const char module[] = "TIFFWriteDirectorySec"; 410 uint32 ndir; 411 TIFFDirEntry* dir; 412 uint32 dirsize; 413 void* dirmem; 414 uint32 m; 415 if (tif->tif_mode == O_RDONLY) 416 return (1); 417 418 _TIFFFillStriles( tif ); 419 420 /* 421 * Clear write state so that subsequent images with 422 * different characteristics get the right buffers 423 * setup for them. 424 */ 425 if (imagedone) 426 { 427 if (tif->tif_flags & TIFF_POSTENCODE) 428 { 429 tif->tif_flags &= ~TIFF_POSTENCODE; 430 if (!(*tif->tif_postencode)(tif)) 431 { 432 TIFFErrorExt(tif->tif_clientdata,module, 433 "Error post-encoding before directory write"); 434 return (0); 435 } 436 } 437 (*tif->tif_close)(tif); /* shutdown encoder */ 438 /* 439 * Flush any data that might have been written 440 * by the compression close+cleanup routines. But 441 * be careful not to write stuff if we didn't add data 442 * in the previous steps as the "rawcc" data may well be 443 * a previously read tile/strip in mixed read/write mode. 444 */ 445 if (tif->tif_rawcc > 0 446 && (tif->tif_flags & TIFF_BEENWRITING) != 0 ) 447 { 448 if( !TIFFFlushData1(tif) ) 449 { 450 TIFFErrorExt(tif->tif_clientdata, module, 451 "Error flushing data before directory write"); 452 return (0); 453 } 454 } 455 if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) 456 { 457 _TIFFfree(tif->tif_rawdata); 458 tif->tif_rawdata = NULL; 459 tif->tif_rawcc = 0; 460 tif->tif_rawdatasize = 0; 461 tif->tif_rawdataoff = 0; 462 tif->tif_rawdataloaded = 0; 463 } 464 tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP); 465 } 466 dir=NULL; 467 dirmem=NULL; 468 dirsize=0; 469 while (1) 470 { 471 ndir=0; 472 if (isimage) 473 { 474 if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) 475 { 476 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH,tif->tif_dir.td_imagewidth)) 477 goto bad; 478 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH,tif->tif_dir.td_imagelength)) 479 goto bad; 480 } 481 if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) 482 { 483 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILEWIDTH,tif->tif_dir.td_tilewidth)) 484 goto bad; 485 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH,tif->tif_dir.td_tilelength)) 486 goto bad; 487 } 488 if (TIFFFieldSet(tif,FIELD_RESOLUTION)) 489 { 490 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION,tif->tif_dir.td_xresolution)) 491 goto bad; 492 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION,tif->tif_dir.td_yresolution)) 493 goto bad; 494 } 495 if (TIFFFieldSet(tif,FIELD_POSITION)) 496 { 497 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XPOSITION,tif->tif_dir.td_xposition)) 498 goto bad; 499 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YPOSITION,tif->tif_dir.td_yposition)) 500 goto bad; 501 } 502 if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) 503 { 504 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_SUBFILETYPE,tif->tif_dir.td_subfiletype)) 505 goto bad; 506 } 507 if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE)) 508 { 509 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE,tif->tif_dir.td_bitspersample)) 510 goto bad; 511 } 512 if (TIFFFieldSet(tif,FIELD_COMPRESSION)) 513 { 514 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_COMPRESSION,tif->tif_dir.td_compression)) 515 goto bad; 516 } 517 if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) 518 { 519 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PHOTOMETRIC,tif->tif_dir.td_photometric)) 520 goto bad; 521 } 522 if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) 523 { 524 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING,tif->tif_dir.td_threshholding)) 525 goto bad; 526 } 527 if (TIFFFieldSet(tif,FIELD_FILLORDER)) 528 { 529 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_FILLORDER,tif->tif_dir.td_fillorder)) 530 goto bad; 531 } 532 if (TIFFFieldSet(tif,FIELD_ORIENTATION)) 533 { 534 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_ORIENTATION,tif->tif_dir.td_orientation)) 535 goto bad; 536 } 537 if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL)) 538 { 539 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL,tif->tif_dir.td_samplesperpixel)) 540 goto bad; 541 } 542 if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) 543 { 544 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP,tif->tif_dir.td_rowsperstrip)) 545 goto bad; 546 } 547 if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE)) 548 { 549 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE,tif->tif_dir.td_minsamplevalue)) 550 goto bad; 551 } 552 if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE)) 553 { 554 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE,tif->tif_dir.td_maxsamplevalue)) 555 goto bad; 556 } 557 if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) 558 { 559 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG,tif->tif_dir.td_planarconfig)) 560 goto bad; 561 } 562 if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) 563 { 564 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT,tif->tif_dir.td_resolutionunit)) 565 goto bad; 566 } 567 if (TIFFFieldSet(tif,FIELD_PAGENUMBER)) 568 { 569 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER,2,&tif->tif_dir.td_pagenumber[0])) 570 goto bad; 571 } 572 if (TIFFFieldSet(tif,FIELD_STRIPBYTECOUNTS)) 573 { 574 if (!isTiled(tif)) 575 { 576 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount_p)) 577 goto bad; 578 } 579 else 580 { 581 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount_p)) 582 goto bad; 583 } 584 } 585 if (TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) 586 { 587 if (!isTiled(tif)) 588 { 589 /* td_stripoffset_p might be NULL in an odd OJPEG case. See 590 * tif_dirread.c around line 3634. 591 * XXX: OJPEG hack. 592 * If a) compression is OJPEG, b) it's not a tiled TIFF, 593 * and c) the number of strips is 1, 594 * then we tolerate the absence of stripoffsets tag, 595 * because, presumably, all required data is in the 596 * JpegInterchangeFormat stream. 597 * We can get here when using tiffset on such a file. 598 * See http://bugzilla.maptools.org/show_bug.cgi?id=2500 599 */ 600 if (tif->tif_dir.td_stripoffset_p != NULL && 601 !TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset_p)) 602 goto bad; 603 } 604 else 605 { 606 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset_p)) 607 goto bad; 608 } 609 } 610 if (TIFFFieldSet(tif,FIELD_COLORMAP)) 611 { 612 if (!TIFFWriteDirectoryTagColormap(tif,&ndir,dir)) 613 goto bad; 614 } 615 if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES)) 616 { 617 if (tif->tif_dir.td_extrasamples) 618 { 619 uint16 na; 620 uint16* nb; 621 TIFFGetFieldDefaulted(tif,TIFFTAG_EXTRASAMPLES,&na,&nb); 622 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_EXTRASAMPLES,na,nb)) 623 goto bad; 624 } 625 } 626 if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) 627 { 628 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT,tif->tif_dir.td_sampleformat)) 629 goto bad; 630 } 631 if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) 632 { 633 if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue)) 634 goto bad; 635 } 636 if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) 637 { 638 if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue)) 639 goto bad; 640 } 641 if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH)) 642 { 643 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_IMAGEDEPTH,tif->tif_dir.td_imagedepth)) 644 goto bad; 645 } 646 if (TIFFFieldSet(tif,FIELD_TILEDEPTH)) 647 { 648 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_TILEDEPTH,tif->tif_dir.td_tiledepth)) 649 goto bad; 650 } 651 if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS)) 652 { 653 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS,2,&tif->tif_dir.td_halftonehints[0])) 654 goto bad; 655 } 656 if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING)) 657 { 658 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING,2,&tif->tif_dir.td_ycbcrsubsampling[0])) 659 goto bad; 660 } 661 if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) 662 { 663 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING,tif->tif_dir.td_ycbcrpositioning)) 664 goto bad; 665 } 666 if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) 667 { 668 if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE,6,tif->tif_dir.td_refblackwhite)) 669 goto bad; 670 } 671 if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) 672 { 673 if (!TIFFWriteDirectoryTagTransferfunction(tif,&ndir,dir)) 674 goto bad; 675 } 676 if (TIFFFieldSet(tif,FIELD_INKNAMES)) 677 { 678 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames)) 679 goto bad; 680 } 681 if (TIFFFieldSet(tif,FIELD_SUBIFD)) 682 { 683 if (!TIFFWriteDirectoryTagSubifd(tif,&ndir,dir)) 684 goto bad; 685 } 686 { 687 uint32 n; 688 for (n=0; n<tif->tif_nfields; n++) { 689 const TIFFField* o; 690 o = tif->tif_fields[n]; 691 if ((o->field_bit>=FIELD_CODEC)&&(TIFFFieldSet(tif,o->field_bit))) 692 { 693 switch (o->get_field_type) 694 { 695 case TIFF_SETGET_ASCII: 696 { 697 uint32 pa; 698 char* pb; 699 assert(o->field_type==TIFF_ASCII); 700 assert(o->field_readcount==TIFF_VARIABLE); 701 assert(o->field_passcount==0); 702 TIFFGetField(tif,o->field_tag,&pb); 703 pa=(uint32)(strlen(pb)); 704 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,(uint16)o->field_tag,pa,pb)) 705 goto bad; 706 } 707 break; 708 case TIFF_SETGET_UINT16: 709 { 710 uint16 p; 711 assert(o->field_type==TIFF_SHORT); 712 assert(o->field_readcount==1); 713 assert(o->field_passcount==0); 714 TIFFGetField(tif,o->field_tag,&p); 715 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,(uint16)o->field_tag,p)) 716 goto bad; 717 } 718 break; 719 case TIFF_SETGET_UINT32: 720 { 721 uint32 p; 722 assert(o->field_type==TIFF_LONG); 723 assert(o->field_readcount==1); 724 assert(o->field_passcount==0); 725 TIFFGetField(tif,o->field_tag,&p); 726 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,(uint16)o->field_tag,p)) 727 goto bad; 728 } 729 break; 730 case TIFF_SETGET_C32_UINT8: 731 { 732 uint32 pa; 733 void* pb; 734 assert(o->field_type==TIFF_UNDEFINED); 735 assert(o->field_readcount==TIFF_VARIABLE2); 736 assert(o->field_passcount==1); 737 TIFFGetField(tif,o->field_tag,&pa,&pb); 738 if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,(uint16)o->field_tag,pa,pb)) 739 goto bad; 740 } 741 break; 742 default: 743 TIFFErrorExt(tif->tif_clientdata,module, 744 "Cannot write tag %d (%s)", 745 TIFFFieldTag(o), 746 o->field_name ? o->field_name : "unknown"); 747 goto bad; 748 } 749 } 750 } 751 } 752 } 753 for (m=0; m<(uint32)(tif->tif_dir.td_customValueCount); m++) 754 { 755 uint16 tag = (uint16)tif->tif_dir.td_customValues[m].info->field_tag; 756 uint32 count = tif->tif_dir.td_customValues[m].count; 757 switch (tif->tif_dir.td_customValues[m].info->field_type) 758 { 759 case TIFF_ASCII: 760 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 761 goto bad; 762 break; 763 case TIFF_UNDEFINED: 764 if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 765 goto bad; 766 break; 767 case TIFF_BYTE: 768 if (!TIFFWriteDirectoryTagByteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 769 goto bad; 770 break; 771 case TIFF_SBYTE: 772 if (!TIFFWriteDirectoryTagSbyteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 773 goto bad; 774 break; 775 case TIFF_SHORT: 776 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 777 goto bad; 778 break; 779 case TIFF_SSHORT: 780 if (!TIFFWriteDirectoryTagSshortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 781 goto bad; 782 break; 783 case TIFF_LONG: 784 if (!TIFFWriteDirectoryTagLongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 785 goto bad; 786 break; 787 case TIFF_SLONG: 788 if (!TIFFWriteDirectoryTagSlongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 789 goto bad; 790 break; 791 case TIFF_LONG8: 792 if (!TIFFWriteDirectoryTagLong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 793 goto bad; 794 break; 795 case TIFF_SLONG8: 796 if (!TIFFWriteDirectoryTagSlong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 797 goto bad; 798 break; 799 case TIFF_RATIONAL: 800 if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 801 goto bad; 802 break; 803 case TIFF_SRATIONAL: 804 if (!TIFFWriteDirectoryTagSrationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 805 goto bad; 806 break; 807 case TIFF_FLOAT: 808 if (!TIFFWriteDirectoryTagFloatArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 809 goto bad; 810 break; 811 case TIFF_DOUBLE: 812 if (!TIFFWriteDirectoryTagDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 813 goto bad; 814 break; 815 case TIFF_IFD: 816 if (!TIFFWriteDirectoryTagIfdArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 817 goto bad; 818 break; 819 case TIFF_IFD8: 820 if (!TIFFWriteDirectoryTagIfdIfd8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value)) 821 goto bad; 822 break; 823 default: 824 assert(0); /* we should never get here */ 825 break; 826 } 827 } 828 if (dir!=NULL) 829 break; 830 dir=_TIFFmalloc(ndir*sizeof(TIFFDirEntry)); 831 if (dir==NULL) 832 { 833 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 834 goto bad; 835 } 836 if (isimage) 837 { 838 if ((tif->tif_diroff==0)&&(!TIFFLinkDirectory(tif))) 839 goto bad; 840 } 841 else 842 tif->tif_diroff=(TIFFSeekFile(tif,0,SEEK_END)+1)&(~((toff_t)1)); 843 if (pdiroff!=NULL) 844 *pdiroff=tif->tif_diroff; 845 if (!(tif->tif_flags&TIFF_BIGTIFF)) 846 dirsize=2+ndir*12+4; 847 else 848 dirsize=8+ndir*20+8; 849 tif->tif_dataoff=tif->tif_diroff+dirsize; 850 if (!(tif->tif_flags&TIFF_BIGTIFF)) 851 tif->tif_dataoff=(uint32)tif->tif_dataoff; 852 if ((tif->tif_dataoff<tif->tif_diroff)||(tif->tif_dataoff<(uint64)dirsize)) 853 { 854 TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded"); 855 goto bad; 856 } 857 if (tif->tif_dataoff&1) 858 tif->tif_dataoff++; 859 if (isimage) 860 tif->tif_curdir++; 861 } 862 if (isimage) 863 { 864 if (TIFFFieldSet(tif,FIELD_SUBIFD)&&(tif->tif_subifdoff==0)) 865 { 866 uint32 na; 867 TIFFDirEntry* nb; 868 for (na=0, nb=dir; ; na++, nb++) 869 { 870 if( na == ndir ) 871 { 872 TIFFErrorExt(tif->tif_clientdata,module, 873 "Cannot find SubIFD tag"); 874 goto bad; 875 } 876 if (nb->tdir_tag==TIFFTAG_SUBIFD) 877 break; 878 } 879 if (!(tif->tif_flags&TIFF_BIGTIFF)) 880 tif->tif_subifdoff=tif->tif_diroff+2+na*12+8; 881 else 882 tif->tif_subifdoff=tif->tif_diroff+8+na*20+12; 883 } 884 } 885 dirmem=_TIFFmalloc(dirsize); 886 if (dirmem==NULL) 887 { 888 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 889 goto bad; 890 } 891 if (!(tif->tif_flags&TIFF_BIGTIFF)) 892 { 893 uint8* n; 894 uint32 nTmp; 895 TIFFDirEntry* o; 896 n=dirmem; 897 *(uint16*)n=(uint16)ndir; 898 if (tif->tif_flags&TIFF_SWAB) 899 TIFFSwabShort((uint16*)n); 900 n+=2; 901 o=dir; 902 for (m=0; m<ndir; m++) 903 { 904 *(uint16*)n=o->tdir_tag; 905 if (tif->tif_flags&TIFF_SWAB) 906 TIFFSwabShort((uint16*)n); 907 n+=2; 908 *(uint16*)n=o->tdir_type; 909 if (tif->tif_flags&TIFF_SWAB) 910 TIFFSwabShort((uint16*)n); 911 n+=2; 912 nTmp = (uint32)o->tdir_count; 913 _TIFFmemcpy(n,&nTmp,4); 914 if (tif->tif_flags&TIFF_SWAB) 915 TIFFSwabLong((uint32*)n); 916 n+=4; 917 /* This is correct. The data has been */ 918 /* swabbed previously in TIFFWriteDirectoryTagData */ 919 _TIFFmemcpy(n,&o->tdir_offset,4); 920 n+=4; 921 o++; 922 } 923 nTmp = (uint32)tif->tif_nextdiroff; 924 if (tif->tif_flags&TIFF_SWAB) 925 TIFFSwabLong(&nTmp); 926 _TIFFmemcpy(n,&nTmp,4); 927 } 928 else 929 { 930 uint8* n; 931 TIFFDirEntry* o; 932 n=dirmem; 933 *(uint64*)n=ndir; 934 if (tif->tif_flags&TIFF_SWAB) 935 TIFFSwabLong8((uint64*)n); 936 n+=8; 937 o=dir; 938 for (m=0; m<ndir; m++) 939 { 940 *(uint16*)n=o->tdir_tag; 941 if (tif->tif_flags&TIFF_SWAB) 942 TIFFSwabShort((uint16*)n); 943 n+=2; 944 *(uint16*)n=o->tdir_type; 945 if (tif->tif_flags&TIFF_SWAB) 946 TIFFSwabShort((uint16*)n); 947 n+=2; 948 _TIFFmemcpy(n,&o->tdir_count,8); 949 if (tif->tif_flags&TIFF_SWAB) 950 TIFFSwabLong8((uint64*)n); 951 n+=8; 952 _TIFFmemcpy(n,&o->tdir_offset,8); 953 n+=8; 954 o++; 955 } 956 _TIFFmemcpy(n,&tif->tif_nextdiroff,8); 957 if (tif->tif_flags&TIFF_SWAB) 958 TIFFSwabLong8((uint64*)n); 959 } 960 _TIFFfree(dir); 961 dir=NULL; 962 if (!SeekOK(tif,tif->tif_diroff)) 963 { 964 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory"); 965 goto bad; 966 } 967 if (!WriteOK(tif,dirmem,(tmsize_t)dirsize)) 968 { 969 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory"); 970 goto bad; 971 } 972 _TIFFfree(dirmem); 973 if (imagedone) 974 { 975 TIFFFreeDirectory(tif); 976 tif->tif_flags &= ~TIFF_DIRTYDIRECT; 977 tif->tif_flags &= ~TIFF_DIRTYSTRIP; 978 (*tif->tif_cleanup)(tif); 979 /* 980 * Reset directory-related state for subsequent 981 * directories. 982 */ 983 TIFFCreateDirectory(tif); 984 } 985 return(1); 986 bad: 987 if (dir!=NULL) 988 _TIFFfree(dir); 989 if (dirmem!=NULL) 990 _TIFFfree(dirmem); 991 return(0); 992 } 993 994 static int8 TIFFClampDoubleToInt8( double val ) 995 { 996 if( val > 127 ) 997 return 127; 998 if( val < -128 || val != val ) 999 return -128; 1000 return (int8)val; 1001 } 1002 1003 static int16 TIFFClampDoubleToInt16( double val ) 1004 { 1005 if( val > 32767 ) 1006 return 32767; 1007 if( val < -32768 || val != val ) 1008 return -32768; 1009 return (int16)val; 1010 } 1011 1012 static int32 TIFFClampDoubleToInt32( double val ) 1013 { 1014 if( val > 0x7FFFFFFF ) 1015 return 0x7FFFFFFF; 1016 if( val < -0x7FFFFFFF-1 || val != val ) 1017 return -0x7FFFFFFF-1; 1018 return (int32)val; 1019 } 1020 1021 static uint8 TIFFClampDoubleToUInt8( double val ) 1022 { 1023 if( val < 0 ) 1024 return 0; 1025 if( val > 255 || val != val ) 1026 return 255; 1027 return (uint8)val; 1028 } 1029 1030 static uint16 TIFFClampDoubleToUInt16( double val ) 1031 { 1032 if( val < 0 ) 1033 return 0; 1034 if( val > 65535 || val != val ) 1035 return 65535; 1036 return (uint16)val; 1037 } 1038 1039 static uint32 TIFFClampDoubleToUInt32( double val ) 1040 { 1041 if( val < 0 ) 1042 return 0; 1043 if( val > 0xFFFFFFFFU || val != val ) 1044 return 0xFFFFFFFFU; 1045 return (uint32)val; 1046 } 1047 1048 static int 1049 TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value) 1050 { 1051 static const char module[] = "TIFFWriteDirectoryTagSampleformatArray"; 1052 void* conv; 1053 uint32 i; 1054 int ok; 1055 conv = _TIFFmalloc(count*sizeof(double)); 1056 if (conv == NULL) 1057 { 1058 TIFFErrorExt(tif->tif_clientdata, module, "Out of memory"); 1059 return (0); 1060 } 1061 1062 switch (tif->tif_dir.td_sampleformat) 1063 { 1064 case SAMPLEFORMAT_IEEEFP: 1065 if (tif->tif_dir.td_bitspersample<=32) 1066 { 1067 for (i = 0; i < count; ++i) 1068 ((float*)conv)[i] = _TIFFClampDoubleToFloat(value[i]); 1069 ok = TIFFWriteDirectoryTagFloatArray(tif,ndir,dir,tag,count,(float*)conv); 1070 } 1071 else 1072 { 1073 ok = TIFFWriteDirectoryTagDoubleArray(tif,ndir,dir,tag,count,value); 1074 } 1075 break; 1076 case SAMPLEFORMAT_INT: 1077 if (tif->tif_dir.td_bitspersample<=8) 1078 { 1079 for (i = 0; i < count; ++i) 1080 ((int8*)conv)[i] = TIFFClampDoubleToInt8(value[i]); 1081 ok = TIFFWriteDirectoryTagSbyteArray(tif,ndir,dir,tag,count,(int8*)conv); 1082 } 1083 else if (tif->tif_dir.td_bitspersample<=16) 1084 { 1085 for (i = 0; i < count; ++i) 1086 ((int16*)conv)[i] = TIFFClampDoubleToInt16(value[i]); 1087 ok = TIFFWriteDirectoryTagSshortArray(tif,ndir,dir,tag,count,(int16*)conv); 1088 } 1089 else 1090 { 1091 for (i = 0; i < count; ++i) 1092 ((int32*)conv)[i] = TIFFClampDoubleToInt32(value[i]); 1093 ok = TIFFWriteDirectoryTagSlongArray(tif,ndir,dir,tag,count,(int32*)conv); 1094 } 1095 break; 1096 case SAMPLEFORMAT_UINT: 1097 if (tif->tif_dir.td_bitspersample<=8) 1098 { 1099 for (i = 0; i < count; ++i) 1100 ((uint8*)conv)[i] = TIFFClampDoubleToUInt8(value[i]); 1101 ok = TIFFWriteDirectoryTagByteArray(tif,ndir,dir,tag,count,(uint8*)conv); 1102 } 1103 else if (tif->tif_dir.td_bitspersample<=16) 1104 { 1105 for (i = 0; i < count; ++i) 1106 ((uint16*)conv)[i] = TIFFClampDoubleToUInt16(value[i]); 1107 ok = TIFFWriteDirectoryTagShortArray(tif,ndir,dir,tag,count,(uint16*)conv); 1108 } 1109 else 1110 { 1111 for (i = 0; i < count; ++i) 1112 ((uint32*)conv)[i] = TIFFClampDoubleToUInt32(value[i]); 1113 ok = TIFFWriteDirectoryTagLongArray(tif,ndir,dir,tag,count,(uint32*)conv); 1114 } 1115 break; 1116 default: 1117 ok = 0; 1118 } 1119 1120 _TIFFfree(conv); 1121 return (ok); 1122 } 1123 1124 #if 0 1125 static int 1126 TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) 1127 { 1128 switch (tif->tif_dir.td_sampleformat) 1129 { 1130 case SAMPLEFORMAT_IEEEFP: 1131 if (tif->tif_dir.td_bitspersample<=32) 1132 return(TIFFWriteDirectoryTagFloatPerSample(tif,ndir,dir,tag,(float)value)); 1133 else 1134 return(TIFFWriteDirectoryTagDoublePerSample(tif,ndir,dir,tag,value)); 1135 case SAMPLEFORMAT_INT: 1136 if (tif->tif_dir.td_bitspersample<=8) 1137 return(TIFFWriteDirectoryTagSbytePerSample(tif,ndir,dir,tag,(int8)value)); 1138 else if (tif->tif_dir.td_bitspersample<=16) 1139 return(TIFFWriteDirectoryTagSshortPerSample(tif,ndir,dir,tag,(int16)value)); 1140 else 1141 return(TIFFWriteDirectoryTagSlongPerSample(tif,ndir,dir,tag,(int32)value)); 1142 case SAMPLEFORMAT_UINT: 1143 if (tif->tif_dir.td_bitspersample<=8) 1144 return(TIFFWriteDirectoryTagBytePerSample(tif,ndir,dir,tag,(uint8)value)); 1145 else if (tif->tif_dir.td_bitspersample<=16) 1146 return(TIFFWriteDirectoryTagShortPerSample(tif,ndir,dir,tag,(uint16)value)); 1147 else 1148 return(TIFFWriteDirectoryTagLongPerSample(tif,ndir,dir,tag,(uint32)value)); 1149 default: 1150 return(1); 1151 } 1152 } 1153 #endif 1154 1155 static int 1156 TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value) 1157 { 1158 if (dir==NULL) 1159 { 1160 (*ndir)++; 1161 return(1); 1162 } 1163 return(TIFFWriteDirectoryTagCheckedAscii(tif,ndir,dir,tag,count,value)); 1164 } 1165 1166 static int 1167 TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) 1168 { 1169 if (dir==NULL) 1170 { 1171 (*ndir)++; 1172 return(1); 1173 } 1174 return(TIFFWriteDirectoryTagCheckedUndefinedArray(tif,ndir,dir,tag,count,value)); 1175 } 1176 1177 #ifdef notdef 1178 static int 1179 TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value) 1180 { 1181 if (dir==NULL) 1182 { 1183 (*ndir)++; 1184 return(1); 1185 } 1186 return(TIFFWriteDirectoryTagCheckedByte(tif,ndir,dir,tag,value)); 1187 } 1188 #endif 1189 1190 static int 1191 TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) 1192 { 1193 if (dir==NULL) 1194 { 1195 (*ndir)++; 1196 return(1); 1197 } 1198 return(TIFFWriteDirectoryTagCheckedByteArray(tif,ndir,dir,tag,count,value)); 1199 } 1200 1201 #if 0 1202 static int 1203 TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value) 1204 { 1205 static const char module[] = "TIFFWriteDirectoryTagBytePerSample"; 1206 uint8* m; 1207 uint8* na; 1208 uint16 nb; 1209 int o; 1210 if (dir==NULL) 1211 { 1212 (*ndir)++; 1213 return(1); 1214 } 1215 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint8)); 1216 if (m==NULL) 1217 { 1218 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1219 return(0); 1220 } 1221 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1222 *na=value; 1223 o=TIFFWriteDirectoryTagCheckedByteArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1224 _TIFFfree(m); 1225 return(o); 1226 } 1227 #endif 1228 1229 #ifdef notdef 1230 static int 1231 TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value) 1232 { 1233 if (dir==NULL) 1234 { 1235 (*ndir)++; 1236 return(1); 1237 } 1238 return(TIFFWriteDirectoryTagCheckedSbyte(tif,ndir,dir,tag,value)); 1239 } 1240 #endif 1241 1242 static int 1243 TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value) 1244 { 1245 if (dir==NULL) 1246 { 1247 (*ndir)++; 1248 return(1); 1249 } 1250 return(TIFFWriteDirectoryTagCheckedSbyteArray(tif,ndir,dir,tag,count,value)); 1251 } 1252 1253 #if 0 1254 static int 1255 TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value) 1256 { 1257 static const char module[] = "TIFFWriteDirectoryTagSbytePerSample"; 1258 int8* m; 1259 int8* na; 1260 uint16 nb; 1261 int o; 1262 if (dir==NULL) 1263 { 1264 (*ndir)++; 1265 return(1); 1266 } 1267 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int8)); 1268 if (m==NULL) 1269 { 1270 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1271 return(0); 1272 } 1273 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1274 *na=value; 1275 o=TIFFWriteDirectoryTagCheckedSbyteArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1276 _TIFFfree(m); 1277 return(o); 1278 } 1279 #endif 1280 1281 static int 1282 TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value) 1283 { 1284 if (dir==NULL) 1285 { 1286 (*ndir)++; 1287 return(1); 1288 } 1289 return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,value)); 1290 } 1291 1292 static int 1293 TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value) 1294 { 1295 if (dir==NULL) 1296 { 1297 (*ndir)++; 1298 return(1); 1299 } 1300 return(TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,value)); 1301 } 1302 1303 static int 1304 TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value) 1305 { 1306 static const char module[] = "TIFFWriteDirectoryTagShortPerSample"; 1307 uint16* m; 1308 uint16* na; 1309 uint16 nb; 1310 int o; 1311 if (dir==NULL) 1312 { 1313 (*ndir)++; 1314 return(1); 1315 } 1316 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint16)); 1317 if (m==NULL) 1318 { 1319 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1320 return(0); 1321 } 1322 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1323 *na=value; 1324 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1325 _TIFFfree(m); 1326 return(o); 1327 } 1328 1329 #ifdef notdef 1330 static int 1331 TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value) 1332 { 1333 if (dir==NULL) 1334 { 1335 (*ndir)++; 1336 return(1); 1337 } 1338 return(TIFFWriteDirectoryTagCheckedSshort(tif,ndir,dir,tag,value)); 1339 } 1340 #endif 1341 1342 static int 1343 TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value) 1344 { 1345 if (dir==NULL) 1346 { 1347 (*ndir)++; 1348 return(1); 1349 } 1350 return(TIFFWriteDirectoryTagCheckedSshortArray(tif,ndir,dir,tag,count,value)); 1351 } 1352 1353 #if 0 1354 static int 1355 TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value) 1356 { 1357 static const char module[] = "TIFFWriteDirectoryTagSshortPerSample"; 1358 int16* m; 1359 int16* na; 1360 uint16 nb; 1361 int o; 1362 if (dir==NULL) 1363 { 1364 (*ndir)++; 1365 return(1); 1366 } 1367 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int16)); 1368 if (m==NULL) 1369 { 1370 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1371 return(0); 1372 } 1373 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1374 *na=value; 1375 o=TIFFWriteDirectoryTagCheckedSshortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1376 _TIFFfree(m); 1377 return(o); 1378 } 1379 #endif 1380 1381 static int 1382 TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) 1383 { 1384 if (dir==NULL) 1385 { 1386 (*ndir)++; 1387 return(1); 1388 } 1389 return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value)); 1390 } 1391 1392 static int 1393 TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) 1394 { 1395 if (dir==NULL) 1396 { 1397 (*ndir)++; 1398 return(1); 1399 } 1400 return(TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,value)); 1401 } 1402 1403 #if 0 1404 static int 1405 TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) 1406 { 1407 static const char module[] = "TIFFWriteDirectoryTagLongPerSample"; 1408 uint32* m; 1409 uint32* na; 1410 uint16 nb; 1411 int o; 1412 if (dir==NULL) 1413 { 1414 (*ndir)++; 1415 return(1); 1416 } 1417 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint32)); 1418 if (m==NULL) 1419 { 1420 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1421 return(0); 1422 } 1423 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1424 *na=value; 1425 o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1426 _TIFFfree(m); 1427 return(o); 1428 } 1429 #endif 1430 1431 #ifdef notdef 1432 static int 1433 TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value) 1434 { 1435 if (dir==NULL) 1436 { 1437 (*ndir)++; 1438 return(1); 1439 } 1440 return(TIFFWriteDirectoryTagCheckedSlong(tif,ndir,dir,tag,value)); 1441 } 1442 #endif 1443 1444 static int 1445 TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value) 1446 { 1447 if (dir==NULL) 1448 { 1449 (*ndir)++; 1450 return(1); 1451 } 1452 return(TIFFWriteDirectoryTagCheckedSlongArray(tif,ndir,dir,tag,count,value)); 1453 } 1454 1455 #if 0 1456 static int 1457 TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value) 1458 { 1459 static const char module[] = "TIFFWriteDirectoryTagSlongPerSample"; 1460 int32* m; 1461 int32* na; 1462 uint16 nb; 1463 int o; 1464 if (dir==NULL) 1465 { 1466 (*ndir)++; 1467 return(1); 1468 } 1469 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int32)); 1470 if (m==NULL) 1471 { 1472 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1473 return(0); 1474 } 1475 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1476 *na=value; 1477 o=TIFFWriteDirectoryTagCheckedSlongArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1478 _TIFFfree(m); 1479 return(o); 1480 } 1481 #endif 1482 1483 #ifdef notdef 1484 static int 1485 TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value) 1486 { 1487 if (dir==NULL) 1488 { 1489 (*ndir)++; 1490 return(1); 1491 } 1492 return(TIFFWriteDirectoryTagCheckedLong8(tif,ndir,dir,tag,value)); 1493 } 1494 #endif 1495 1496 static int 1497 TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 1498 { 1499 if (dir==NULL) 1500 { 1501 (*ndir)++; 1502 return(1); 1503 } 1504 return(TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value)); 1505 } 1506 1507 #ifdef notdef 1508 static int 1509 TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value) 1510 { 1511 if (dir==NULL) 1512 { 1513 (*ndir)++; 1514 return(1); 1515 } 1516 return(TIFFWriteDirectoryTagCheckedSlong8(tif,ndir,dir,tag,value)); 1517 } 1518 #endif 1519 1520 static int 1521 TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value) 1522 { 1523 if (dir==NULL) 1524 { 1525 (*ndir)++; 1526 return(1); 1527 } 1528 return(TIFFWriteDirectoryTagCheckedSlong8Array(tif,ndir,dir,tag,count,value)); 1529 } 1530 1531 static int 1532 TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) 1533 { 1534 if (dir==NULL) 1535 { 1536 (*ndir)++; 1537 return(1); 1538 } 1539 return(TIFFWriteDirectoryTagCheckedRational(tif,ndir,dir,tag,value)); 1540 } 1541 1542 static int 1543 TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) 1544 { 1545 if (dir==NULL) 1546 { 1547 (*ndir)++; 1548 return(1); 1549 } 1550 return(TIFFWriteDirectoryTagCheckedRationalArray(tif,ndir,dir,tag,count,value)); 1551 } 1552 1553 static int 1554 TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) 1555 { 1556 if (dir==NULL) 1557 { 1558 (*ndir)++; 1559 return(1); 1560 } 1561 return(TIFFWriteDirectoryTagCheckedSrationalArray(tif,ndir,dir,tag,count,value)); 1562 } 1563 1564 #ifdef notdef 1565 static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value) 1566 { 1567 if (dir==NULL) 1568 { 1569 (*ndir)++; 1570 return(1); 1571 } 1572 return(TIFFWriteDirectoryTagCheckedFloat(tif,ndir,dir,tag,value)); 1573 } 1574 #endif 1575 1576 static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) 1577 { 1578 if (dir==NULL) 1579 { 1580 (*ndir)++; 1581 return(1); 1582 } 1583 return(TIFFWriteDirectoryTagCheckedFloatArray(tif,ndir,dir,tag,count,value)); 1584 } 1585 1586 #if 0 1587 static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value) 1588 { 1589 static const char module[] = "TIFFWriteDirectoryTagFloatPerSample"; 1590 float* m; 1591 float* na; 1592 uint16 nb; 1593 int o; 1594 if (dir==NULL) 1595 { 1596 (*ndir)++; 1597 return(1); 1598 } 1599 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(float)); 1600 if (m==NULL) 1601 { 1602 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1603 return(0); 1604 } 1605 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1606 *na=value; 1607 o=TIFFWriteDirectoryTagCheckedFloatArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1608 _TIFFfree(m); 1609 return(o); 1610 } 1611 #endif 1612 1613 #ifdef notdef 1614 static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) 1615 { 1616 if (dir==NULL) 1617 { 1618 (*ndir)++; 1619 return(1); 1620 } 1621 return(TIFFWriteDirectoryTagCheckedDouble(tif,ndir,dir,tag,value)); 1622 } 1623 #endif 1624 1625 static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value) 1626 { 1627 if (dir==NULL) 1628 { 1629 (*ndir)++; 1630 return(1); 1631 } 1632 return(TIFFWriteDirectoryTagCheckedDoubleArray(tif,ndir,dir,tag,count,value)); 1633 } 1634 1635 #if 0 1636 static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) 1637 { 1638 static const char module[] = "TIFFWriteDirectoryTagDoublePerSample"; 1639 double* m; 1640 double* na; 1641 uint16 nb; 1642 int o; 1643 if (dir==NULL) 1644 { 1645 (*ndir)++; 1646 return(1); 1647 } 1648 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(double)); 1649 if (m==NULL) 1650 { 1651 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1652 return(0); 1653 } 1654 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) 1655 *na=value; 1656 o=TIFFWriteDirectoryTagCheckedDoubleArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); 1657 _TIFFfree(m); 1658 return(o); 1659 } 1660 #endif 1661 1662 static int 1663 TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) 1664 { 1665 if (dir==NULL) 1666 { 1667 (*ndir)++; 1668 return(1); 1669 } 1670 return(TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,value)); 1671 } 1672 1673 #ifdef notdef 1674 static int 1675 TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 1676 { 1677 if (dir==NULL) 1678 { 1679 (*ndir)++; 1680 return(1); 1681 } 1682 return(TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,tag,count,value)); 1683 } 1684 #endif 1685 1686 static int 1687 TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) 1688 { 1689 if (dir==NULL) 1690 { 1691 (*ndir)++; 1692 return(1); 1693 } 1694 if (value<=0xFFFF) 1695 return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,(uint16)value)); 1696 else 1697 return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value)); 1698 } 1699 1700 static int _WriteAsType(TIFF* tif, uint64 strile_size, uint64 uncompressed_threshold) 1701 { 1702 const uint16 compression = tif->tif_dir.td_compression; 1703 if ( compression == COMPRESSION_NONE ) 1704 { 1705 return strile_size > uncompressed_threshold; 1706 } 1707 else if ( compression == COMPRESSION_JPEG || 1708 compression == COMPRESSION_LZW || 1709 compression == COMPRESSION_ADOBE_DEFLATE || 1710 compression == COMPRESSION_LZMA || 1711 compression == COMPRESSION_LERC || 1712 compression == COMPRESSION_ZSTD || 1713 compression == COMPRESSION_WEBP ) 1714 { 1715 /* For a few select compression types, we assume that in the worst */ 1716 /* case the compressed size will be 10 times the uncompressed size */ 1717 /* This is overly pessismistic ! */ 1718 return strile_size >= uncompressed_threshold / 10; 1719 } 1720 return 1; 1721 } 1722 1723 static int WriteAsLong8(TIFF* tif, uint64 strile_size) 1724 { 1725 return _WriteAsType(tif, strile_size, 0xFFFFFFFFU); 1726 } 1727 1728 static int WriteAsLong4(TIFF* tif, uint64 strile_size) 1729 { 1730 return _WriteAsType(tif, strile_size, 0xFFFFU); 1731 } 1732 1733 /************************************************************************/ 1734 /* TIFFWriteDirectoryTagLongLong8Array() */ 1735 /* */ 1736 /* Write out LONG8 array and write a SHORT/LONG/LONG8 depending */ 1737 /* on strile size and Classic/BigTIFF mode. */ 1738 /************************************************************************/ 1739 1740 static int 1741 TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 1742 { 1743 static const char module[] = "TIFFWriteDirectoryTagLongLong8Array"; 1744 int o; 1745 int write_aslong4; 1746 1747 /* is this just a counting pass? */ 1748 if (dir==NULL) 1749 { 1750 (*ndir)++; 1751 return(1); 1752 } 1753 1754 if( tif->tif_dir.td_deferstrilearraywriting ) 1755 { 1756 return TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_NOTYPE, 0, 0, NULL); 1757 } 1758 1759 if( tif->tif_flags&TIFF_BIGTIFF ) 1760 { 1761 int write_aslong8 = 1; 1762 /* In the case of ByteCounts array, we may be able to write them on */ 1763 /* LONG if the strip/tilesize is not too big. */ 1764 /* Also do that for count > 1 in the case someone would want to create */ 1765 /* a single-strip file with a growing height, in which case using */ 1766 /* LONG8 will be safer. */ 1767 if( count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS ) 1768 { 1769 write_aslong8 = WriteAsLong8(tif, TIFFStripSize64(tif)); 1770 } 1771 else if( count > 1 && tag == TIFFTAG_TILEBYTECOUNTS ) 1772 { 1773 write_aslong8 = WriteAsLong8(tif, TIFFTileSize64(tif)); 1774 } 1775 if( write_aslong8 ) 1776 { 1777 return TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir, 1778 tag,count,value); 1779 } 1780 } 1781 1782 write_aslong4 = 1; 1783 if( count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS ) 1784 { 1785 write_aslong4 = WriteAsLong4(tif, TIFFStripSize64(tif)); 1786 } 1787 else if( count > 1 && tag == TIFFTAG_TILEBYTECOUNTS ) 1788 { 1789 write_aslong4 = WriteAsLong4(tif, TIFFTileSize64(tif)); 1790 } 1791 if( write_aslong4 ) 1792 { 1793 /* 1794 ** For classic tiff we want to verify everything is in range for LONG 1795 ** and convert to long format. 1796 */ 1797 1798 uint32* p = _TIFFmalloc(count*sizeof(uint32)); 1799 uint32* q; 1800 uint64* ma; 1801 uint32 mb; 1802 1803 if (p==NULL) 1804 { 1805 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1806 return(0); 1807 } 1808 1809 for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++) 1810 { 1811 if (*ma>0xFFFFFFFF) 1812 { 1813 TIFFErrorExt(tif->tif_clientdata,module, 1814 "Attempt to write value larger than 0xFFFFFFFF in LONG array."); 1815 _TIFFfree(p); 1816 return(0); 1817 } 1818 *q= (uint32)(*ma); 1819 } 1820 1821 o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p); 1822 _TIFFfree(p); 1823 } 1824 else 1825 { 1826 uint16* p = _TIFFmalloc(count*sizeof(uint16)); 1827 uint16* q; 1828 uint64* ma; 1829 uint32 mb; 1830 1831 if (p==NULL) 1832 { 1833 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1834 return(0); 1835 } 1836 1837 for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++) 1838 { 1839 if (*ma>0xFFFF) 1840 { 1841 /* Should not happen normally given the check we did before */ 1842 TIFFErrorExt(tif->tif_clientdata,module, 1843 "Attempt to write value larger than 0xFFFF in SHORT array."); 1844 _TIFFfree(p); 1845 return(0); 1846 } 1847 *q= (uint16)(*ma); 1848 } 1849 1850 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,p); 1851 _TIFFfree(p); 1852 } 1853 1854 return(o); 1855 } 1856 1857 /************************************************************************/ 1858 /* TIFFWriteDirectoryTagIfdIfd8Array() */ 1859 /* */ 1860 /* Write either IFD8 or IFD array depending on file type. */ 1861 /************************************************************************/ 1862 1863 static int 1864 TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 1865 { 1866 static const char module[] = "TIFFWriteDirectoryTagIfdIfd8Array"; 1867 uint64* ma; 1868 uint32 mb; 1869 uint32* p; 1870 uint32* q; 1871 int o; 1872 1873 /* is this just a counting pass? */ 1874 if (dir==NULL) 1875 { 1876 (*ndir)++; 1877 return(1); 1878 } 1879 1880 /* We always write IFD8 for BigTIFF, no checking needed. */ 1881 if( tif->tif_flags&TIFF_BIGTIFF ) 1882 return TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir, 1883 tag,count,value); 1884 1885 /* 1886 ** For classic tiff we want to verify everything is in range for IFD 1887 ** and convert to long format. 1888 */ 1889 1890 p = _TIFFmalloc(count*sizeof(uint32)); 1891 if (p==NULL) 1892 { 1893 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1894 return(0); 1895 } 1896 1897 for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++) 1898 { 1899 if (*ma>0xFFFFFFFF) 1900 { 1901 TIFFErrorExt(tif->tif_clientdata,module, 1902 "Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file."); 1903 _TIFFfree(p); 1904 return(0); 1905 } 1906 *q= (uint32)(*ma); 1907 } 1908 1909 o=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,p); 1910 _TIFFfree(p); 1911 1912 return(o); 1913 } 1914 1915 #ifdef notdef 1916 static int 1917 TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 1918 { 1919 static const char module[] = "TIFFWriteDirectoryTagShortLongLong8Array"; 1920 uint64* ma; 1921 uint32 mb; 1922 uint8 n; 1923 int o; 1924 if (dir==NULL) 1925 { 1926 (*ndir)++; 1927 return(1); 1928 } 1929 n=0; 1930 for (ma=value, mb=0; mb<count; ma++, mb++) 1931 { 1932 if ((n==0)&&(*ma>0xFFFF)) 1933 n=1; 1934 if ((n==1)&&(*ma>0xFFFFFFFF)) 1935 { 1936 n=2; 1937 break; 1938 } 1939 } 1940 if (n==0) 1941 { 1942 uint16* p; 1943 uint16* q; 1944 p=_TIFFmalloc(count*sizeof(uint16)); 1945 if (p==NULL) 1946 { 1947 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1948 return(0); 1949 } 1950 for (ma=value, mb=0, q=p; mb<count; ma++, mb++, q++) 1951 *q=(uint16)(*ma); 1952 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,p); 1953 _TIFFfree(p); 1954 } 1955 else if (n==1) 1956 { 1957 uint32* p; 1958 uint32* q; 1959 p=_TIFFmalloc(count*sizeof(uint32)); 1960 if (p==NULL) 1961 { 1962 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1963 return(0); 1964 } 1965 for (ma=value, mb=0, q=p; mb<count; ma++, mb++, q++) 1966 *q=(uint32)(*ma); 1967 o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p); 1968 _TIFFfree(p); 1969 } 1970 else 1971 { 1972 assert(n==2); 1973 o=TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value); 1974 } 1975 return(o); 1976 } 1977 #endif 1978 static int 1979 TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir) 1980 { 1981 static const char module[] = "TIFFWriteDirectoryTagColormap"; 1982 uint32 m; 1983 uint16* n; 1984 int o; 1985 if (dir==NULL) 1986 { 1987 (*ndir)++; 1988 return(1); 1989 } 1990 m=(1<<tif->tif_dir.td_bitspersample); 1991 n=_TIFFmalloc(3*m*sizeof(uint16)); 1992 if (n==NULL) 1993 { 1994 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 1995 return(0); 1996 } 1997 _TIFFmemcpy(&n[0],tif->tif_dir.td_colormap[0],m*sizeof(uint16)); 1998 _TIFFmemcpy(&n[m],tif->tif_dir.td_colormap[1],m*sizeof(uint16)); 1999 _TIFFmemcpy(&n[2*m],tif->tif_dir.td_colormap[2],m*sizeof(uint16)); 2000 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_COLORMAP,3*m,n); 2001 _TIFFfree(n); 2002 return(o); 2003 } 2004 2005 static int 2006 TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir) 2007 { 2008 static const char module[] = "TIFFWriteDirectoryTagTransferfunction"; 2009 uint32 m; 2010 uint16 n; 2011 uint16* o; 2012 int p; 2013 if (dir==NULL) 2014 { 2015 (*ndir)++; 2016 return(1); 2017 } 2018 m=(1<<tif->tif_dir.td_bitspersample); 2019 n=tif->tif_dir.td_samplesperpixel-tif->tif_dir.td_extrasamples; 2020 /* 2021 * Check if the table can be written as a single column, 2022 * or if it must be written as 3 columns. Note that we 2023 * write a 3-column tag if there are 2 samples/pixel and 2024 * a single column of data won't suffice--hmm. 2025 */ 2026 if (n>3) 2027 n=3; 2028 if (n==3) 2029 { 2030 if (tif->tif_dir.td_transferfunction[2] == NULL || 2031 !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16))) 2032 n=2; 2033 } 2034 if (n==2) 2035 { 2036 if (tif->tif_dir.td_transferfunction[1] == NULL || 2037 !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16))) 2038 n=1; 2039 } 2040 if (n==0) 2041 n=1; 2042 o=_TIFFmalloc(n*m*sizeof(uint16)); 2043 if (o==NULL) 2044 { 2045 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 2046 return(0); 2047 } 2048 _TIFFmemcpy(&o[0],tif->tif_dir.td_transferfunction[0],m*sizeof(uint16)); 2049 if (n>1) 2050 _TIFFmemcpy(&o[m],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)); 2051 if (n>2) 2052 _TIFFmemcpy(&o[2*m],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)); 2053 p=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_TRANSFERFUNCTION,n*m,o); 2054 _TIFFfree(o); 2055 return(p); 2056 } 2057 2058 static int 2059 TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir) 2060 { 2061 static const char module[] = "TIFFWriteDirectoryTagSubifd"; 2062 uint64 m; 2063 int n; 2064 if (tif->tif_dir.td_nsubifd==0) 2065 return(1); 2066 if (dir==NULL) 2067 { 2068 (*ndir)++; 2069 return(1); 2070 } 2071 m=tif->tif_dataoff; 2072 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2073 { 2074 uint32* o; 2075 uint64* pa; 2076 uint32* pb; 2077 uint16 p; 2078 o=_TIFFmalloc(tif->tif_dir.td_nsubifd*sizeof(uint32)); 2079 if (o==NULL) 2080 { 2081 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 2082 return(0); 2083 } 2084 pa=tif->tif_dir.td_subifd; 2085 pb=o; 2086 for (p=0; p < tif->tif_dir.td_nsubifd; p++) 2087 { 2088 assert(pa != 0); 2089 2090 /* Could happen if an classicTIFF has a SubIFD of type LONG8 (which is illegal) */ 2091 if( *pa > 0xFFFFFFFFUL) 2092 { 2093 TIFFErrorExt(tif->tif_clientdata,module,"Illegal value for SubIFD tag"); 2094 _TIFFfree(o); 2095 return(0); 2096 } 2097 *pb++=(uint32)(*pa++); 2098 } 2099 n=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,o); 2100 _TIFFfree(o); 2101 } 2102 else 2103 n=TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,tif->tif_dir.td_subifd); 2104 if (!n) 2105 return(0); 2106 /* 2107 * Total hack: if this directory includes a SubIFD 2108 * tag then force the next <n> directories to be 2109 * written as ``sub directories'' of this one. This 2110 * is used to write things like thumbnails and 2111 * image masks that one wants to keep out of the 2112 * normal directory linkage access mechanism. 2113 */ 2114 tif->tif_flags|=TIFF_INSUBIFD; 2115 tif->tif_nsubifd=tif->tif_dir.td_nsubifd; 2116 if (tif->tif_dir.td_nsubifd==1) 2117 tif->tif_subifdoff=0; 2118 else 2119 tif->tif_subifdoff=m; 2120 return(1); 2121 } 2122 2123 static int 2124 TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value) 2125 { 2126 assert(sizeof(char)==1); 2127 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_ASCII,count,count,value)); 2128 } 2129 2130 static int 2131 TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) 2132 { 2133 assert(sizeof(uint8)==1); 2134 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_UNDEFINED,count,count,value)); 2135 } 2136 2137 #ifdef notdef 2138 static int 2139 TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value) 2140 { 2141 assert(sizeof(uint8)==1); 2142 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,1,1,&value)); 2143 } 2144 #endif 2145 2146 static int 2147 TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) 2148 { 2149 assert(sizeof(uint8)==1); 2150 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,count,count,value)); 2151 } 2152 2153 #ifdef notdef 2154 static int 2155 TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value) 2156 { 2157 assert(sizeof(int8)==1); 2158 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,1,1,&value)); 2159 } 2160 #endif 2161 2162 static int 2163 TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value) 2164 { 2165 assert(sizeof(int8)==1); 2166 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,count,count,value)); 2167 } 2168 2169 static int 2170 TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value) 2171 { 2172 uint16 m; 2173 assert(sizeof(uint16)==2); 2174 m=value; 2175 if (tif->tif_flags&TIFF_SWAB) 2176 TIFFSwabShort(&m); 2177 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,1,2,&m)); 2178 } 2179 2180 static int 2181 TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value) 2182 { 2183 assert(count<0x80000000); 2184 assert(sizeof(uint16)==2); 2185 if (tif->tif_flags&TIFF_SWAB) 2186 TIFFSwabArrayOfShort(value,count); 2187 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,count,count*2,value)); 2188 } 2189 2190 #ifdef notdef 2191 static int 2192 TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value) 2193 { 2194 int16 m; 2195 assert(sizeof(int16)==2); 2196 m=value; 2197 if (tif->tif_flags&TIFF_SWAB) 2198 TIFFSwabShort((uint16*)(&m)); 2199 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,1,2,&m)); 2200 } 2201 #endif 2202 2203 static int 2204 TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value) 2205 { 2206 assert(count<0x80000000); 2207 assert(sizeof(int16)==2); 2208 if (tif->tif_flags&TIFF_SWAB) 2209 TIFFSwabArrayOfShort((uint16*)value,count); 2210 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,count,count*2,value)); 2211 } 2212 2213 static int 2214 TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) 2215 { 2216 uint32 m; 2217 assert(sizeof(uint32)==4); 2218 m=value; 2219 if (tif->tif_flags&TIFF_SWAB) 2220 TIFFSwabLong(&m); 2221 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,1,4,&m)); 2222 } 2223 2224 static int 2225 TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) 2226 { 2227 assert(count<0x40000000); 2228 assert(sizeof(uint32)==4); 2229 if (tif->tif_flags&TIFF_SWAB) 2230 TIFFSwabArrayOfLong(value,count); 2231 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,count,count*4,value)); 2232 } 2233 2234 #ifdef notdef 2235 static int 2236 TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value) 2237 { 2238 int32 m; 2239 assert(sizeof(int32)==4); 2240 m=value; 2241 if (tif->tif_flags&TIFF_SWAB) 2242 TIFFSwabLong((uint32*)(&m)); 2243 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,1,4,&m)); 2244 } 2245 #endif 2246 2247 static int 2248 TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value) 2249 { 2250 assert(count<0x40000000); 2251 assert(sizeof(int32)==4); 2252 if (tif->tif_flags&TIFF_SWAB) 2253 TIFFSwabArrayOfLong((uint32*)value,count); 2254 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,count,count*4,value)); 2255 } 2256 2257 #ifdef notdef 2258 static int 2259 TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value) 2260 { 2261 uint64 m; 2262 assert(sizeof(uint64)==8); 2263 if( !(tif->tif_flags&TIFF_BIGTIFF) ) { 2264 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedLong8","LONG8 not allowed for ClassicTIFF"); 2265 return(0); 2266 } 2267 m=value; 2268 if (tif->tif_flags&TIFF_SWAB) 2269 TIFFSwabLong8(&m); 2270 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,1,8,&m)); 2271 } 2272 #endif 2273 2274 static int 2275 TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 2276 { 2277 assert(count<0x20000000); 2278 assert(sizeof(uint64)==8); 2279 if( !(tif->tif_flags&TIFF_BIGTIFF) ) { 2280 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedLong8Array","LONG8 not allowed for ClassicTIFF"); 2281 return(0); 2282 } 2283 if (tif->tif_flags&TIFF_SWAB) 2284 TIFFSwabArrayOfLong8(value,count); 2285 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,count,count*8,value)); 2286 } 2287 2288 #ifdef notdef 2289 static int 2290 TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value) 2291 { 2292 int64 m; 2293 assert(sizeof(int64)==8); 2294 if( !(tif->tif_flags&TIFF_BIGTIFF) ) { 2295 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedSlong8","SLONG8 not allowed for ClassicTIFF"); 2296 return(0); 2297 } 2298 m=value; 2299 if (tif->tif_flags&TIFF_SWAB) 2300 TIFFSwabLong8((uint64*)(&m)); 2301 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,1,8,&m)); 2302 } 2303 #endif 2304 2305 static int 2306 TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value) 2307 { 2308 assert(count<0x20000000); 2309 assert(sizeof(int64)==8); 2310 if( !(tif->tif_flags&TIFF_BIGTIFF) ) { 2311 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedSlong8Array","SLONG8 not allowed for ClassicTIFF"); 2312 return(0); 2313 } 2314 if (tif->tif_flags&TIFF_SWAB) 2315 TIFFSwabArrayOfLong8((uint64*)value,count); 2316 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,count,count*8,value)); 2317 } 2318 2319 static int 2320 TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) 2321 { 2322 static const char module[] = "TIFFWriteDirectoryTagCheckedRational"; 2323 uint32 m[2]; 2324 assert(sizeof(uint32)==4); 2325 if( value < 0 ) 2326 { 2327 TIFFErrorExt(tif->tif_clientdata,module,"Negative value is illegal"); 2328 return 0; 2329 } 2330 else if( value != value ) 2331 { 2332 TIFFErrorExt(tif->tif_clientdata,module,"Not-a-number value is illegal"); 2333 return 0; 2334 } 2335 else if (value==0.0) 2336 { 2337 m[0]=0; 2338 m[1]=1; 2339 } 2340 else if (value <= 0xFFFFFFFFU && value==(double)(uint32)value) 2341 { 2342 m[0]=(uint32)value; 2343 m[1]=1; 2344 } 2345 else if (value<1.0) 2346 { 2347 m[0]=(uint32)(value*0xFFFFFFFF); 2348 m[1]=0xFFFFFFFF; 2349 } 2350 else 2351 { 2352 m[0]=0xFFFFFFFF; 2353 m[1]=(uint32)(0xFFFFFFFF/value); 2354 } 2355 if (tif->tif_flags&TIFF_SWAB) 2356 { 2357 TIFFSwabLong(&m[0]); 2358 TIFFSwabLong(&m[1]); 2359 } 2360 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,1,8,&m[0])); 2361 } 2362 2363 static int 2364 TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) 2365 { 2366 static const char module[] = "TIFFWriteDirectoryTagCheckedRationalArray"; 2367 uint32* m; 2368 float* na; 2369 uint32* nb; 2370 uint32 nc; 2371 int o; 2372 assert(sizeof(uint32)==4); 2373 m=_TIFFmalloc(count*2*sizeof(uint32)); 2374 if (m==NULL) 2375 { 2376 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 2377 return(0); 2378 } 2379 for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++) 2380 { 2381 if (*na<=0.0 || *na != *na) 2382 { 2383 nb[0]=0; 2384 nb[1]=1; 2385 } 2386 else if (*na >= 0 && *na <= (float)0xFFFFFFFFU && 2387 *na==(float)(uint32)(*na)) 2388 { 2389 nb[0]=(uint32)(*na); 2390 nb[1]=1; 2391 } 2392 else if (*na<1.0) 2393 { 2394 nb[0]=(uint32)((double)(*na)*0xFFFFFFFF); 2395 nb[1]=0xFFFFFFFF; 2396 } 2397 else 2398 { 2399 nb[0]=0xFFFFFFFF; 2400 nb[1]=(uint32)((double)0xFFFFFFFF/(*na)); 2401 } 2402 } 2403 if (tif->tif_flags&TIFF_SWAB) 2404 TIFFSwabArrayOfLong(m,count*2); 2405 o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,count,count*8,&m[0]); 2406 _TIFFfree(m); 2407 return(o); 2408 } 2409 2410 static int 2411 TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) 2412 { 2413 static const char module[] = "TIFFWriteDirectoryTagCheckedSrationalArray"; 2414 int32* m; 2415 float* na; 2416 int32* nb; 2417 uint32 nc; 2418 int o; 2419 assert(sizeof(int32)==4); 2420 m=_TIFFmalloc(count*2*sizeof(int32)); 2421 if (m==NULL) 2422 { 2423 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); 2424 return(0); 2425 } 2426 for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++) 2427 { 2428 if (*na<0.0) 2429 { 2430 if (*na==(int32)(*na)) 2431 { 2432 nb[0]=(int32)(*na); 2433 nb[1]=1; 2434 } 2435 else if (*na>-1.0) 2436 { 2437 nb[0]=-(int32)((double)(-*na)*0x7FFFFFFF); 2438 nb[1]=0x7FFFFFFF; 2439 } 2440 else 2441 { 2442 nb[0]=-0x7FFFFFFF; 2443 nb[1]=(int32)((double)0x7FFFFFFF/(-*na)); 2444 } 2445 } 2446 else 2447 { 2448 if (*na==(int32)(*na)) 2449 { 2450 nb[0]=(int32)(*na); 2451 nb[1]=1; 2452 } 2453 else if (*na<1.0) 2454 { 2455 nb[0]=(int32)((double)(*na)*0x7FFFFFFF); 2456 nb[1]=0x7FFFFFFF; 2457 } 2458 else 2459 { 2460 nb[0]=0x7FFFFFFF; 2461 nb[1]=(int32)((double)0x7FFFFFFF/(*na)); 2462 } 2463 } 2464 } 2465 if (tif->tif_flags&TIFF_SWAB) 2466 TIFFSwabArrayOfLong((uint32*)m,count*2); 2467 o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SRATIONAL,count,count*8,&m[0]); 2468 _TIFFfree(m); 2469 return(o); 2470 } 2471 2472 #ifdef notdef 2473 static int 2474 TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value) 2475 { 2476 float m; 2477 assert(sizeof(float)==4); 2478 m=value; 2479 TIFFCvtNativeToIEEEFloat(tif,1,&m); 2480 if (tif->tif_flags&TIFF_SWAB) 2481 TIFFSwabFloat(&m); 2482 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,1,4,&m)); 2483 } 2484 #endif 2485 2486 static int 2487 TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) 2488 { 2489 assert(count<0x40000000); 2490 assert(sizeof(float)==4); 2491 TIFFCvtNativeToIEEEFloat(tif,count,&value); 2492 if (tif->tif_flags&TIFF_SWAB) 2493 TIFFSwabArrayOfFloat(value,count); 2494 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,count,count*4,value)); 2495 } 2496 2497 #ifdef notdef 2498 static int 2499 TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) 2500 { 2501 double m; 2502 assert(sizeof(double)==8); 2503 m=value; 2504 TIFFCvtNativeToIEEEDouble(tif,1,&m); 2505 if (tif->tif_flags&TIFF_SWAB) 2506 TIFFSwabDouble(&m); 2507 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,1,8,&m)); 2508 } 2509 #endif 2510 2511 static int 2512 TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value) 2513 { 2514 assert(count<0x20000000); 2515 assert(sizeof(double)==8); 2516 TIFFCvtNativeToIEEEDouble(tif,count,&value); 2517 if (tif->tif_flags&TIFF_SWAB) 2518 TIFFSwabArrayOfDouble(value,count); 2519 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,count,count*8,value)); 2520 } 2521 2522 static int 2523 TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) 2524 { 2525 assert(count<0x40000000); 2526 assert(sizeof(uint32)==4); 2527 if (tif->tif_flags&TIFF_SWAB) 2528 TIFFSwabArrayOfLong(value,count); 2529 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD,count,count*4,value)); 2530 } 2531 2532 static int 2533 TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) 2534 { 2535 assert(count<0x20000000); 2536 assert(sizeof(uint64)==8); 2537 assert(tif->tif_flags&TIFF_BIGTIFF); 2538 if (tif->tif_flags&TIFF_SWAB) 2539 TIFFSwabArrayOfLong8(value,count); 2540 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD8,count,count*8,value)); 2541 } 2542 2543 static int 2544 TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data) 2545 { 2546 static const char module[] = "TIFFWriteDirectoryTagData"; 2547 uint32 m; 2548 m=0; 2549 while (m<(*ndir)) 2550 { 2551 assert(dir[m].tdir_tag!=tag); 2552 if (dir[m].tdir_tag>tag) 2553 break; 2554 m++; 2555 } 2556 if (m<(*ndir)) 2557 { 2558 uint32 n; 2559 for (n=*ndir; n>m; n--) 2560 dir[n]=dir[n-1]; 2561 } 2562 dir[m].tdir_tag=tag; 2563 dir[m].tdir_type=datatype; 2564 dir[m].tdir_count=count; 2565 dir[m].tdir_offset.toff_long8 = 0; 2566 if (datalength<=((tif->tif_flags&TIFF_BIGTIFF)?0x8U:0x4U)) 2567 { 2568 if( data && datalength ) 2569 { 2570 _TIFFmemcpy(&dir[m].tdir_offset,data,datalength); 2571 } 2572 } 2573 else 2574 { 2575 uint64 na,nb; 2576 na=tif->tif_dataoff; 2577 nb=na+datalength; 2578 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2579 nb=(uint32)nb; 2580 if ((nb<na)||(nb<datalength)) 2581 { 2582 TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded"); 2583 return(0); 2584 } 2585 if (!SeekOK(tif,na)) 2586 { 2587 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data"); 2588 return(0); 2589 } 2590 assert(datalength<0x80000000UL); 2591 if (!WriteOK(tif,data,(tmsize_t)datalength)) 2592 { 2593 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data"); 2594 return(0); 2595 } 2596 tif->tif_dataoff=nb; 2597 if (tif->tif_dataoff&1) 2598 tif->tif_dataoff++; 2599 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2600 { 2601 uint32 o; 2602 o=(uint32)na; 2603 if (tif->tif_flags&TIFF_SWAB) 2604 TIFFSwabLong(&o); 2605 _TIFFmemcpy(&dir[m].tdir_offset,&o,4); 2606 } 2607 else 2608 { 2609 dir[m].tdir_offset.toff_long8 = na; 2610 if (tif->tif_flags&TIFF_SWAB) 2611 TIFFSwabLong8(&dir[m].tdir_offset.toff_long8); 2612 } 2613 } 2614 (*ndir)++; 2615 return(1); 2616 } 2617 2618 /* 2619 * Link the current directory into the directory chain for the file. 2620 */ 2621 static int 2622 TIFFLinkDirectory(TIFF* tif) 2623 { 2624 static const char module[] = "TIFFLinkDirectory"; 2625 2626 tif->tif_diroff = (TIFFSeekFile(tif,0,SEEK_END)+1) & (~((toff_t)1)); 2627 2628 /* 2629 * Handle SubIFDs 2630 */ 2631 if (tif->tif_flags & TIFF_INSUBIFD) 2632 { 2633 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2634 { 2635 uint32 m; 2636 m = (uint32)tif->tif_diroff; 2637 if (tif->tif_flags & TIFF_SWAB) 2638 TIFFSwabLong(&m); 2639 (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET); 2640 if (!WriteOK(tif, &m, 4)) { 2641 TIFFErrorExt(tif->tif_clientdata, module, 2642 "Error writing SubIFD directory link"); 2643 return (0); 2644 } 2645 /* 2646 * Advance to the next SubIFD or, if this is 2647 * the last one configured, revert back to the 2648 * normal directory linkage. 2649 */ 2650 if (--tif->tif_nsubifd) 2651 tif->tif_subifdoff += 4; 2652 else 2653 tif->tif_flags &= ~TIFF_INSUBIFD; 2654 return (1); 2655 } 2656 else 2657 { 2658 uint64 m; 2659 m = tif->tif_diroff; 2660 if (tif->tif_flags & TIFF_SWAB) 2661 TIFFSwabLong8(&m); 2662 (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET); 2663 if (!WriteOK(tif, &m, 8)) { 2664 TIFFErrorExt(tif->tif_clientdata, module, 2665 "Error writing SubIFD directory link"); 2666 return (0); 2667 } 2668 /* 2669 * Advance to the next SubIFD or, if this is 2670 * the last one configured, revert back to the 2671 * normal directory linkage. 2672 */ 2673 if (--tif->tif_nsubifd) 2674 tif->tif_subifdoff += 8; 2675 else 2676 tif->tif_flags &= ~TIFF_INSUBIFD; 2677 return (1); 2678 } 2679 } 2680 2681 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2682 { 2683 uint32 m; 2684 uint32 nextdir; 2685 m = (uint32)(tif->tif_diroff); 2686 if (tif->tif_flags & TIFF_SWAB) 2687 TIFFSwabLong(&m); 2688 if (tif->tif_header.classic.tiff_diroff == 0) { 2689 /* 2690 * First directory, overwrite offset in header. 2691 */ 2692 tif->tif_header.classic.tiff_diroff = (uint32) tif->tif_diroff; 2693 (void) TIFFSeekFile(tif,4, SEEK_SET); 2694 if (!WriteOK(tif, &m, 4)) { 2695 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, 2696 "Error writing TIFF header"); 2697 return (0); 2698 } 2699 return (1); 2700 } 2701 /* 2702 * Not the first directory, search to the last and append. 2703 */ 2704 nextdir = tif->tif_header.classic.tiff_diroff; 2705 while(1) { 2706 uint16 dircount; 2707 uint32 nextnextdir; 2708 2709 if (!SeekOK(tif, nextdir) || 2710 !ReadOK(tif, &dircount, 2)) { 2711 TIFFErrorExt(tif->tif_clientdata, module, 2712 "Error fetching directory count"); 2713 return (0); 2714 } 2715 if (tif->tif_flags & TIFF_SWAB) 2716 TIFFSwabShort(&dircount); 2717 (void) TIFFSeekFile(tif, 2718 nextdir+2+dircount*12, SEEK_SET); 2719 if (!ReadOK(tif, &nextnextdir, 4)) { 2720 TIFFErrorExt(tif->tif_clientdata, module, 2721 "Error fetching directory link"); 2722 return (0); 2723 } 2724 if (tif->tif_flags & TIFF_SWAB) 2725 TIFFSwabLong(&nextnextdir); 2726 if (nextnextdir==0) 2727 { 2728 (void) TIFFSeekFile(tif, 2729 nextdir+2+dircount*12, SEEK_SET); 2730 if (!WriteOK(tif, &m, 4)) { 2731 TIFFErrorExt(tif->tif_clientdata, module, 2732 "Error writing directory link"); 2733 return (0); 2734 } 2735 break; 2736 } 2737 nextdir=nextnextdir; 2738 } 2739 } 2740 else 2741 { 2742 uint64 m; 2743 uint64 nextdir; 2744 m = tif->tif_diroff; 2745 if (tif->tif_flags & TIFF_SWAB) 2746 TIFFSwabLong8(&m); 2747 if (tif->tif_header.big.tiff_diroff == 0) { 2748 /* 2749 * First directory, overwrite offset in header. 2750 */ 2751 tif->tif_header.big.tiff_diroff = tif->tif_diroff; 2752 (void) TIFFSeekFile(tif,8, SEEK_SET); 2753 if (!WriteOK(tif, &m, 8)) { 2754 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, 2755 "Error writing TIFF header"); 2756 return (0); 2757 } 2758 return (1); 2759 } 2760 /* 2761 * Not the first directory, search to the last and append. 2762 */ 2763 nextdir = tif->tif_header.big.tiff_diroff; 2764 while(1) { 2765 uint64 dircount64; 2766 uint16 dircount; 2767 uint64 nextnextdir; 2768 2769 if (!SeekOK(tif, nextdir) || 2770 !ReadOK(tif, &dircount64, 8)) { 2771 TIFFErrorExt(tif->tif_clientdata, module, 2772 "Error fetching directory count"); 2773 return (0); 2774 } 2775 if (tif->tif_flags & TIFF_SWAB) 2776 TIFFSwabLong8(&dircount64); 2777 if (dircount64>0xFFFF) 2778 { 2779 TIFFErrorExt(tif->tif_clientdata, module, 2780 "Sanity check on tag count failed, likely corrupt TIFF"); 2781 return (0); 2782 } 2783 dircount=(uint16)dircount64; 2784 (void) TIFFSeekFile(tif, 2785 nextdir+8+dircount*20, SEEK_SET); 2786 if (!ReadOK(tif, &nextnextdir, 8)) { 2787 TIFFErrorExt(tif->tif_clientdata, module, 2788 "Error fetching directory link"); 2789 return (0); 2790 } 2791 if (tif->tif_flags & TIFF_SWAB) 2792 TIFFSwabLong8(&nextnextdir); 2793 if (nextnextdir==0) 2794 { 2795 (void) TIFFSeekFile(tif, 2796 nextdir+8+dircount*20, SEEK_SET); 2797 if (!WriteOK(tif, &m, 8)) { 2798 TIFFErrorExt(tif->tif_clientdata, module, 2799 "Error writing directory link"); 2800 return (0); 2801 } 2802 break; 2803 } 2804 nextdir=nextnextdir; 2805 } 2806 } 2807 return (1); 2808 } 2809 2810 /************************************************************************/ 2811 /* TIFFRewriteField() */ 2812 /* */ 2813 /* Rewrite a field in the directory on disk without regard to */ 2814 /* updating the TIFF directory structure in memory. Currently */ 2815 /* only supported for field that already exist in the on-disk */ 2816 /* directory. Mainly used for updating stripoffset / */ 2817 /* stripbytecount values after the directory is already on */ 2818 /* disk. */ 2819 /* */ 2820 /* Returns zero on failure, and one on success. */ 2821 /************************************************************************/ 2822 2823 int 2824 _TIFFRewriteField(TIFF* tif, uint16 tag, TIFFDataType in_datatype, 2825 tmsize_t count, void* data) 2826 { 2827 static const char module[] = "TIFFResetField"; 2828 /* const TIFFField* fip = NULL; */ 2829 uint16 dircount; 2830 tmsize_t dirsize; 2831 uint8 direntry_raw[20]; 2832 uint16 entry_tag = 0; 2833 uint16 entry_type = 0; 2834 uint64 entry_count = 0; 2835 uint64 entry_offset = 0; 2836 int value_in_entry = 0; 2837 uint64 read_offset; 2838 uint8 *buf_to_write = NULL; 2839 TIFFDataType datatype; 2840 2841 /* -------------------------------------------------------------------- */ 2842 /* Find field definition. */ 2843 /* -------------------------------------------------------------------- */ 2844 /*fip =*/ TIFFFindField(tif, tag, TIFF_ANY); 2845 2846 /* -------------------------------------------------------------------- */ 2847 /* Do some checking this is a straight forward case. */ 2848 /* -------------------------------------------------------------------- */ 2849 if( isMapped(tif) ) 2850 { 2851 TIFFErrorExt( tif->tif_clientdata, module, 2852 "Memory mapped files not currently supported for this operation." ); 2853 return 0; 2854 } 2855 2856 if( tif->tif_diroff == 0 ) 2857 { 2858 TIFFErrorExt( tif->tif_clientdata, module, 2859 "Attempt to reset field on directory not already on disk." ); 2860 return 0; 2861 } 2862 2863 /* -------------------------------------------------------------------- */ 2864 /* Read the directory entry count. */ 2865 /* -------------------------------------------------------------------- */ 2866 if (!SeekOK(tif, tif->tif_diroff)) { 2867 TIFFErrorExt(tif->tif_clientdata, module, 2868 "%s: Seek error accessing TIFF directory", 2869 tif->tif_name); 2870 return 0; 2871 } 2872 2873 read_offset = tif->tif_diroff; 2874 2875 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2876 { 2877 if (!ReadOK(tif, &dircount, sizeof (uint16))) { 2878 TIFFErrorExt(tif->tif_clientdata, module, 2879 "%s: Can not read TIFF directory count", 2880 tif->tif_name); 2881 return 0; 2882 } 2883 if (tif->tif_flags & TIFF_SWAB) 2884 TIFFSwabShort(&dircount); 2885 dirsize = 12; 2886 read_offset += 2; 2887 } else { 2888 uint64 dircount64; 2889 if (!ReadOK(tif, &dircount64, sizeof (uint64))) { 2890 TIFFErrorExt(tif->tif_clientdata, module, 2891 "%s: Can not read TIFF directory count", 2892 tif->tif_name); 2893 return 0; 2894 } 2895 if (tif->tif_flags & TIFF_SWAB) 2896 TIFFSwabLong8(&dircount64); 2897 dircount = (uint16)dircount64; 2898 dirsize = 20; 2899 read_offset += 8; 2900 } 2901 2902 /* -------------------------------------------------------------------- */ 2903 /* Read through directory to find target tag. */ 2904 /* -------------------------------------------------------------------- */ 2905 while( dircount > 0 ) 2906 { 2907 if (!ReadOK(tif, direntry_raw, dirsize)) { 2908 TIFFErrorExt(tif->tif_clientdata, module, 2909 "%s: Can not read TIFF directory entry.", 2910 tif->tif_name); 2911 return 0; 2912 } 2913 2914 memcpy( &entry_tag, direntry_raw + 0, sizeof(uint16) ); 2915 if (tif->tif_flags&TIFF_SWAB) 2916 TIFFSwabShort( &entry_tag ); 2917 2918 if( entry_tag == tag ) 2919 break; 2920 2921 read_offset += dirsize; 2922 } 2923 2924 if( entry_tag != tag ) 2925 { 2926 TIFFErrorExt(tif->tif_clientdata, module, 2927 "%s: Could not find tag %d.", 2928 tif->tif_name, tag ); 2929 return 0; 2930 } 2931 2932 /* -------------------------------------------------------------------- */ 2933 /* Extract the type, count and offset for this entry. */ 2934 /* -------------------------------------------------------------------- */ 2935 memcpy( &entry_type, direntry_raw + 2, sizeof(uint16) ); 2936 if (tif->tif_flags&TIFF_SWAB) 2937 TIFFSwabShort( &entry_type ); 2938 2939 if (!(tif->tif_flags&TIFF_BIGTIFF)) 2940 { 2941 uint32 value; 2942 2943 memcpy( &value, direntry_raw + 4, sizeof(uint32) ); 2944 if (tif->tif_flags&TIFF_SWAB) 2945 TIFFSwabLong( &value ); 2946 entry_count = value; 2947 2948 memcpy( &value, direntry_raw + 8, sizeof(uint32) ); 2949 if (tif->tif_flags&TIFF_SWAB) 2950 TIFFSwabLong( &value ); 2951 entry_offset = value; 2952 } 2953 else 2954 { 2955 memcpy( &entry_count, direntry_raw + 4, sizeof(uint64) ); 2956 if (tif->tif_flags&TIFF_SWAB) 2957 TIFFSwabLong8( &entry_count ); 2958 2959 memcpy( &entry_offset, direntry_raw + 12, sizeof(uint64) ); 2960 if (tif->tif_flags&TIFF_SWAB) 2961 TIFFSwabLong8( &entry_offset ); 2962 } 2963 2964 /* -------------------------------------------------------------------- */ 2965 /* When a dummy tag was written due to TIFFDeferStrileArrayWriting() */ 2966 /* -------------------------------------------------------------------- */ 2967 if( entry_offset == 0 && entry_count == 0 && entry_type == 0 ) 2968 { 2969 if( tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS ) 2970 { 2971 entry_type = (tif->tif_flags&TIFF_BIGTIFF) ? TIFF_LONG8 : TIFF_LONG; 2972 } 2973 else 2974 { 2975 int write_aslong8 = 1; 2976 if( count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS ) 2977 { 2978 write_aslong8 = WriteAsLong8(tif, TIFFStripSize64(tif)); 2979 } 2980 else if( count > 1 && tag == TIFFTAG_TILEBYTECOUNTS ) 2981 { 2982 write_aslong8 = WriteAsLong8(tif, TIFFTileSize64(tif)); 2983 } 2984 if( write_aslong8 ) 2985 { 2986 entry_type = TIFF_LONG8; 2987 } 2988 else 2989 { 2990 int write_aslong4 = 1; 2991 if( count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS ) 2992 { 2993 write_aslong4 = WriteAsLong4(tif, TIFFStripSize64(tif)); 2994 } 2995 else if( count > 1 && tag == TIFFTAG_TILEBYTECOUNTS ) 2996 { 2997 write_aslong4 = WriteAsLong4(tif, TIFFTileSize64(tif)); 2998 } 2999 if( write_aslong4 ) 3000 { 3001 entry_type = TIFF_LONG; 3002 } 3003 else 3004 { 3005 entry_type = TIFF_SHORT; 3006 } 3007 } 3008 } 3009 } 3010 3011 /* -------------------------------------------------------------------- */ 3012 /* What data type do we want to write this as? */ 3013 /* -------------------------------------------------------------------- */ 3014 if( TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags&TIFF_BIGTIFF) ) 3015 { 3016 if( in_datatype == TIFF_LONG8 ) 3017 datatype = entry_type == TIFF_SHORT ? TIFF_SHORT : TIFF_LONG; 3018 else if( in_datatype == TIFF_SLONG8 ) 3019 datatype = TIFF_SLONG; 3020 else if( in_datatype == TIFF_IFD8 ) 3021 datatype = TIFF_IFD; 3022 else 3023 datatype = in_datatype; 3024 } 3025 else 3026 { 3027 if( in_datatype == TIFF_LONG8 && 3028 (entry_type == TIFF_SHORT || entry_type == TIFF_LONG || 3029 entry_type == TIFF_LONG8 ) ) 3030 datatype = entry_type; 3031 else if( in_datatype == TIFF_SLONG8 && 3032 (entry_type == TIFF_SLONG || entry_type == TIFF_SLONG8 ) ) 3033 datatype = entry_type; 3034 else if( in_datatype == TIFF_IFD8 && 3035 (entry_type == TIFF_IFD || entry_type == TIFF_IFD8 ) ) 3036 datatype = entry_type; 3037 else 3038 datatype = in_datatype; 3039 } 3040 3041 /* -------------------------------------------------------------------- */ 3042 /* Prepare buffer of actual data to write. This includes */ 3043 /* swabbing as needed. */ 3044 /* -------------------------------------------------------------------- */ 3045 buf_to_write = 3046 (uint8 *)_TIFFCheckMalloc(tif, count, TIFFDataWidth(datatype), 3047 "for field buffer."); 3048 if (!buf_to_write) 3049 return 0; 3050 3051 if( datatype == in_datatype ) 3052 memcpy( buf_to_write, data, count * TIFFDataWidth(datatype) ); 3053 else if( datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8 ) 3054 { 3055 tmsize_t i; 3056 3057 for( i = 0; i < count; i++ ) 3058 { 3059 ((int32 *) buf_to_write)[i] = 3060 (int32) ((int64 *) data)[i]; 3061 if( (int64) ((int32 *) buf_to_write)[i] != ((int64 *) data)[i] ) 3062 { 3063 _TIFFfree( buf_to_write ); 3064 TIFFErrorExt( tif->tif_clientdata, module, 3065 "Value exceeds 32bit range of output type." ); 3066 return 0; 3067 } 3068 } 3069 } 3070 else if( (datatype == TIFF_LONG && in_datatype == TIFF_LONG8) 3071 || (datatype == TIFF_IFD && in_datatype == TIFF_IFD8) ) 3072 { 3073 tmsize_t i; 3074 3075 for( i = 0; i < count; i++ ) 3076 { 3077 ((uint32 *) buf_to_write)[i] = 3078 (uint32) ((uint64 *) data)[i]; 3079 if( (uint64) ((uint32 *) buf_to_write)[i] != ((uint64 *) data)[i] ) 3080 { 3081 _TIFFfree( buf_to_write ); 3082 TIFFErrorExt( tif->tif_clientdata, module, 3083 "Value exceeds 32bit range of output type." ); 3084 return 0; 3085 } 3086 } 3087 } 3088 else if( datatype == TIFF_SHORT && in_datatype == TIFF_LONG8 ) 3089 { 3090 tmsize_t i; 3091 3092 for( i = 0; i < count; i++ ) 3093 { 3094 ((uint16 *) buf_to_write)[i] = 3095 (uint16) ((uint64 *) data)[i]; 3096 if( (uint64) ((uint16 *) buf_to_write)[i] != ((uint64 *) data)[i] ) 3097 { 3098 _TIFFfree( buf_to_write ); 3099 TIFFErrorExt( tif->tif_clientdata, module, 3100 "Value exceeds 16bit range of output type." ); 3101 return 0; 3102 } 3103 } 3104 } 3105 else 3106 { 3107 TIFFErrorExt( tif->tif_clientdata, module, 3108 "Unhandled type conversion." ); 3109 return 0; 3110 } 3111 3112 if( TIFFDataWidth(datatype) > 1 && (tif->tif_flags&TIFF_SWAB) ) 3113 { 3114 if( TIFFDataWidth(datatype) == 2 ) 3115 TIFFSwabArrayOfShort( (uint16 *) buf_to_write, count ); 3116 else if( TIFFDataWidth(datatype) == 4 ) 3117 TIFFSwabArrayOfLong( (uint32 *) buf_to_write, count ); 3118 else if( TIFFDataWidth(datatype) == 8 ) 3119 TIFFSwabArrayOfLong8( (uint64 *) buf_to_write, count ); 3120 } 3121 3122 /* -------------------------------------------------------------------- */ 3123 /* Is this a value that fits into the directory entry? */ 3124 /* -------------------------------------------------------------------- */ 3125 if (!(tif->tif_flags&TIFF_BIGTIFF)) 3126 { 3127 if( TIFFDataWidth(datatype) * count <= 4 ) 3128 { 3129 entry_offset = read_offset + 8; 3130 value_in_entry = 1; 3131 } 3132 } 3133 else 3134 { 3135 if( TIFFDataWidth(datatype) * count <= 8 ) 3136 { 3137 entry_offset = read_offset + 12; 3138 value_in_entry = 1; 3139 } 3140 } 3141 3142 if( (tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS) && 3143 tif->tif_dir.td_stripoffset_entry.tdir_count == 0 && 3144 tif->tif_dir.td_stripoffset_entry.tdir_type == 0 && 3145 tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 ) 3146 { 3147 tif->tif_dir.td_stripoffset_entry.tdir_type = datatype; 3148 tif->tif_dir.td_stripoffset_entry.tdir_count = count; 3149 } 3150 else if( (tag == TIFFTAG_TILEBYTECOUNTS || tag == TIFFTAG_STRIPBYTECOUNTS) && 3151 tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 && 3152 tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 && 3153 tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0 ) 3154 { 3155 tif->tif_dir.td_stripbytecount_entry.tdir_type = datatype; 3156 tif->tif_dir.td_stripbytecount_entry.tdir_count = count; 3157 } 3158 3159 /* -------------------------------------------------------------------- */ 3160 /* If the tag type, and count match, then we just write it out */ 3161 /* over the old values without altering the directory entry at */ 3162 /* all. */ 3163 /* -------------------------------------------------------------------- */ 3164 if( entry_count == (uint64)count && entry_type == (uint16) datatype ) 3165 { 3166 if (!SeekOK(tif, entry_offset)) { 3167 _TIFFfree( buf_to_write ); 3168 TIFFErrorExt(tif->tif_clientdata, module, 3169 "%s: Seek error accessing TIFF directory", 3170 tif->tif_name); 3171 return 0; 3172 } 3173 if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) { 3174 _TIFFfree( buf_to_write ); 3175 TIFFErrorExt(tif->tif_clientdata, module, 3176 "Error writing directory link"); 3177 return (0); 3178 } 3179 3180 _TIFFfree( buf_to_write ); 3181 return 1; 3182 } 3183 3184 /* -------------------------------------------------------------------- */ 3185 /* Otherwise, we write the new tag data at the end of the file. */ 3186 /* -------------------------------------------------------------------- */ 3187 if( !value_in_entry ) 3188 { 3189 entry_offset = TIFFSeekFile(tif,0,SEEK_END); 3190 3191 if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) { 3192 _TIFFfree( buf_to_write ); 3193 TIFFErrorExt(tif->tif_clientdata, module, 3194 "Error writing directory link"); 3195 return (0); 3196 } 3197 } 3198 else 3199 { 3200 memcpy( &entry_offset, buf_to_write, count*TIFFDataWidth(datatype)); 3201 } 3202 3203 _TIFFfree( buf_to_write ); 3204 buf_to_write = 0; 3205 3206 /* -------------------------------------------------------------------- */ 3207 /* Adjust the directory entry. */ 3208 /* -------------------------------------------------------------------- */ 3209 entry_type = datatype; 3210 entry_count = (uint64)count; 3211 memcpy( direntry_raw + 2, &entry_type, sizeof(uint16) ); 3212 if (tif->tif_flags&TIFF_SWAB) 3213 TIFFSwabShort( (uint16 *) (direntry_raw + 2) ); 3214 3215 if (!(tif->tif_flags&TIFF_BIGTIFF)) 3216 { 3217 uint32 value; 3218 3219 value = (uint32) entry_count; 3220 memcpy( direntry_raw + 4, &value, sizeof(uint32) ); 3221 if (tif->tif_flags&TIFF_SWAB) 3222 TIFFSwabLong( (uint32 *) (direntry_raw + 4) ); 3223 3224 value = (uint32) entry_offset; 3225 memcpy( direntry_raw + 8, &value, sizeof(uint32) ); 3226 if (tif->tif_flags&TIFF_SWAB) 3227 TIFFSwabLong( (uint32 *) (direntry_raw + 8) ); 3228 } 3229 else 3230 { 3231 memcpy( direntry_raw + 4, &entry_count, sizeof(uint64) ); 3232 if (tif->tif_flags&TIFF_SWAB) 3233 TIFFSwabLong8( (uint64 *) (direntry_raw + 4) ); 3234 3235 memcpy( direntry_raw + 12, &entry_offset, sizeof(uint64) ); 3236 if (tif->tif_flags&TIFF_SWAB) 3237 TIFFSwabLong8( (uint64 *) (direntry_raw + 12) ); 3238 } 3239 3240 /* -------------------------------------------------------------------- */ 3241 /* Write the directory entry out to disk. */ 3242 /* -------------------------------------------------------------------- */ 3243 if (!SeekOK(tif, read_offset )) { 3244 TIFFErrorExt(tif->tif_clientdata, module, 3245 "%s: Seek error accessing TIFF directory", 3246 tif->tif_name); 3247 return 0; 3248 } 3249 3250 if (!WriteOK(tif, direntry_raw,dirsize)) 3251 { 3252 TIFFErrorExt(tif->tif_clientdata, module, 3253 "%s: Can not write TIFF directory entry.", 3254 tif->tif_name); 3255 return 0; 3256 } 3257 3258 return 1; 3259 } 3260 /* vim: set ts=8 sts=8 sw=8 noet: */ 3261 /* 3262 * Local Variables: 3263 * mode: c 3264 * c-basic-offset: 8 3265 * fill-column: 78 3266 * End: 3267 */ 3268