ReactOS 0.4.16-dev-2613-g9533ad7
tif_dirwrite.c
Go to the documentation of this file.
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 "tiffiop.h"
31#include <float.h> /*--: for Rational2Double */
32#include <math.h> /*--: for Rational2Double */
33
34#ifdef HAVE_IEEEFP
35#define TIFFCvtNativeToIEEEFloat(tif, n, fp)
36#define TIFFCvtNativeToIEEEDouble(tif, n, dp)
37#else
38/* If your machine does not support IEEE floating point then you will need to
39 * add support to tif_machdep.c to convert between the native format and
40 * IEEE format. */
41extern void TIFFCvtNativeToIEEEFloat(TIFF *tif, uint32_t n, float *fp);
42extern void TIFFCvtNativeToIEEEDouble(TIFF *tif, uint32_t n, double *dp);
43#endif
44
45static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
46 uint64_t *pdiroff);
47
48static int TIFFWriteDirectoryTagSampleformatArray(TIFF *tif, uint32_t *ndir,
49 TIFFDirEntry *dir,
50 uint16_t tag, uint32_t count,
51 double *value);
52
53static int TIFFWriteDirectoryTagAscii(TIFF *tif, uint32_t *ndir,
54 TIFFDirEntry *dir, uint16_t tag,
55 uint32_t count, char *value);
56static int TIFFWriteDirectoryTagUndefinedArray(TIFF *tif, uint32_t *ndir,
57 TIFFDirEntry *dir, uint16_t tag,
58 uint32_t count, uint8_t *value);
59static int TIFFWriteDirectoryTagByteArray(TIFF *tif, uint32_t *ndir,
60 TIFFDirEntry *dir, uint16_t tag,
61 uint32_t count, uint8_t *value);
62static int TIFFWriteDirectoryTagSbyteArray(TIFF *tif, uint32_t *ndir,
63 TIFFDirEntry *dir, uint16_t tag,
64 uint32_t count, int8_t *value);
65static int TIFFWriteDirectoryTagShort(TIFF *tif, uint32_t *ndir,
66 TIFFDirEntry *dir, uint16_t tag,
67 uint16_t value);
68static int TIFFWriteDirectoryTagShortArray(TIFF *tif, uint32_t *ndir,
69 TIFFDirEntry *dir, uint16_t tag,
70 uint32_t count, uint16_t *value);
71static int TIFFWriteDirectoryTagShortPerSample(TIFF *tif, uint32_t *ndir,
72 TIFFDirEntry *dir, uint16_t tag,
73 uint16_t value);
74static int TIFFWriteDirectoryTagSshortArray(TIFF *tif, uint32_t *ndir,
75 TIFFDirEntry *dir, uint16_t tag,
76 uint32_t count, int16_t *value);
77static int TIFFWriteDirectoryTagLong(TIFF *tif, uint32_t *ndir,
78 TIFFDirEntry *dir, uint16_t tag,
79 uint32_t value);
80static int TIFFWriteDirectoryTagLongArray(TIFF *tif, uint32_t *ndir,
81 TIFFDirEntry *dir, uint16_t tag,
82 uint32_t count, uint32_t *value);
83static int TIFFWriteDirectoryTagSlongArray(TIFF *tif, uint32_t *ndir,
84 TIFFDirEntry *dir, uint16_t tag,
85 uint32_t count, int32_t *value);
86static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32_t *ndir,
87 TIFFDirEntry *dir, uint16_t tag,
88 uint32_t count, uint64_t *value);
89static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32_t *ndir,
90 TIFFDirEntry *dir, uint16_t tag,
91 uint32_t count, int64_t *value);
92static int TIFFWriteDirectoryTagRational(TIFF *tif, uint32_t *ndir,
93 TIFFDirEntry *dir, uint16_t tag,
94 double value);
95static int TIFFWriteDirectoryTagRationalArray(TIFF *tif, uint32_t *ndir,
96 TIFFDirEntry *dir, uint16_t tag,
97 uint32_t count, float *value);
98static int TIFFWriteDirectoryTagSrationalArray(TIFF *tif, uint32_t *ndir,
99 TIFFDirEntry *dir, uint16_t tag,
100 uint32_t count, float *value);
101static int TIFFWriteDirectoryTagFloatArray(TIFF *tif, uint32_t *ndir,
102 TIFFDirEntry *dir, uint16_t tag,
103 uint32_t count, float *value);
104static int TIFFWriteDirectoryTagDoubleArray(TIFF *tif, uint32_t *ndir,
105 TIFFDirEntry *dir, uint16_t tag,
106 uint32_t count, double *value);
107static int TIFFWriteDirectoryTagIfdArray(TIFF *tif, uint32_t *ndir,
108 TIFFDirEntry *dir, uint16_t tag,
109 uint32_t count, uint32_t *value);
110static int TIFFWriteDirectoryTagShortLong(TIFF *tif, uint32_t *ndir,
111 TIFFDirEntry *dir, uint16_t tag,
112 uint32_t value);
113static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32_t *ndir,
114 TIFFDirEntry *dir, uint16_t tag,
115 uint32_t count, uint64_t *value);
116static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF *tif, uint32_t *ndir,
117 TIFFDirEntry *dir, uint16_t tag,
118 uint32_t count, uint64_t *value);
119static int TIFFWriteDirectoryTagColormap(TIFF *tif, uint32_t *ndir,
120 TIFFDirEntry *dir);
121static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32_t *ndir,
122 TIFFDirEntry *dir);
123static int TIFFWriteDirectoryTagSubifd(TIFF *tif, uint32_t *ndir,
124 TIFFDirEntry *dir);
125
126static int TIFFWriteDirectoryTagCheckedAscii(TIFF *tif, uint32_t *ndir,
127 TIFFDirEntry *dir, uint16_t tag,
128 uint32_t count, char *value);
129static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF *tif, uint32_t *ndir,
130 TIFFDirEntry *dir,
131 uint16_t tag,
132 uint32_t count,
133 uint8_t *value);
134static int TIFFWriteDirectoryTagCheckedByteArray(TIFF *tif, uint32_t *ndir,
135 TIFFDirEntry *dir,
136 uint16_t tag, uint32_t count,
137 uint8_t *value);
138static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF *tif, uint32_t *ndir,
139 TIFFDirEntry *dir,
140 uint16_t tag, uint32_t count,
141 int8_t *value);
142static int TIFFWriteDirectoryTagCheckedShort(TIFF *tif, uint32_t *ndir,
143 TIFFDirEntry *dir, uint16_t tag,
144 uint16_t value);
145static int TIFFWriteDirectoryTagCheckedShortArray(TIFF *tif, uint32_t *ndir,
146 TIFFDirEntry *dir,
147 uint16_t tag, uint32_t count,
148 uint16_t *value);
149static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF *tif, uint32_t *ndir,
150 TIFFDirEntry *dir,
151 uint16_t tag, uint32_t count,
152 int16_t *value);
153static int TIFFWriteDirectoryTagCheckedLong(TIFF *tif, uint32_t *ndir,
154 TIFFDirEntry *dir, uint16_t tag,
155 uint32_t value);
156static int TIFFWriteDirectoryTagCheckedLongArray(TIFF *tif, uint32_t *ndir,
157 TIFFDirEntry *dir,
158 uint16_t tag, uint32_t count,
159 uint32_t *value);
160static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF *tif, uint32_t *ndir,
161 TIFFDirEntry *dir,
162 uint16_t tag, uint32_t count,
163 int32_t *value);
164static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF *tif, uint32_t *ndir,
165 TIFFDirEntry *dir,
166 uint16_t tag, uint32_t count,
167 uint64_t *value);
168static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF *tif, uint32_t *ndir,
169 TIFFDirEntry *dir,
170 uint16_t tag, uint32_t count,
171 int64_t *value);
172static int TIFFWriteDirectoryTagCheckedRational(TIFF *tif, uint32_t *ndir,
173 TIFFDirEntry *dir, uint16_t tag,
174 double value);
175static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32_t *ndir,
176 TIFFDirEntry *dir,
177 uint16_t tag,
178 uint32_t count,
179 float *value);
180static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32_t *ndir,
181 TIFFDirEntry *dir,
182 uint16_t tag,
183 uint32_t count,
184 float *value);
185
186/*--: Rational2Double: New functions to support true double-precision for custom
187 * rational tag types. */
188static int TIFFWriteDirectoryTagRationalDoubleArray(TIFF *tif, uint32_t *ndir,
189 TIFFDirEntry *dir,
190 uint16_t tag,
191 uint32_t count,
192 double *value);
193static int TIFFWriteDirectoryTagSrationalDoubleArray(TIFF *tif, uint32_t *ndir,
194 TIFFDirEntry *dir,
195 uint16_t tag,
196 uint32_t count,
197 double *value);
198static int
199TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF *tif, uint32_t *ndir,
200 TIFFDirEntry *dir, uint16_t tag,
201 uint32_t count, double *value);
202static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(
203 TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count,
204 double *value);
205static void DoubleToRational(double value, uint32_t *num, uint32_t *denom);
206static void DoubleToSrational(double value, int32_t *num, int32_t *denom);
207
208static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF *tif, uint32_t *ndir,
209 TIFFDirEntry *dir,
210 uint16_t tag, uint32_t count,
211 float *value);
212static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF *tif, uint32_t *ndir,
213 TIFFDirEntry *dir,
214 uint16_t tag, uint32_t count,
215 double *value);
216static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF *tif, uint32_t *ndir,
217 TIFFDirEntry *dir, uint16_t tag,
218 uint32_t count,
219 uint32_t *value);
220static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF *tif, uint32_t *ndir,
221 TIFFDirEntry *dir,
222 uint16_t tag, uint32_t count,
223 uint64_t *value);
224
225static int TIFFWriteDirectoryTagData(TIFF *tif, uint32_t *ndir,
226 TIFFDirEntry *dir, uint16_t tag,
227 uint16_t datatype, uint32_t count,
228 uint32_t datalength, void *data);
229
230static int TIFFLinkDirectory(TIFF *);
231
232/*
233 * Write the contents of the current directory
234 * to the specified file. This routine doesn't
235 * handle overwriting a directory with auxiliary
236 * storage that's been changed.
237 */
238int TIFFWriteDirectory(TIFF *tif)
239{
240 return TIFFWriteDirectorySec(tif, TRUE, TRUE, NULL);
241}
242
243/*
244 * This is an advanced writing function that must be used in a particular
245 * sequence, and generally together with TIFFForceStrileArrayWriting(),
246 * to make its intended effect. Its aim is to modify the location
247 * where the [Strip/Tile][Offsets/ByteCounts] arrays are located in the file.
248 * More precisely, when TIFFWriteCheck() will be called, the tag entries for
249 * those arrays will be written with type = count = offset = 0 as a temporary
250 * value.
251 *
252 * Its effect is only valid for the current directory, and before
253 * TIFFWriteDirectory() is first called, and will be reset when
254 * changing directory.
255 *
256 * The typical sequence of calls is:
257 * TIFFOpen()
258 * [ TIFFCreateDirectory(tif) ]
259 * Set fields with calls to TIFFSetField(tif, ...)
260 * TIFFDeferStrileArrayWriting(tif)
261 * TIFFWriteCheck(tif, ...)
262 * TIFFWriteDirectory(tif)
263 * ... potentially create other directories and come back to the above directory
264 * TIFFForceStrileArrayWriting(tif): emit the arrays at the end of file
265 *
266 * Returns 1 in case of success, 0 otherwise.
267 */
268int TIFFDeferStrileArrayWriting(TIFF *tif)
269{
270 static const char module[] = "TIFFDeferStrileArrayWriting";
271 if (tif->tif_mode == O_RDONLY)
272 {
273 TIFFErrorExtR(tif, tif->tif_name, "File opened in read-only mode");
274 return 0;
275 }
276 if (tif->tif_diroff != 0)
277 {
278 TIFFErrorExtR(tif, module, "Directory has already been written");
279 return 0;
280 }
281
282 tif->tif_dir.td_deferstrilearraywriting = TRUE;
283 return 1;
284}
285
286/*
287 * Similar to TIFFWriteDirectory(), writes the directory out
288 * but leaves all data structures in memory so that it can be
289 * written again. This will make a partially written TIFF file
290 * readable before it is successfully completed/closed.
291 */
292int TIFFCheckpointDirectory(TIFF *tif)
293{
294 int rc;
295 /* Setup the strips arrays, if they haven't already been. */
296 if (tif->tif_dir.td_stripoffset_p == NULL)
297 (void)TIFFSetupStrips(tif);
298 rc = TIFFWriteDirectorySec(tif, TRUE, FALSE, NULL);
299 (void)TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));
300 return rc;
301}
302
303int TIFFWriteCustomDirectory(TIFF *tif, uint64_t *pdiroff)
304{
305 return TIFFWriteDirectorySec(tif, FALSE, FALSE, pdiroff);
306}
307
308/*
309 * Similar to TIFFWriteDirectorySec(), but if the directory has already
310 * been written once, it is relocated to the end of the file, in case it
311 * has changed in size. Note that this will result in the loss of the
312 * previously used directory space.
313 */
314
315static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone,
316 uint64_t *pdiroff)
317{
318 static const char module[] = "TIFFRewriteDirectory";
319
320 /* We don't need to do anything special if it hasn't been written. */
321 if (tif->tif_diroff == 0)
322 return TIFFWriteDirectory(tif);
323
324 /*
325 * Find and zero the pointer to this directory, so that TIFFLinkDirectory
326 * will cause it to be added after this directories current pre-link.
327 */
328 uint64_t torewritediroff = tif->tif_diroff;
329
330 if (!(tif->tif_flags & TIFF_BIGTIFF))
331 {
332 if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff)
333 {
334 tif->tif_header.classic.tiff_diroff = 0;
335 tif->tif_diroff = 0;
336
337 TIFFSeekFile(tif, 4, SEEK_SET);
338 if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff), 4))
339 {
340 TIFFErrorExtR(tif, tif->tif_name, "Error updating TIFF header");
341 return (0);
342 }
343 }
344 else if (tif->tif_diroff > 0xFFFFFFFFU)
345 {
346 TIFFErrorExtR(tif, module,
347 "tif->tif_diroff exceeds 32 bit range allowed for "
348 "Classic TIFF");
349 return (0);
350 }
351 else
352 {
353 uint32_t nextdir;
354 nextdir = tif->tif_header.classic.tiff_diroff;
355 while (1)
356 {
357 uint16_t dircount;
358 uint32_t nextnextdir;
359
360 if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount, 2))
361 {
362 TIFFErrorExtR(tif, module,
363 "Error fetching directory count");
364 return (0);
365 }
366 if (tif->tif_flags & TIFF_SWAB)
367 TIFFSwabShort(&dircount);
368 (void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12, SEEK_SET);
369 if (!ReadOK(tif, &nextnextdir, 4))
370 {
371 TIFFErrorExtR(tif, module, "Error fetching directory link");
372 return (0);
373 }
374 if (tif->tif_flags & TIFF_SWAB)
375 TIFFSwabLong(&nextnextdir);
376 if (nextnextdir == tif->tif_diroff)
377 {
378 uint32_t m;
379 m = 0;
380 (void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12,
381 SEEK_SET);
382 if (!WriteOK(tif, &m, 4))
383 {
384 TIFFErrorExtR(tif, module,
385 "Error writing directory link");
386 return (0);
387 }
388 tif->tif_diroff = 0;
389 /* Force a full-traversal to reach the zeroed pointer */
390 tif->tif_lastdiroff = 0;
391 break;
392 }
393 nextdir = nextnextdir;
394 }
395 }
396 /* Remove skipped offset from IFD loop directory list. */
397 _TIFFRemoveEntryFromDirectoryListByOffset(tif, torewritediroff);
398 }
399 else
400 {
401 if (tif->tif_header.big.tiff_diroff == tif->tif_diroff)
402 {
403 tif->tif_header.big.tiff_diroff = 0;
404 tif->tif_diroff = 0;
405
406 TIFFSeekFile(tif, 8, SEEK_SET);
407 if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff), 8))
408 {
409 TIFFErrorExtR(tif, tif->tif_name, "Error updating TIFF header");
410 return (0);
411 }
412 }
413 else
414 {
415 uint64_t nextdir;
416 nextdir = tif->tif_header.big.tiff_diroff;
417 while (1)
418 {
419 uint64_t dircount64;
420 uint16_t dircount;
421 uint64_t nextnextdir;
422
423 if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount64, 8))
424 {
425 TIFFErrorExtR(tif, module,
426 "Error fetching directory count");
427 return (0);
428 }
429 if (tif->tif_flags & TIFF_SWAB)
430 TIFFSwabLong8(&dircount64);
431 if (dircount64 > 0xFFFF)
432 {
433 TIFFErrorExtR(tif, module,
434 "Sanity check on tag count failed, likely "
435 "corrupt TIFF");
436 return (0);
437 }
438 dircount = (uint16_t)dircount64;
439 (void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20, SEEK_SET);
440 if (!ReadOK(tif, &nextnextdir, 8))
441 {
442 TIFFErrorExtR(tif, module, "Error fetching directory link");
443 return (0);
444 }
445 if (tif->tif_flags & TIFF_SWAB)
446 TIFFSwabLong8(&nextnextdir);
447 if (nextnextdir == tif->tif_diroff)
448 {
449 uint64_t m;
450 m = 0;
451 (void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20,
452 SEEK_SET);
453 if (!WriteOK(tif, &m, 8))
454 {
455 TIFFErrorExtR(tif, module,
456 "Error writing directory link");
457 return (0);
458 }
459 tif->tif_diroff = 0;
460 /* Force a full-traversal to reach the zeroed pointer */
461 tif->tif_lastdiroff = 0;
462 break;
463 }
464 nextdir = nextnextdir;
465 }
466 }
467 /* Remove skipped offset from IFD loop directory list. */
468 _TIFFRemoveEntryFromDirectoryListByOffset(tif, torewritediroff);
469 }
470
471 /*
472 * Now use TIFFWriteDirectorySec() normally.
473 */
474 return TIFFWriteDirectorySec(tif, isimage, imagedone, pdiroff);
475} /*-- TIFFRewriteDirectorySec() --*/
476
477/*
478 * Similar to TIFFWriteDirectory(), but if the directory has already
479 * been written once, it is relocated to the end of the file, in case it
480 * has changed in size. Note that this will result in the loss of the
481 * previously used directory space.
482 */
483int TIFFRewriteDirectory(TIFF *tif)
484{
485 return TIFFRewriteDirectorySec(tif, TRUE, TRUE, NULL);
486}
487
488static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
489 uint64_t *pdiroff)
490{
491 static const char module[] = "TIFFWriteDirectorySec";
492 uint32_t ndir;
493 TIFFDirEntry *dir;
494 uint32_t dirsize;
495 void *dirmem;
496 uint32_t m;
497 if (tif->tif_mode == O_RDONLY)
498 return (1);
499
500 _TIFFFillStriles(tif);
501
502 /*
503 * Clear write state so that subsequent images with
504 * different characteristics get the right buffers
505 * setup for them.
506 */
507 if (imagedone)
508 {
509 if (tif->tif_flags & TIFF_POSTENCODE)
510 {
511 tif->tif_flags &= ~TIFF_POSTENCODE;
512 if (!(*tif->tif_postencode)(tif))
513 {
514 TIFFErrorExtR(tif, module,
515 "Error post-encoding before directory write");
516 return (0);
517 }
518 }
519 (*tif->tif_close)(tif); /* shutdown encoder */
520 /*
521 * Flush any data that might have been written
522 * by the compression close+cleanup routines. But
523 * be careful not to write stuff if we didn't add data
524 * in the previous steps as the "rawcc" data may well be
525 * a previously read tile/strip in mixed read/write mode.
526 */
527 if (tif->tif_rawcc > 0 && (tif->tif_flags & TIFF_BEENWRITING) != 0)
528 {
529 if (!TIFFFlushData1(tif))
530 {
531 TIFFErrorExtR(tif, module,
532 "Error flushing data before directory write");
533 return (0);
534 }
535 }
536 if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
537 {
538 _TIFFfreeExt(tif, tif->tif_rawdata);
539 tif->tif_rawdata = NULL;
540 tif->tif_rawcp = NULL;
541 tif->tif_rawcc = 0;
542 tif->tif_rawdatasize = 0;
543 tif->tif_rawdataoff = 0;
544 tif->tif_rawdataloaded = 0;
545 }
546 tif->tif_flags &= ~(TIFF_BEENWRITING | TIFF_BUFFERSETUP);
547 }
548
549 if (TIFFFieldSet(tif, FIELD_COMPRESSION) &&
550 (tif->tif_dir.td_compression == COMPRESSION_DEFLATE))
551 {
552 TIFFWarningExtR(tif, module,
553 "Creating TIFF with legacy Deflate codec identifier, "
554 "COMPRESSION_ADOBE_DEFLATE is more widely supported");
555 }
556 dir = NULL;
557 dirmem = NULL;
558 dirsize = 0;
559 while (1)
560 {
561 /* The first loop only determines "ndir" and uses TIFFLinkDirectory() to
562 * set the offset at which the IFD is to be written to the file.
563 * The second loop writes IFD entries to the file. */
564 ndir = 0;
565 if (dir == NULL)
566 tif->tif_dir.td_dirdatasize_write = 0;
567 if (isimage)
568 {
569 /*-- Step 1: Process named tags for an image with FIELD bits
570 * associated. --*/
571 if (TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS))
572 {
573 if (!TIFFWriteDirectoryTagShortLong(tif, &ndir, dir,
574 TIFFTAG_IMAGEWIDTH,
575 tif->tif_dir.td_imagewidth))
576 goto bad;
577 if (!TIFFWriteDirectoryTagShortLong(
578 tif, &ndir, dir, TIFFTAG_IMAGELENGTH,
579 tif->tif_dir.td_imagelength))
580 goto bad;
581 }
582 if (TIFFFieldSet(tif, FIELD_TILEDIMENSIONS))
583 {
584 if (!TIFFWriteDirectoryTagShortLong(tif, &ndir, dir,
585 TIFFTAG_TILEWIDTH,
586 tif->tif_dir.td_tilewidth))
587 goto bad;
588 if (!TIFFWriteDirectoryTagShortLong(tif, &ndir, dir,
589 TIFFTAG_TILELENGTH,
590 tif->tif_dir.td_tilelength))
591 goto bad;
592 }
593 if (TIFFFieldSet(tif, FIELD_RESOLUTION))
594 {
595 if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
596 TIFFTAG_XRESOLUTION,
597 tif->tif_dir.td_xresolution))
598 goto bad;
599 if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
600 TIFFTAG_YRESOLUTION,
601 tif->tif_dir.td_yresolution))
602 goto bad;
603 }
604 if (TIFFFieldSet(tif, FIELD_POSITION))
605 {
606 if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
607 TIFFTAG_XPOSITION,
608 tif->tif_dir.td_xposition))
609 goto bad;
610 if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
611 TIFFTAG_YPOSITION,
612 tif->tif_dir.td_yposition))
613 goto bad;
614 }
615 if (TIFFFieldSet(tif, FIELD_SUBFILETYPE))
616 {
617 if (!TIFFWriteDirectoryTagLong(tif, &ndir, dir,
618 TIFFTAG_SUBFILETYPE,
619 tif->tif_dir.td_subfiletype))
620 goto bad;
621 }
622 if (TIFFFieldSet(tif, FIELD_BITSPERSAMPLE))
623 {
624 if (!TIFFWriteDirectoryTagShortPerSample(
625 tif, &ndir, dir, TIFFTAG_BITSPERSAMPLE,
626 tif->tif_dir.td_bitspersample))
627 goto bad;
628 }
629 if (TIFFFieldSet(tif, FIELD_COMPRESSION))
630 {
631 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
632 TIFFTAG_COMPRESSION,
633 tif->tif_dir.td_compression))
634 goto bad;
635 }
636 if (TIFFFieldSet(tif, FIELD_PHOTOMETRIC))
637 {
638 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
639 TIFFTAG_PHOTOMETRIC,
640 tif->tif_dir.td_photometric))
641 goto bad;
642 }
643 if (TIFFFieldSet(tif, FIELD_THRESHHOLDING))
644 {
645 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
646 TIFFTAG_THRESHHOLDING,
647 tif->tif_dir.td_threshholding))
648 goto bad;
649 }
650 if (TIFFFieldSet(tif, FIELD_FILLORDER))
651 {
652 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
653 TIFFTAG_FILLORDER,
654 tif->tif_dir.td_fillorder))
655 goto bad;
656 }
657 if (TIFFFieldSet(tif, FIELD_ORIENTATION))
658 {
659 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
660 TIFFTAG_ORIENTATION,
661 tif->tif_dir.td_orientation))
662 goto bad;
663 }
664 if (TIFFFieldSet(tif, FIELD_SAMPLESPERPIXEL))
665 {
666 if (!TIFFWriteDirectoryTagShort(
667 tif, &ndir, dir, TIFFTAG_SAMPLESPERPIXEL,
668 tif->tif_dir.td_samplesperpixel))
669 goto bad;
670 }
671 if (TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
672 {
673 if (!TIFFWriteDirectoryTagShortLong(
674 tif, &ndir, dir, TIFFTAG_ROWSPERSTRIP,
675 tif->tif_dir.td_rowsperstrip))
676 goto bad;
677 }
678 if (TIFFFieldSet(tif, FIELD_MINSAMPLEVALUE))
679 {
680 if (!TIFFWriteDirectoryTagShortPerSample(
681 tif, &ndir, dir, TIFFTAG_MINSAMPLEVALUE,
682 tif->tif_dir.td_minsamplevalue))
683 goto bad;
684 }
685 if (TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
686 {
687 if (!TIFFWriteDirectoryTagShortPerSample(
688 tif, &ndir, dir, TIFFTAG_MAXSAMPLEVALUE,
689 tif->tif_dir.td_maxsamplevalue))
690 goto bad;
691 }
692 if (TIFFFieldSet(tif, FIELD_PLANARCONFIG))
693 {
694 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
695 TIFFTAG_PLANARCONFIG,
696 tif->tif_dir.td_planarconfig))
697 goto bad;
698 }
699 if (TIFFFieldSet(tif, FIELD_RESOLUTIONUNIT))
700 {
701 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
702 TIFFTAG_RESOLUTIONUNIT,
703 tif->tif_dir.td_resolutionunit))
704 goto bad;
705 }
706 if (TIFFFieldSet(tif, FIELD_PAGENUMBER))
707 {
708 if (!TIFFWriteDirectoryTagShortArray(
709 tif, &ndir, dir, TIFFTAG_PAGENUMBER, 2,
710 &tif->tif_dir.td_pagenumber[0]))
711 goto bad;
712 }
713 if (TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS))
714 {
715 if (!isTiled(tif))
716 {
717 if (!TIFFWriteDirectoryTagLongLong8Array(
718 tif, &ndir, dir, TIFFTAG_STRIPBYTECOUNTS,
719 tif->tif_dir.td_nstrips,
720 tif->tif_dir.td_stripbytecount_p))
721 goto bad;
722 }
723 else
724 {
725 if (!TIFFWriteDirectoryTagLongLong8Array(
726 tif, &ndir, dir, TIFFTAG_TILEBYTECOUNTS,
727 tif->tif_dir.td_nstrips,
728 tif->tif_dir.td_stripbytecount_p))
729 goto bad;
730 }
731 }
732 if (TIFFFieldSet(tif, FIELD_STRIPOFFSETS))
733 {
734 if (!isTiled(tif))
735 {
736 /* td_stripoffset_p might be NULL in an odd OJPEG case. See
737 * tif_dirread.c around line 3634.
738 * XXX: OJPEG hack.
739 * If a) compression is OJPEG, b) it's not a tiled TIFF,
740 * and c) the number of strips is 1,
741 * then we tolerate the absence of stripoffsets tag,
742 * because, presumably, all required data is in the
743 * JpegInterchangeFormat stream.
744 * We can get here when using tiffset on such a file.
745 * See http://bugzilla.maptools.org/show_bug.cgi?id=2500
746 */
747 if (tif->tif_dir.td_stripoffset_p != NULL &&
748 !TIFFWriteDirectoryTagLongLong8Array(
749 tif, &ndir, dir, TIFFTAG_STRIPOFFSETS,
750 tif->tif_dir.td_nstrips,
751 tif->tif_dir.td_stripoffset_p))
752 goto bad;
753 }
754 else
755 {
756 if (!TIFFWriteDirectoryTagLongLong8Array(
757 tif, &ndir, dir, TIFFTAG_TILEOFFSETS,
758 tif->tif_dir.td_nstrips,
759 tif->tif_dir.td_stripoffset_p))
760 goto bad;
761 }
762 }
763 if (TIFFFieldSet(tif, FIELD_COLORMAP))
764 {
765 if (!TIFFWriteDirectoryTagColormap(tif, &ndir, dir))
766 goto bad;
767 }
768 if (TIFFFieldSet(tif, FIELD_EXTRASAMPLES))
769 {
770 if (tif->tif_dir.td_extrasamples)
771 {
772 uint16_t na;
773 uint16_t *nb;
774 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES, &na, &nb);
775 if (!TIFFWriteDirectoryTagShortArray(
776 tif, &ndir, dir, TIFFTAG_EXTRASAMPLES, na, nb))
777 goto bad;
778 }
779 }
780 if (TIFFFieldSet(tif, FIELD_SAMPLEFORMAT))
781 {
782 if (!TIFFWriteDirectoryTagShortPerSample(
783 tif, &ndir, dir, TIFFTAG_SAMPLEFORMAT,
784 tif->tif_dir.td_sampleformat))
785 goto bad;
786 }
787 if (TIFFFieldSet(tif, FIELD_SMINSAMPLEVALUE))
788 {
789 if (!TIFFWriteDirectoryTagSampleformatArray(
790 tif, &ndir, dir, TIFFTAG_SMINSAMPLEVALUE,
791 tif->tif_dir.td_samplesperpixel,
792 tif->tif_dir.td_sminsamplevalue))
793 goto bad;
794 }
795 if (TIFFFieldSet(tif, FIELD_SMAXSAMPLEVALUE))
796 {
797 if (!TIFFWriteDirectoryTagSampleformatArray(
798 tif, &ndir, dir, TIFFTAG_SMAXSAMPLEVALUE,
799 tif->tif_dir.td_samplesperpixel,
800 tif->tif_dir.td_smaxsamplevalue))
801 goto bad;
802 }
803 if (TIFFFieldSet(tif, FIELD_IMAGEDEPTH))
804 {
805 if (!TIFFWriteDirectoryTagLong(tif, &ndir, dir,
806 TIFFTAG_IMAGEDEPTH,
807 tif->tif_dir.td_imagedepth))
808 goto bad;
809 }
810 if (TIFFFieldSet(tif, FIELD_TILEDEPTH))
811 {
812 if (!TIFFWriteDirectoryTagLong(tif, &ndir, dir,
813 TIFFTAG_TILEDEPTH,
814 tif->tif_dir.td_tiledepth))
815 goto bad;
816 }
817 if (TIFFFieldSet(tif, FIELD_HALFTONEHINTS))
818 {
819 if (!TIFFWriteDirectoryTagShortArray(
820 tif, &ndir, dir, TIFFTAG_HALFTONEHINTS, 2,
821 &tif->tif_dir.td_halftonehints[0]))
822 goto bad;
823 }
824 if (TIFFFieldSet(tif, FIELD_YCBCRSUBSAMPLING))
825 {
826 if (!TIFFWriteDirectoryTagShortArray(
827 tif, &ndir, dir, TIFFTAG_YCBCRSUBSAMPLING, 2,
828 &tif->tif_dir.td_ycbcrsubsampling[0]))
829 goto bad;
830 }
831 if (TIFFFieldSet(tif, FIELD_YCBCRPOSITIONING))
832 {
833 if (!TIFFWriteDirectoryTagShort(
834 tif, &ndir, dir, TIFFTAG_YCBCRPOSITIONING,
835 tif->tif_dir.td_ycbcrpositioning))
836 goto bad;
837 }
838 if (TIFFFieldSet(tif, FIELD_REFBLACKWHITE))
839 {
840 if (!TIFFWriteDirectoryTagRationalArray(
841 tif, &ndir, dir, TIFFTAG_REFERENCEBLACKWHITE, 6,
842 tif->tif_dir.td_refblackwhite))
843 goto bad;
844 }
845 if (TIFFFieldSet(tif, FIELD_TRANSFERFUNCTION))
846 {
847 if (!TIFFWriteDirectoryTagTransferfunction(tif, &ndir, dir))
848 goto bad;
849 }
850 if (TIFFFieldSet(tif, FIELD_INKNAMES))
851 {
852 if (!TIFFWriteDirectoryTagAscii(
853 tif, &ndir, dir, TIFFTAG_INKNAMES,
854 tif->tif_dir.td_inknameslen, tif->tif_dir.td_inknames))
855 goto bad;
856 }
857 if (TIFFFieldSet(tif, FIELD_NUMBEROFINKS))
858 {
859 if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir,
860 TIFFTAG_NUMBEROFINKS,
861 tif->tif_dir.td_numberofinks))
862 goto bad;
863 }
864 if (TIFFFieldSet(tif, FIELD_SUBIFD))
865 {
866 if (!TIFFWriteDirectoryTagSubifd(tif, &ndir, dir))
867 goto bad;
868 }
869 /*-- Step 2: Process named tags for an image with FIELD bits
870 added by a codec.
871 Attention: There is only code for some field_types,
872 which are actually used by current codecs. --*/
873 {
874 uint32_t n;
875 for (n = 0; n < tif->tif_nfields; n++)
876 {
877 const TIFFField *o;
878 o = tif->tif_fields[n];
879 if ((o->field_bit >= FIELD_CODEC) &&
880 (TIFFFieldSet(tif, o->field_bit)))
881 {
882 switch (o->set_get_field_type)
883 {
884 case TIFF_SETGET_ASCII:
885 {
886 uint32_t pa;
887 char *pb;
888 assert(o->field_type == TIFF_ASCII);
889 assert(o->field_readcount == TIFF_VARIABLE);
890 assert(o->field_passcount == 0);
891 TIFFGetField(tif, o->field_tag, &pb);
892 pa = (uint32_t)(strlen(pb) + 1);
893 if (!TIFFWriteDirectoryTagAscii(
894 tif, &ndir, dir, (uint16_t)o->field_tag,
895 pa, pb))
896 goto bad;
897 }
898 break;
899 case TIFF_SETGET_UINT16:
900 {
901 uint16_t p;
902 assert(o->field_type == TIFF_SHORT);
903 assert(o->field_readcount == 1);
904 assert(o->field_passcount == 0);
905 TIFFGetField(tif, o->field_tag, &p);
906 if (!TIFFWriteDirectoryTagShort(
907 tif, &ndir, dir, (uint16_t)o->field_tag,
908 p))
909 goto bad;
910 }
911 break;
912 case TIFF_SETGET_UINT32:
913 {
914 uint32_t p;
915 assert(o->field_type == TIFF_LONG);
916 assert(o->field_readcount == 1);
917 assert(o->field_passcount == 0);
918 TIFFGetField(tif, o->field_tag, &p);
919 if (!TIFFWriteDirectoryTagLong(
920 tif, &ndir, dir, (uint16_t)o->field_tag,
921 p))
922 goto bad;
923 }
924 break;
925 case TIFF_SETGET_C32_UINT8:
926 {
927 uint32_t pa;
928 void *pb;
929 assert(o->field_type == TIFF_UNDEFINED);
930 assert(o->field_readcount == TIFF_VARIABLE2);
931 assert(o->field_passcount == 1);
932 TIFFGetField(tif, o->field_tag, &pa, &pb);
933 if (!TIFFWriteDirectoryTagUndefinedArray(
934 tif, &ndir, dir, (uint16_t)o->field_tag,
935 pa, pb))
936 goto bad;
937 }
938 break;
939 default:
940 TIFFErrorExtR(
941 tif, module,
942 "Cannot write tag %" PRIu32 " (%s)",
943 TIFFFieldTag(o),
944 o->field_name ? o->field_name : "unknown");
945 goto bad;
946 }
947 }
948 }
949 }
950 }
951 /*-- Step 3: Process custom tags without FIELD bit for an image
952 * or for custom IFDs (e.g. EXIF) with !isimage. --*/
953 for (m = 0; m < (uint32_t)(tif->tif_dir.td_customValueCount); m++)
954 {
955 uint16_t tag =
956 (uint16_t)tif->tif_dir.td_customValues[m].info->field_tag;
957 uint32_t count = tif->tif_dir.td_customValues[m].count;
958 switch (tif->tif_dir.td_customValues[m].info->field_type)
959 {
960 case TIFF_ASCII:
961 if (!TIFFWriteDirectoryTagAscii(
962 tif, &ndir, dir, tag, count,
963 tif->tif_dir.td_customValues[m].value))
964 goto bad;
965 break;
966 case TIFF_UNDEFINED:
967 if (!TIFFWriteDirectoryTagUndefinedArray(
968 tif, &ndir, dir, tag, count,
969 tif->tif_dir.td_customValues[m].value))
970 goto bad;
971 break;
972 case TIFF_BYTE:
973 if (!TIFFWriteDirectoryTagByteArray(
974 tif, &ndir, dir, tag, count,
975 tif->tif_dir.td_customValues[m].value))
976 goto bad;
977 break;
978 case TIFF_SBYTE:
979 if (!TIFFWriteDirectoryTagSbyteArray(
980 tif, &ndir, dir, tag, count,
981 tif->tif_dir.td_customValues[m].value))
982 goto bad;
983 break;
984 case TIFF_SHORT:
985 if (!TIFFWriteDirectoryTagShortArray(
986 tif, &ndir, dir, tag, count,
987 tif->tif_dir.td_customValues[m].value))
988 goto bad;
989 break;
990 case TIFF_SSHORT:
991 if (!TIFFWriteDirectoryTagSshortArray(
992 tif, &ndir, dir, tag, count,
993 tif->tif_dir.td_customValues[m].value))
994 goto bad;
995 break;
996 case TIFF_LONG:
997 if (!TIFFWriteDirectoryTagLongArray(
998 tif, &ndir, dir, tag, count,
999 tif->tif_dir.td_customValues[m].value))
1000 goto bad;
1001 break;
1002 case TIFF_SLONG:
1003 if (!TIFFWriteDirectoryTagSlongArray(
1004 tif, &ndir, dir, tag, count,
1005 tif->tif_dir.td_customValues[m].value))
1006 goto bad;
1007 break;
1008 case TIFF_LONG8:
1009 if (!TIFFWriteDirectoryTagLong8Array(
1010 tif, &ndir, dir, tag, count,
1011 tif->tif_dir.td_customValues[m].value))
1012 goto bad;
1013 break;
1014 case TIFF_SLONG8:
1015 if (!TIFFWriteDirectoryTagSlong8Array(
1016 tif, &ndir, dir, tag, count,
1017 tif->tif_dir.td_customValues[m].value))
1018 goto bad;
1019 break;
1020 case TIFF_RATIONAL:
1021 {
1022 /*-- Rational2Double: For Rationals evaluate
1023 * "set_get_field_type" to determine internal storage size.
1024 */
1025 int tv_size;
1026 tv_size = TIFFFieldSetGetSize(
1027 tif->tif_dir.td_customValues[m].info);
1028 if (tv_size == 8)
1029 {
1030 if (!TIFFWriteDirectoryTagRationalDoubleArray(
1031 tif, &ndir, dir, tag, count,
1032 tif->tif_dir.td_customValues[m].value))
1033 goto bad;
1034 }
1035 else
1036 {
1037 /*-- default should be tv_size == 4 */
1038 if (!TIFFWriteDirectoryTagRationalArray(
1039 tif, &ndir, dir, tag, count,
1040 tif->tif_dir.td_customValues[m].value))
1041 goto bad;
1042 /*-- ToDo: After Testing, this should be removed and
1043 * tv_size==4 should be set as default. */
1044 if (tv_size != 4)
1045 {
1046 TIFFErrorExtR(
1047 tif, "TIFFLib: _TIFFWriteDirectorySec()",
1048 "Rational2Double: .set_get_field_type is "
1049 "not 4 but %d",
1050 tv_size);
1051 }
1052 }
1053 }
1054 break;
1055 case TIFF_SRATIONAL:
1056 {
1057 /*-- Rational2Double: For Rationals evaluate
1058 * "set_get_field_type" to determine internal storage size.
1059 */
1060 int tv_size;
1061 tv_size = TIFFFieldSetGetSize(
1062 tif->tif_dir.td_customValues[m].info);
1063 if (tv_size == 8)
1064 {
1065 if (!TIFFWriteDirectoryTagSrationalDoubleArray(
1066 tif, &ndir, dir, tag, count,
1067 tif->tif_dir.td_customValues[m].value))
1068 goto bad;
1069 }
1070 else
1071 {
1072 /*-- default should be tv_size == 4 */
1073 if (!TIFFWriteDirectoryTagSrationalArray(
1074 tif, &ndir, dir, tag, count,
1075 tif->tif_dir.td_customValues[m].value))
1076 goto bad;
1077 /*-- ToDo: After Testing, this should be removed and
1078 * tv_size==4 should be set as default. */
1079 if (tv_size != 4)
1080 {
1081 TIFFErrorExtR(
1082 tif, "TIFFLib: _TIFFWriteDirectorySec()",
1083 "Rational2Double: .set_get_field_type is "
1084 "not 4 but %d",
1085 tv_size);
1086 }
1087 }
1088 }
1089 break;
1090 case TIFF_FLOAT:
1091 if (!TIFFWriteDirectoryTagFloatArray(
1092 tif, &ndir, dir, tag, count,
1093 tif->tif_dir.td_customValues[m].value))
1094 goto bad;
1095 break;
1096 case TIFF_DOUBLE:
1097 if (!TIFFWriteDirectoryTagDoubleArray(
1098 tif, &ndir, dir, tag, count,
1099 tif->tif_dir.td_customValues[m].value))
1100 goto bad;
1101 break;
1102 case TIFF_IFD:
1103 if (!TIFFWriteDirectoryTagIfdArray(
1104 tif, &ndir, dir, tag, count,
1105 tif->tif_dir.td_customValues[m].value))
1106 goto bad;
1107 break;
1108 case TIFF_IFD8:
1109 if (!TIFFWriteDirectoryTagIfdIfd8Array(
1110 tif, &ndir, dir, tag, count,
1111 tif->tif_dir.td_customValues[m].value))
1112 goto bad;
1113 break;
1114 default:
1115 assert(0); /* we should never get here */
1116 break;
1117 }
1118 }
1119 /* "break" if IFD has been written above in second pass.*/
1120 if (dir != NULL)
1121 break;
1122
1123 /* Evaluate IFD data size: Finally, add the size of the IFD tag entries
1124 * themselves. */
1125 if (!(tif->tif_flags & TIFF_BIGTIFF))
1126 tif->tif_dir.td_dirdatasize_write += 2 + ndir * 12 + 4;
1127 else
1128 tif->tif_dir.td_dirdatasize_write += 8 + ndir * 20 + 8;
1129
1130 /* Setup a new directory within first pass. */
1131 dir = _TIFFmallocExt(tif, ndir * sizeof(TIFFDirEntry));
1132 if (dir == NULL)
1133 {
1134 TIFFErrorExtR(tif, module, "Out of memory");
1135 goto bad;
1136 }
1137 if (isimage)
1138 {
1139 /* Check, weather the IFD to be written is new or an already written
1140 * IFD can be overwritten or needs to be re-written to a different
1141 * location in the file because the IFD is extended with additional
1142 * tags or the IFD data size is increased.
1143 * - tif_diroff == 0, if a new directory has to be linked.
1144 * - tif_diroff != 0, IFD has been re-read from file and will be
1145 * overwritten or re-written.
1146 */
1147 if (tif->tif_diroff == 0)
1148 {
1149 if (!TIFFLinkDirectory(tif))
1150 goto bad;
1151 }
1152 else if (tif->tif_dir.td_dirdatasize_write >
1153 tif->tif_dir.td_dirdatasize_read)
1154 {
1155 if (dir != NULL)
1156 {
1157 _TIFFfreeExt(tif, dir);
1158 dir = NULL;
1159 }
1160 if (!TIFFRewriteDirectorySec(tif, isimage, imagedone, pdiroff))
1161 goto bad;
1162 return (1);
1163 }
1164 }
1165 else
1166 {
1167 /* For !isimage, which means custom-IFD like EXIFIFD or
1168 * checkpointing an IFD, determine whether to overwrite or append at
1169 * the end of the file.
1170 */
1171 if (!((tif->tif_dir.td_dirdatasize_read > 0) &&
1172 (tif->tif_dir.td_dirdatasize_write <=
1173 tif->tif_dir.td_dirdatasize_read)))
1174 {
1175 /* Append at end of file and increment to an even offset. */
1176 tif->tif_diroff =
1177 (TIFFSeekFile(tif, 0, SEEK_END) + 1) & (~((toff_t)1));
1178 }
1179 }
1180 /* Return IFD offset */
1181 if (pdiroff != NULL)
1182 *pdiroff = tif->tif_diroff;
1183 if (!(tif->tif_flags & TIFF_BIGTIFF))
1184 dirsize = 2 + ndir * 12 + 4;
1185 else
1186 dirsize = 8 + ndir * 20 + 8;
1187 /* Append IFD data stright after the IFD tag entries.
1188 * Data that does not fit into an IFD tag entry is written to the file
1189 * in the second pass of the while loop. That offset is stored in "dir".
1190 */
1191 tif->tif_dataoff = tif->tif_diroff + dirsize;
1192 if (!(tif->tif_flags & TIFF_BIGTIFF))
1193 tif->tif_dataoff = (uint32_t)tif->tif_dataoff;
1194 if ((tif->tif_dataoff < tif->tif_diroff) ||
1195 (tif->tif_dataoff < (uint64_t)dirsize))
1196 {
1197 TIFFErrorExtR(tif, module, "Maximum TIFF file size exceeded");
1198 goto bad;
1199 }
1200 if (tif->tif_dataoff & 1)
1201 tif->tif_dataoff++;
1202 } /* while() */
1203 if (isimage)
1204 {
1205 /* For SubIFDs remember offset of SubIFD tag within main IFD.
1206 * However, might be already done in TIFFWriteDirectoryTagSubifd() if
1207 * there are more than one SubIFD. */
1208 if (TIFFFieldSet(tif, FIELD_SUBIFD) && (tif->tif_subifdoff == 0))
1209 {
1210 uint32_t na;
1211 TIFFDirEntry *nb;
1212 for (na = 0, nb = dir;; na++, nb++)
1213 {
1214 if (na == ndir)
1215 {
1216 TIFFErrorExtR(tif, module, "Cannot find SubIFD tag");
1217 goto bad;
1218 }
1219 if (nb->tdir_tag == TIFFTAG_SUBIFD)
1220 break;
1221 }
1222 if (!(tif->tif_flags & TIFF_BIGTIFF))
1223 tif->tif_subifdoff = tif->tif_diroff + 2 + na * 12 + 8;
1224 else
1225 tif->tif_subifdoff = tif->tif_diroff + 8 + na * 20 + 12;
1226 }
1227 }
1228 /* Copy/swab IFD entries from "dir" into "dirmem",
1229 * which is then written to file. */
1230 dirmem = _TIFFmallocExt(tif, dirsize);
1231 if (dirmem == NULL)
1232 {
1233 TIFFErrorExtR(tif, module, "Out of memory");
1234 goto bad;
1235 }
1236 if (!(tif->tif_flags & TIFF_BIGTIFF))
1237 {
1238 uint8_t *n;
1239 uint32_t nTmp;
1240 TIFFDirEntry *o;
1241 n = dirmem;
1242 *(uint16_t *)n = (uint16_t)ndir;
1243 if (tif->tif_flags & TIFF_SWAB)
1244 TIFFSwabShort((uint16_t *)n);
1245 n += 2;
1246 o = dir;
1247 for (m = 0; m < ndir; m++)
1248 {
1249 *(uint16_t *)n = o->tdir_tag;
1250 if (tif->tif_flags & TIFF_SWAB)
1251 TIFFSwabShort((uint16_t *)n);
1252 n += 2;
1253 *(uint16_t *)n = o->tdir_type;
1254 if (tif->tif_flags & TIFF_SWAB)
1255 TIFFSwabShort((uint16_t *)n);
1256 n += 2;
1257 nTmp = (uint32_t)o->tdir_count;
1258 _TIFFmemcpy(n, &nTmp, 4);
1259 if (tif->tif_flags & TIFF_SWAB)
1260 TIFFSwabLong((uint32_t *)n);
1261 n += 4;
1262 /* This is correct. The data has been */
1263 /* swabbed previously in TIFFWriteDirectoryTagData */
1264 _TIFFmemcpy(n, &o->tdir_offset, 4);
1265 n += 4;
1266 o++;
1267 }
1268 nTmp = (uint32_t)tif->tif_nextdiroff;
1269 if (tif->tif_flags & TIFF_SWAB)
1270 TIFFSwabLong(&nTmp);
1271 _TIFFmemcpy(n, &nTmp, 4);
1272 }
1273 else
1274 {
1275 uint8_t *n;
1276 TIFFDirEntry *o;
1277 n = dirmem;
1278 *(uint64_t *)n = ndir;
1279 if (tif->tif_flags & TIFF_SWAB)
1280 TIFFSwabLong8((uint64_t *)n);
1281 n += 8;
1282 o = dir;
1283 for (m = 0; m < ndir; m++)
1284 {
1285 *(uint16_t *)n = o->tdir_tag;
1286 if (tif->tif_flags & TIFF_SWAB)
1287 TIFFSwabShort((uint16_t *)n);
1288 n += 2;
1289 *(uint16_t *)n = o->tdir_type;
1290 if (tif->tif_flags & TIFF_SWAB)
1291 TIFFSwabShort((uint16_t *)n);
1292 n += 2;
1293 _TIFFmemcpy(n, &o->tdir_count, 8);
1294 if (tif->tif_flags & TIFF_SWAB)
1295 TIFFSwabLong8((uint64_t *)n);
1296 n += 8;
1297 _TIFFmemcpy(n, &o->tdir_offset, 8);
1298 n += 8;
1299 o++;
1300 }
1301 _TIFFmemcpy(n, &tif->tif_nextdiroff, 8);
1302 if (tif->tif_flags & TIFF_SWAB)
1303 TIFFSwabLong8((uint64_t *)n);
1304 }
1305 _TIFFfreeExt(tif, dir);
1306 dir = NULL;
1307 if (!SeekOK(tif, tif->tif_diroff))
1308 {
1309 TIFFErrorExtR(tif, module,
1310 "IO error writing directory at seek to offset");
1311 goto bad;
1312 }
1313 if (!WriteOK(tif, dirmem, (tmsize_t)dirsize))
1314 {
1315 TIFFErrorExtR(tif, module, "IO error writing directory");
1316 goto bad;
1317 }
1318 _TIFFfreeExt(tif, dirmem);
1319
1320 /* Increment tif_curdir if IFD wasn't already written to file and no error
1321 * occurred during IFD writing above. */
1322 if (isimage && !tif->tif_dir.td_iswrittentofile)
1323 {
1324 if (!((tif->tif_flags & TIFF_INSUBIFD) &&
1325 !(TIFFFieldSet(tif, FIELD_SUBIFD))))
1326 {
1327 /*-- Normal main-IFD case --*/
1328 if (tif->tif_curdircount != TIFF_NON_EXISTENT_DIR_NUMBER)
1329 {
1330 tif->tif_curdir = tif->tif_curdircount;
1331 }
1332 else
1333 {
1334 /*ToDo SU: NEW_IFD_CURDIR_INCREMENTING: Delete this
1335 * unexpected case after some testing time. */
1336 /* Attention: tif->tif_curdircount is already set within
1337 * TIFFNumberOfDirectories() */
1338 tif->tif_curdircount = TIFFNumberOfDirectories(tif);
1339 tif->tif_curdir = tif->tif_curdircount;
1340 TIFFErrorExtR(
1341 tif, module,
1342 "tif_curdircount is TIFF_NON_EXISTENT_DIR_NUMBER, "
1343 "not expected !! Line %d",
1344 __LINE__);
1345 goto bad;
1346 }
1347 }
1348 else
1349 {
1350 /*-- SubIFD case -- */
1351 /* tif_curdir is always set to 0 for all SubIFDs. */
1352 tif->tif_curdir = 0;
1353 }
1354 }
1355 /* Increment tif_curdircount only if main-IFD of an image was not already
1356 * present on file. */
1357 /* Check in combination with (... && !(TIFFFieldSet(tif, FIELD_SUBIFD)))
1358 * is necessary here because TIFF_INSUBIFD was already set above for the
1359 * next SubIFD when this main-IFD (with FIELD_SUBIFD) is currently being
1360 * written. */
1361 if (isimage && !tif->tif_dir.td_iswrittentofile &&
1362 !((tif->tif_flags & TIFF_INSUBIFD) &&
1363 !(TIFFFieldSet(tif, FIELD_SUBIFD))))
1364 tif->tif_curdircount++;
1365
1366 tif->tif_dir.td_iswrittentofile = TRUE;
1367
1368 /* Reset SubIFD writing stage after last SubIFD has been written. */
1369 if (imagedone && (tif->tif_flags & TIFF_INSUBIFD) && tif->tif_nsubifd == 0)
1370 tif->tif_flags &= ~TIFF_INSUBIFD;
1371
1372 /* Add or update this directory to the IFD list. */
1373 if (!_TIFFCheckDirNumberAndOffset(tif, tif->tif_curdir, tif->tif_diroff))
1374 {
1375 TIFFErrorExtR(tif, module,
1376 "Starting directory %u at offset 0x%" PRIx64 " (%" PRIu64
1377 ") might cause an IFD loop",
1378 tif->tif_curdir, tif->tif_diroff, tif->tif_diroff);
1379 }
1380
1381 if (imagedone)
1382 {
1383 TIFFFreeDirectory(tif);
1384 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
1385 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
1386 /* Reset directory-related state for subsequent directories. */
1387 TIFFCreateDirectory(tif);
1388 }
1389 else
1390 {
1391 /* IFD is only checkpointed to file (or a custom IFD like EXIF is
1392 * written), thus set IFD data size written to file. */
1393 tif->tif_dir.td_dirdatasize_read = tif->tif_dir.td_dirdatasize_write;
1394 }
1395 return (1);
1396bad:
1397 if (dir != NULL)
1398 _TIFFfreeExt(tif, dir);
1399 if (dirmem != NULL)
1400 _TIFFfreeExt(tif, dirmem);
1401 return (0);
1402}
1403
1404static int8_t TIFFClampDoubleToInt8(double val)
1405{
1406 if (val > 127)
1407 return 127;
1408 if (val < -128 || val != val)
1409 return -128;
1410 return (int8_t)val;
1411}
1412
1413static int16_t TIFFClampDoubleToInt16(double val)
1414{
1415 if (val > 32767)
1416 return 32767;
1417 if (val < -32768 || val != val)
1418 return -32768;
1419 return (int16_t)val;
1420}
1421
1422static int32_t TIFFClampDoubleToInt32(double val)
1423{
1424 if (val > 0x7FFFFFFF)
1425 return 0x7FFFFFFF;
1426 if (val < -0x7FFFFFFF - 1 || val != val)
1427 return -0x7FFFFFFF - 1;
1428 return (int32_t)val;
1429}
1430
1431static uint8_t TIFFClampDoubleToUInt8(double val)
1432{
1433 if (val < 0)
1434 return 0;
1435 if (val > 255 || val != val)
1436 return 255;
1437 return (uint8_t)val;
1438}
1439
1440static uint16_t TIFFClampDoubleToUInt16(double val)
1441{
1442 if (val < 0)
1443 return 0;
1444 if (val > 65535 || val != val)
1445 return 65535;
1446 return (uint16_t)val;
1447}
1448
1449static uint32_t TIFFClampDoubleToUInt32(double val)
1450{
1451 if (val < 0)
1452 return 0;
1453 if (val > 0xFFFFFFFFU || val != val)
1454 return 0xFFFFFFFFU;
1455 return (uint32_t)val;
1456}
1457
1458static int TIFFWriteDirectoryTagSampleformatArray(TIFF *tif, uint32_t *ndir,
1459 TIFFDirEntry *dir,
1460 uint16_t tag, uint32_t count,
1461 double *value)
1462{
1463 static const char module[] = "TIFFWriteDirectoryTagSampleformatArray";
1464 void *conv;
1465 uint32_t i;
1466 int ok;
1467 conv = _TIFFmallocExt(tif, count * sizeof(double));
1468 if (conv == NULL)
1469 {
1470 TIFFErrorExtR(tif, module, "Out of memory");
1471 return (0);
1472 }
1473
1474 switch (tif->tif_dir.td_sampleformat)
1475 {
1476 case SAMPLEFORMAT_IEEEFP:
1477 if (tif->tif_dir.td_bitspersample <= 32)
1478 {
1479 for (i = 0; i < count; ++i)
1480 ((float *)conv)[i] = _TIFFClampDoubleToFloat(value[i]);
1481 ok = TIFFWriteDirectoryTagFloatArray(tif, ndir, dir, tag, count,
1482 (float *)conv);
1483 }
1484 else
1485 {
1486 ok = TIFFWriteDirectoryTagDoubleArray(tif, ndir, dir, tag,
1487 count, value);
1488 }
1489 break;
1490 case SAMPLEFORMAT_INT:
1491 if (tif->tif_dir.td_bitspersample <= 8)
1492 {
1493 for (i = 0; i < count; ++i)
1494 ((int8_t *)conv)[i] = TIFFClampDoubleToInt8(value[i]);
1495 ok = TIFFWriteDirectoryTagSbyteArray(tif, ndir, dir, tag, count,
1496 (int8_t *)conv);
1497 }
1498 else if (tif->tif_dir.td_bitspersample <= 16)
1499 {
1500 for (i = 0; i < count; ++i)
1501 ((int16_t *)conv)[i] = TIFFClampDoubleToInt16(value[i]);
1502 ok = TIFFWriteDirectoryTagSshortArray(tif, ndir, dir, tag,
1503 count, (int16_t *)conv);
1504 }
1505 else
1506 {
1507 for (i = 0; i < count; ++i)
1508 ((int32_t *)conv)[i] = TIFFClampDoubleToInt32(value[i]);
1509 ok = TIFFWriteDirectoryTagSlongArray(tif, ndir, dir, tag, count,
1510 (int32_t *)conv);
1511 }
1512 break;
1513 case SAMPLEFORMAT_UINT:
1514 if (tif->tif_dir.td_bitspersample <= 8)
1515 {
1516 for (i = 0; i < count; ++i)
1517 ((uint8_t *)conv)[i] = TIFFClampDoubleToUInt8(value[i]);
1518 ok = TIFFWriteDirectoryTagByteArray(tif, ndir, dir, tag, count,
1519 (uint8_t *)conv);
1520 }
1521 else if (tif->tif_dir.td_bitspersample <= 16)
1522 {
1523 for (i = 0; i < count; ++i)
1524 ((uint16_t *)conv)[i] = TIFFClampDoubleToUInt16(value[i]);
1525 ok = TIFFWriteDirectoryTagShortArray(tif, ndir, dir, tag, count,
1526 (uint16_t *)conv);
1527 }
1528 else
1529 {
1530 for (i = 0; i < count; ++i)
1531 ((uint32_t *)conv)[i] = TIFFClampDoubleToUInt32(value[i]);
1532 ok = TIFFWriteDirectoryTagLongArray(tif, ndir, dir, tag, count,
1533 (uint32_t *)conv);
1534 }
1535 break;
1536 default:
1537 ok = 0;
1538 }
1539
1540 _TIFFfreeExt(tif, conv);
1541 return (ok);
1542}
1543
1544static int TIFFWriteDirectoryTagAscii(TIFF *tif, uint32_t *ndir,
1545 TIFFDirEntry *dir, uint16_t tag,
1546 uint32_t count, char *value)
1547{
1548 return (
1549 TIFFWriteDirectoryTagCheckedAscii(tif, ndir, dir, tag, count, value));
1550}
1551
1552static int TIFFWriteDirectoryTagUndefinedArray(TIFF *tif, uint32_t *ndir,
1553 TIFFDirEntry *dir, uint16_t tag,
1554 uint32_t count, uint8_t *value)
1555{
1556 return (TIFFWriteDirectoryTagCheckedUndefinedArray(tif, ndir, dir, tag,
1557 count, value));
1558}
1559
1560static int TIFFWriteDirectoryTagByteArray(TIFF *tif, uint32_t *ndir,
1561 TIFFDirEntry *dir, uint16_t tag,
1562 uint32_t count, uint8_t *value)
1563{
1564 return (TIFFWriteDirectoryTagCheckedByteArray(tif, ndir, dir, tag, count,
1565 value));
1566}
1567
1568static int TIFFWriteDirectoryTagSbyteArray(TIFF *tif, uint32_t *ndir,
1569 TIFFDirEntry *dir, uint16_t tag,
1570 uint32_t count, int8_t *value)
1571{
1572 return (TIFFWriteDirectoryTagCheckedSbyteArray(tif, ndir, dir, tag, count,
1573 value));
1574}
1575
1576static int TIFFWriteDirectoryTagShort(TIFF *tif, uint32_t *ndir,
1577 TIFFDirEntry *dir, uint16_t tag,
1578 uint16_t value)
1579{
1580 return (TIFFWriteDirectoryTagCheckedShort(tif, ndir, dir, tag, value));
1581}
1582
1583static int TIFFWriteDirectoryTagShortArray(TIFF *tif, uint32_t *ndir,
1584 TIFFDirEntry *dir, uint16_t tag,
1585 uint32_t count, uint16_t *value)
1586{
1587 return (TIFFWriteDirectoryTagCheckedShortArray(tif, ndir, dir, tag, count,
1588 value));
1589}
1590
1591static int TIFFWriteDirectoryTagShortPerSample(TIFF *tif, uint32_t *ndir,
1592 TIFFDirEntry *dir, uint16_t tag,
1593 uint16_t value)
1594{
1595 static const char module[] = "TIFFWriteDirectoryTagShortPerSample";
1596 uint16_t *m;
1597 uint16_t *na;
1598 uint16_t nb;
1599 int o;
1600 if (dir == NULL)
1601 {
1602 /* only evaluate IFD data size and inc. ndir */
1603 return (TIFFWriteDirectoryTagCheckedShortArray(
1604 tif, ndir, dir, tag, tif->tif_dir.td_samplesperpixel, NULL));
1605 }
1606 m = _TIFFmallocExt(tif, tif->tif_dir.td_samplesperpixel * sizeof(uint16_t));
1607 if (m == NULL)
1608 {
1609 TIFFErrorExtR(tif, module, "Out of memory");
1610 return (0);
1611 }
1612 for (na = m, nb = 0; nb < tif->tif_dir.td_samplesperpixel; na++, nb++)
1613 *na = value;
1614 o = TIFFWriteDirectoryTagCheckedShortArray(
1615 tif, ndir, dir, tag, tif->tif_dir.td_samplesperpixel, m);
1616 _TIFFfreeExt(tif, m);
1617 return (o);
1618}
1619
1620static int TIFFWriteDirectoryTagSshortArray(TIFF *tif, uint32_t *ndir,
1621 TIFFDirEntry *dir, uint16_t tag,
1622 uint32_t count, int16_t *value)
1623{
1624 return (TIFFWriteDirectoryTagCheckedSshortArray(tif, ndir, dir, tag, count,
1625 value));
1626}
1627
1628static int TIFFWriteDirectoryTagLong(TIFF *tif, uint32_t *ndir,
1629 TIFFDirEntry *dir, uint16_t tag,
1630 uint32_t value)
1631{
1632 return (TIFFWriteDirectoryTagCheckedLong(tif, ndir, dir, tag, value));
1633}
1634
1635static int TIFFWriteDirectoryTagLongArray(TIFF *tif, uint32_t *ndir,
1636 TIFFDirEntry *dir, uint16_t tag,
1637 uint32_t count, uint32_t *value)
1638{
1639 return (TIFFWriteDirectoryTagCheckedLongArray(tif, ndir, dir, tag, count,
1640 value));
1641}
1642
1643static int TIFFWriteDirectoryTagSlongArray(TIFF *tif, uint32_t *ndir,
1644 TIFFDirEntry *dir, uint16_t tag,
1645 uint32_t count, int32_t *value)
1646{
1647 return (TIFFWriteDirectoryTagCheckedSlongArray(tif, ndir, dir, tag, count,
1648 value));
1649}
1650
1651/************************************************************************/
1652/* TIFFWriteDirectoryTagLong8Array() */
1653/* */
1654/* Write either Long8 or Long array depending on file type. */
1655/************************************************************************/
1656static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32_t *ndir,
1657 TIFFDirEntry *dir, uint16_t tag,
1658 uint32_t count, uint64_t *value)
1659{
1660 static const char module[] = "TIFFWriteDirectoryTagLong8Array";
1661 uint64_t *ma;
1662 uint32_t mb;
1663 uint32_t *p;
1664 uint32_t *q;
1665 int o;
1666
1667 /* is this just a counting pass? */
1668 if (dir == NULL)
1669 {
1670 /* only evaluate IFD data size and inc. ndir */
1671 return (TIFFWriteDirectoryTagCheckedLong8Array(tif, ndir, dir, tag,
1672 count, value));
1673 }
1674
1675 /* We always write Long8 for BigTIFF, no checking needed. */
1676 if (tif->tif_flags & TIFF_BIGTIFF)
1677 return (TIFFWriteDirectoryTagCheckedLong8Array(tif, ndir, dir, tag,
1678 count, value));
1679
1680 /*
1681 ** For classic tiff we want to verify everything is in range for long
1682 ** and convert to long format.
1683 */
1684 p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
1685 if (p == NULL)
1686 {
1687 TIFFErrorExtR(tif, module, "Out of memory");
1688 return (0);
1689 }
1690
1691 for (q = p, ma = value, mb = 0; mb < count; ma++, mb++, q++)
1692 {
1693 if (*ma > 0xFFFFFFFF)
1694 {
1695 TIFFErrorExtR(tif, module,
1696 "Attempt to write unsigned long value %" PRIu64
1697 " larger than 0xFFFFFFFF for tag %d in Classic TIFF "
1698 "file. TIFF file writing aborted",
1699 *ma, tag);
1700 _TIFFfreeExt(tif, p);
1701 return (0);
1702 }
1703 *q = (uint32_t)(*ma);
1704 }
1705
1706 o = TIFFWriteDirectoryTagCheckedLongArray(tif, ndir, dir, tag, count, p);
1707 _TIFFfreeExt(tif, p);
1708
1709 return (o);
1710}
1711
1712/************************************************************************/
1713/* TIFFWriteDirectoryTagSlong8Array() */
1714/* */
1715/* Write either SLong8 or SLong array depending on file type. */
1716/************************************************************************/
1717static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32_t *ndir,
1718 TIFFDirEntry *dir, uint16_t tag,
1719 uint32_t count, int64_t *value)
1720{
1721 static const char module[] = "TIFFWriteDirectoryTagSlong8Array";
1722 int64_t *ma;
1723 uint32_t mb;
1724 int32_t *p;
1725 int32_t *q;
1726 int o;
1727
1728 /* is this just a counting pass? */
1729 if (dir == NULL)
1730 {
1731 /* only evaluate IFD data size and inc. ndir */
1732 return (TIFFWriteDirectoryTagCheckedSlong8Array(tif, ndir, dir, tag,
1733 count, value));
1734 }
1735 /* We always write SLong8 for BigTIFF, no checking needed. */
1736 if (tif->tif_flags & TIFF_BIGTIFF)
1737 return (TIFFWriteDirectoryTagCheckedSlong8Array(tif, ndir, dir, tag,
1738 count, value));
1739
1740 /*
1741 ** For classic tiff we want to verify everything is in range for signed-long
1742 ** and convert to signed-long format.
1743 */
1744 p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
1745 if (p == NULL)
1746 {
1747 TIFFErrorExtR(tif, module, "Out of memory");
1748 return (0);
1749 }
1750
1751 for (q = p, ma = value, mb = 0; mb < count; ma++, mb++, q++)
1752 {
1753 if (*ma > (2147483647))
1754 {
1755 TIFFErrorExtR(tif, module,
1756 "Attempt to write signed long value %" PRIi64
1757 " larger than 0x7FFFFFFF (2147483647) for tag %d in "
1758 "Classic TIFF file. TIFF writing to file aborted",
1759 *ma, tag);
1760 _TIFFfreeExt(tif, p);
1761 return (0);
1762 }
1763 else if (*ma < (-2147483647 - 1))
1764 {
1765 TIFFErrorExtR(tif, module,
1766 "Attempt to write signed long value %" PRIi64
1767 " smaller than 0x80000000 (-2147483648) for tag %d "
1768 "in Classic TIFF file. TIFF writing to file aborted",
1769 *ma, tag);
1770 _TIFFfreeExt(tif, p);
1771 return (0);
1772 }
1773 *q = (int32_t)(*ma);
1774 }
1775
1776 o = TIFFWriteDirectoryTagCheckedSlongArray(tif, ndir, dir, tag, count, p);
1777 _TIFFfreeExt(tif, p);
1778
1779 return (o);
1780}
1781
1782static int TIFFWriteDirectoryTagRational(TIFF *tif, uint32_t *ndir,
1783 TIFFDirEntry *dir, uint16_t tag,
1784 double value)
1785{
1786 return (TIFFWriteDirectoryTagCheckedRational(tif, ndir, dir, tag, value));
1787}
1788
1789static int TIFFWriteDirectoryTagRationalArray(TIFF *tif, uint32_t *ndir,
1790 TIFFDirEntry *dir, uint16_t tag,
1791 uint32_t count, float *value)
1792{
1793 return (TIFFWriteDirectoryTagCheckedRationalArray(tif, ndir, dir, tag,
1794 count, value));
1795}
1796
1797static int TIFFWriteDirectoryTagSrationalArray(TIFF *tif, uint32_t *ndir,
1798 TIFFDirEntry *dir, uint16_t tag,
1799 uint32_t count, float *value)
1800{
1801 return (TIFFWriteDirectoryTagCheckedSrationalArray(tif, ndir, dir, tag,
1802 count, value));
1803}
1804
1805/*-- Rational2Double: additional write functions */
1806static int TIFFWriteDirectoryTagRationalDoubleArray(TIFF *tif, uint32_t *ndir,
1807 TIFFDirEntry *dir,
1808 uint16_t tag,
1809 uint32_t count,
1810 double *value)
1811{
1812 return (TIFFWriteDirectoryTagCheckedRationalDoubleArray(tif, ndir, dir, tag,
1813 count, value));
1814}
1815
1816static int TIFFWriteDirectoryTagSrationalDoubleArray(TIFF *tif, uint32_t *ndir,
1817 TIFFDirEntry *dir,
1818 uint16_t tag,
1819 uint32_t count,
1820 double *value)
1821{
1822 return (TIFFWriteDirectoryTagCheckedSrationalDoubleArray(
1823 tif, ndir, dir, tag, count, value));
1824}
1825
1826static int TIFFWriteDirectoryTagFloatArray(TIFF *tif, uint32_t *ndir,
1827 TIFFDirEntry *dir, uint16_t tag,
1828 uint32_t count, float *value)
1829{
1830 return (TIFFWriteDirectoryTagCheckedFloatArray(tif, ndir, dir, tag, count,
1831 value));
1832}
1833
1834static int TIFFWriteDirectoryTagDoubleArray(TIFF *tif, uint32_t *ndir,
1835 TIFFDirEntry *dir, uint16_t tag,
1836 uint32_t count, double *value)
1837{
1838 return (TIFFWriteDirectoryTagCheckedDoubleArray(tif, ndir, dir, tag, count,
1839 value));
1840}
1841
1842static int TIFFWriteDirectoryTagIfdArray(TIFF *tif, uint32_t *ndir,
1843 TIFFDirEntry *dir, uint16_t tag,
1844 uint32_t count, uint32_t *value)
1845{
1846 return (TIFFWriteDirectoryTagCheckedIfdArray(tif, ndir, dir, tag, count,
1847 value));
1848}
1849
1850static int TIFFWriteDirectoryTagShortLong(TIFF *tif, uint32_t *ndir,
1851 TIFFDirEntry *dir, uint16_t tag,
1852 uint32_t value)
1853{
1854 if (value <= 0xFFFF)
1855 return (TIFFWriteDirectoryTagCheckedShort(tif, ndir, dir, tag,
1856 (uint16_t)value));
1857 else
1858 return (TIFFWriteDirectoryTagCheckedLong(tif, ndir, dir, tag, value));
1859}
1860
1861static int _WriteAsType(TIFF *tif, uint64_t strile_size,
1862 uint64_t uncompressed_threshold)
1863{
1864 const uint16_t compression = tif->tif_dir.td_compression;
1865 if (compression == COMPRESSION_NONE)
1866 {
1867 return strile_size > uncompressed_threshold;
1868 }
1869 else if (compression == COMPRESSION_JPEG ||
1870 compression == COMPRESSION_LZW ||
1871 compression == COMPRESSION_ADOBE_DEFLATE ||
1872 compression == COMPRESSION_DEFLATE ||
1873 compression == COMPRESSION_LZMA ||
1874 compression == COMPRESSION_LERC ||
1875 compression == COMPRESSION_ZSTD ||
1876 compression == COMPRESSION_WEBP || compression == COMPRESSION_JXL)
1877 {
1878 /* For a few select compression types, we assume that in the worst */
1879 /* case the compressed size will be 10 times the uncompressed size. */
1880 /* This is overly pessismistic ! */
1881 return strile_size >= uncompressed_threshold / 10;
1882 }
1883 return 1;
1884}
1885
1886static int WriteAsLong8(TIFF *tif, uint64_t strile_size)
1887{
1888 return _WriteAsType(tif, strile_size, 0xFFFFFFFFU);
1889}
1890
1891static int WriteAsLong4(TIFF *tif, uint64_t strile_size)
1892{
1893 return _WriteAsType(tif, strile_size, 0xFFFFU);
1894}
1895
1896/************************************************************************/
1897/* TIFFWriteDirectoryTagLongLong8Array() */
1898/* */
1899/* Write out LONG8 array and write a SHORT/LONG/LONG8 depending */
1900/* on strile size and Classic/BigTIFF mode. */
1901/************************************************************************/
1902
1903static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32_t *ndir,
1904 TIFFDirEntry *dir, uint16_t tag,
1905 uint32_t count, uint64_t *value)
1906{
1907 static const char module[] = "TIFFWriteDirectoryTagLongLong8Array";
1908 int o;
1909 int write_aslong4;
1910
1911 if (tif->tif_dir.td_deferstrilearraywriting)
1912 {
1913 if (dir == NULL)
1914 {
1915 /* This is just a counting pass to count IFD entries.
1916 * For deferstrilearraywriting no extra bytes will be written
1917 * into IFD space. */
1918 (*ndir)++;
1919 return 1;
1920 }
1921 return TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_NOTYPE, 0, 0,
1922 NULL);
1923 }
1924
1925 if (tif->tif_flags & TIFF_BIGTIFF)
1926 {
1927 int write_aslong8 = 1;
1928 /* In the case of ByteCounts array, we may be able to write them on LONG
1929 * if the strip/tilesize is not too big. Also do that for count > 1 in
1930 * the case someone would want to create a single-strip file with a
1931 * growing height, in which case using LONG8 will be safer. */
1932 if (count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS)
1933 {
1934 write_aslong8 = WriteAsLong8(tif, TIFFStripSize64(tif));
1935 }
1936 else if (count > 1 && tag == TIFFTAG_TILEBYTECOUNTS)
1937 {
1938 write_aslong8 = WriteAsLong8(tif, TIFFTileSize64(tif));
1939 }
1940 if (write_aslong8)
1941 {
1942 return TIFFWriteDirectoryTagCheckedLong8Array(tif, ndir, dir, tag,
1943 count, value);
1944 }
1945 }
1946
1947 write_aslong4 = 1;
1948 if (count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS)
1949 {
1950 write_aslong4 = WriteAsLong4(tif, TIFFStripSize64(tif));
1951 }
1952 else if (count > 1 && tag == TIFFTAG_TILEBYTECOUNTS)
1953 {
1954 write_aslong4 = WriteAsLong4(tif, TIFFTileSize64(tif));
1955 }
1956 if (write_aslong4)
1957 {
1958 /*
1959 ** For classic tiff we want to verify everything is in range for LONG
1960 ** and convert to long format.
1961 */
1962
1963 uint32_t *p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
1964 uint32_t *q;
1965 uint64_t *ma;
1966 uint32_t mb;
1967
1968 if (p == NULL)
1969 {
1970 TIFFErrorExtR(tif, module, "Out of memory");
1971 return (0);
1972 }
1973
1974 for (q = p, ma = value, mb = 0; mb < count; ma++, mb++, q++)
1975 {
1976 if (*ma > 0xFFFFFFFF)
1977 {
1978 TIFFErrorExtR(tif, module,
1979 "Attempt to write value larger than 0xFFFFFFFF "
1980 "in LONG array.");
1981 _TIFFfreeExt(tif, p);
1982 return (0);
1983 }
1984 *q = (uint32_t)(*ma);
1985 }
1986
1987 o = TIFFWriteDirectoryTagCheckedLongArray(tif, ndir, dir, tag, count,
1988 p);
1989 _TIFFfreeExt(tif, p);
1990 }
1991 else
1992 {
1993 uint16_t *p = _TIFFmallocExt(tif, count * sizeof(uint16_t));
1994 uint16_t *q;
1995 uint64_t *ma;
1996 uint32_t mb;
1997
1998 if (p == NULL)
1999 {
2000 TIFFErrorExtR(tif, module, "Out of memory");
2001 return (0);
2002 }
2003
2004 for (q = p, ma = value, mb = 0; mb < count; ma++, mb++, q++)
2005 {
2006 if (*ma > 0xFFFF)
2007 {
2008 /* Should not happen normally given the check we did before */
2009 TIFFErrorExtR(tif, module,
2010 "Attempt to write value larger than 0xFFFF in "
2011 "SHORT array.");
2012 _TIFFfreeExt(tif, p);
2013 return (0);
2014 }
2015 *q = (uint16_t)(*ma);
2016 }
2017
2018 o = TIFFWriteDirectoryTagCheckedShortArray(tif, ndir, dir, tag, count,
2019 p);
2020 _TIFFfreeExt(tif, p);
2021 }
2022
2023 return (o);
2024}
2025
2026/************************************************************************/
2027/* TIFFWriteDirectoryTagIfdIfd8Array() */
2028/* */
2029/* Write either IFD8 or IFD array depending on file type. */
2030/************************************************************************/
2031
2032static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF *tif, uint32_t *ndir,
2033 TIFFDirEntry *dir, uint16_t tag,
2034 uint32_t count, uint64_t *value)
2035{
2036 static const char module[] = "TIFFWriteDirectoryTagIfdIfd8Array";
2037 uint64_t *ma;
2038 uint32_t mb;
2039 uint32_t *p;
2040 uint32_t *q;
2041 int o;
2042
2043 /* We always write IFD8 for BigTIFF, no checking needed. */
2044 if (tif->tif_flags & TIFF_BIGTIFF)
2045 return TIFFWriteDirectoryTagCheckedIfd8Array(tif, ndir, dir, tag, count,
2046 value);
2047
2048 /*
2049 ** For classic tiff we want to verify everything is in range for IFD
2050 ** and convert to long format.
2051 */
2052
2053 p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
2054 if (p == NULL)
2055 {
2056 TIFFErrorExtR(tif, module, "Out of memory");
2057 return (0);
2058 }
2059
2060 for (q = p, ma = value, mb = 0; mb < count; ma++, mb++, q++)
2061 {
2062 if (*ma > 0xFFFFFFFF)
2063 {
2064 TIFFErrorExtR(tif, module,
2065 "Attempt to write value larger than 0xFFFFFFFF in "
2066 "Classic TIFF file.");
2067 _TIFFfreeExt(tif, p);
2068 return (0);
2069 }
2070 *q = (uint32_t)(*ma);
2071 }
2072
2073 o = TIFFWriteDirectoryTagCheckedIfdArray(tif, ndir, dir, tag, count, p);
2074 _TIFFfreeExt(tif, p);
2075
2076 return (o);
2077}
2078
2079/*
2080 * Auxiliary function to determine the IFD data size to be written to the file.
2081 * The IFD data size is finally the size of the IFD tag entries plus the IFD
2082 * data that is written directly after the IFD tag entries.
2083 */
2084static void EvaluateIFDdatasizeWrite(TIFF *tif, uint32_t count,
2085 uint32_t typesize, uint32_t *ndir)
2086{
2087 uint64_t datalength = (uint64_t)count * typesize;
2088 if (datalength > ((tif->tif_flags & TIFF_BIGTIFF) ? 0x8U : 0x4U))
2089 {
2090 /* LibTIFF increments write address to an even offset, thus datalength
2091 * written is also incremented. */
2092 if (datalength & 1)
2093 datalength++;
2094 tif->tif_dir.td_dirdatasize_write += datalength;
2095 }
2096 (*ndir)++;
2097}
2098
2099static int TIFFWriteDirectoryTagColormap(TIFF *tif, uint32_t *ndir,
2100 TIFFDirEntry *dir)
2101{
2102 static const char module[] = "TIFFWriteDirectoryTagColormap";
2103 uint32_t m;
2104 uint16_t *n;
2105 int o;
2106 m = (1 << tif->tif_dir.td_bitspersample);
2107 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2108 {
2109 EvaluateIFDdatasizeWrite(tif, 3 * m, sizeof(uint16_t), ndir);
2110 return 1;
2111 }
2112
2113 n = _TIFFmallocExt(tif, 3 * m * sizeof(uint16_t));
2114 if (n == NULL)
2115 {
2116 TIFFErrorExtR(tif, module, "Out of memory");
2117 return (0);
2118 }
2119 _TIFFmemcpy(&n[0], tif->tif_dir.td_colormap[0], m * sizeof(uint16_t));
2120 _TIFFmemcpy(&n[m], tif->tif_dir.td_colormap[1], m * sizeof(uint16_t));
2121 _TIFFmemcpy(&n[2 * m], tif->tif_dir.td_colormap[2], m * sizeof(uint16_t));
2122 o = TIFFWriteDirectoryTagCheckedShortArray(tif, ndir, dir, TIFFTAG_COLORMAP,
2123 3 * m, n);
2124 _TIFFfreeExt(tif, n);
2125 return (o);
2126}
2127
2128static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32_t *ndir,
2129 TIFFDirEntry *dir)
2130{
2131 static const char module[] = "TIFFWriteDirectoryTagTransferfunction";
2132 uint32_t m;
2133 uint16_t n;
2134 uint16_t *o;
2135 int p;
2136 /* TIFFTAG_TRANSFERFUNCTION expects (1 or 3) pointer to arrays with
2137 * (1 << BitsPerSample) * uint16_t values.
2138 */
2139 m = (1 << tif->tif_dir.td_bitspersample);
2140 /* clang-format off */
2141 n = (tif->tif_dir.td_samplesperpixel - tif->tif_dir.td_extrasamples) > 1 ? 3 : 1;
2142 /* clang-format on */
2143
2144 /* Check for proper number of transferfunctions */
2145 for (int i = 0; i < n; i++)
2146 {
2147 if (tif->tif_dir.td_transferfunction[i] == NULL)
2148 {
2149 TIFFWarningExtR(tif, module,
2150 "Too few TransferFunctions provided. Tag "
2151 "not written to file");
2152 return (1); /* Not an error; only tag is not written. */
2153 }
2154 }
2155 /*
2156 * Check if the table can be written as a single column,
2157 * or if it must be written as 3 columns. Note that we
2158 * write a 3-column tag if there are 2 samples/pixel and
2159 * a single column of data won't suffice--hmm.
2160 */
2161 if (n == 3)
2162 {
2163 if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],
2164 tif->tif_dir.td_transferfunction[2],
2165 m * sizeof(uint16_t)) &&
2166 !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],
2167 tif->tif_dir.td_transferfunction[1],
2168 m * sizeof(uint16_t)))
2169 n = 1;
2170 }
2171 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2172 {
2173 EvaluateIFDdatasizeWrite(tif, n * m, 2, ndir);
2174 return 1;
2175 }
2176
2177 o = _TIFFmallocExt(tif, n * m * sizeof(uint16_t));
2178 if (o == NULL)
2179 {
2180 TIFFErrorExtR(tif, module, "Out of memory");
2181 return (0);
2182 }
2183 _TIFFmemcpy(&o[0], tif->tif_dir.td_transferfunction[0],
2184 m * sizeof(uint16_t));
2185 if (n > 1)
2186 _TIFFmemcpy(&o[m], tif->tif_dir.td_transferfunction[1],
2187 m * sizeof(uint16_t));
2188 if (n > 2)
2189 _TIFFmemcpy(&o[2 * m], tif->tif_dir.td_transferfunction[2],
2190 m * sizeof(uint16_t));
2191 p = TIFFWriteDirectoryTagCheckedShortArray(
2192 tif, ndir, dir, TIFFTAG_TRANSFERFUNCTION, n * m, o);
2193 _TIFFfreeExt(tif, o);
2194 return (p);
2195}
2196
2197static int TIFFWriteDirectoryTagSubifd(TIFF *tif, uint32_t *ndir,
2198 TIFFDirEntry *dir)
2199{
2200 static const char module[] = "TIFFWriteDirectoryTagSubifd";
2201 uint64_t m;
2202 int n;
2203 if (tif->tif_dir.td_nsubifd == 0)
2204 return (1);
2205 m = tif->tif_dataoff;
2206 if (!(tif->tif_flags & TIFF_BIGTIFF))
2207 {
2208 uint32_t *o;
2209 uint64_t *pa;
2210 uint32_t *pb;
2211 uint16_t p;
2212 o = _TIFFmallocExt(tif, tif->tif_dir.td_nsubifd * sizeof(uint32_t));
2213 if (o == NULL)
2214 {
2215 TIFFErrorExtR(tif, module, "Out of memory");
2216 return (0);
2217 }
2218 pa = tif->tif_dir.td_subifd;
2219 pb = o;
2220 for (p = 0; p < tif->tif_dir.td_nsubifd; p++)
2221 {
2222 assert(pa != 0);
2223
2224 /* Could happen if an classicTIFF has a SubIFD of type LONG8 (which
2225 * is illegal) */
2226 if (*pa > 0xFFFFFFFFUL)
2227 {
2228 TIFFErrorExtR(tif, module, "Illegal value for SubIFD tag");
2229 _TIFFfreeExt(tif, o);
2230 return (0);
2231 }
2232 *pb++ = (uint32_t)(*pa++);
2233 }
2234 n = TIFFWriteDirectoryTagCheckedIfdArray(tif, ndir, dir, TIFFTAG_SUBIFD,
2235 tif->tif_dir.td_nsubifd, o);
2236 _TIFFfreeExt(tif, o);
2237 }
2238 else
2239 n = TIFFWriteDirectoryTagCheckedIfd8Array(
2240 tif, ndir, dir, TIFFTAG_SUBIFD, tif->tif_dir.td_nsubifd,
2241 tif->tif_dir.td_subifd);
2242
2243 if (dir == NULL)
2244 /* Just have evaluated IFD data size and incremented ndir
2245 * above in sub-functions. */
2246 return (n);
2247
2248 if (!n)
2249 return (0);
2250 /*
2251 * Total hack: if this directory includes a SubIFD
2252 * tag then force the next <n> directories to be
2253 * written as ``sub directories'' of this one. This
2254 * is used to write things like thumbnails and
2255 * image masks that one wants to keep out of the
2256 * normal directory linkage access mechanism.
2257 */
2258 tif->tif_flags |= TIFF_INSUBIFD;
2259 tif->tif_nsubifd = tif->tif_dir.td_nsubifd;
2260 if (tif->tif_dir.td_nsubifd == 1)
2261 tif->tif_subifdoff = 0;
2262 else
2263 tif->tif_subifdoff = m;
2264 return (1);
2265}
2266
2267static int TIFFWriteDirectoryTagCheckedAscii(TIFF *tif, uint32_t *ndir,
2268 TIFFDirEntry *dir, uint16_t tag,
2269 uint32_t count, char *value)
2270{
2271 assert(sizeof(char) == 1);
2272 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2273 {
2274 EvaluateIFDdatasizeWrite(tif, count, 1, ndir);
2275 return 1;
2276 }
2277 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_ASCII, count,
2278 count, value));
2279}
2280
2281static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF *tif, uint32_t *ndir,
2282 TIFFDirEntry *dir,
2283 uint16_t tag,
2284 uint32_t count,
2285 uint8_t *value)
2286{
2287 assert(sizeof(uint8_t) == 1);
2288 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2289 {
2290 EvaluateIFDdatasizeWrite(tif, count, 1, ndir);
2291 return 1;
2292 }
2293 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_UNDEFINED,
2294 count, count, value));
2295}
2296
2297static int TIFFWriteDirectoryTagCheckedByteArray(TIFF *tif, uint32_t *ndir,
2298 TIFFDirEntry *dir,
2299 uint16_t tag, uint32_t count,
2300 uint8_t *value)
2301{
2302 assert(sizeof(uint8_t) == 1);
2303 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2304 {
2305 EvaluateIFDdatasizeWrite(tif, count, 1, ndir);
2306 return 1;
2307 }
2308 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_BYTE, count,
2309 count, value));
2310}
2311
2312static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF *tif, uint32_t *ndir,
2313 TIFFDirEntry *dir,
2314 uint16_t tag, uint32_t count,
2315 int8_t *value)
2316{
2317 assert(sizeof(int8_t) == 1);
2318 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2319 {
2320 EvaluateIFDdatasizeWrite(tif, count, 1, ndir);
2321 return 1;
2322 }
2323 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SBYTE, count,
2324 count, value));
2325}
2326
2327static int TIFFWriteDirectoryTagCheckedShort(TIFF *tif, uint32_t *ndir,
2328 TIFFDirEntry *dir, uint16_t tag,
2329 uint16_t value)
2330{
2331 uint16_t m;
2332 assert(sizeof(uint16_t) == 2);
2333 if (dir == NULL)
2334 {
2335 /* No additional data to IFD data size just increment ndir. */
2336 (*ndir)++;
2337 return 1;
2338 }
2339 m = value;
2340 if (tif->tif_flags & TIFF_SWAB)
2341 TIFFSwabShort(&m);
2342 return (
2343 TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SHORT, 1, 2, &m));
2344}
2345
2346static int TIFFWriteDirectoryTagCheckedShortArray(TIFF *tif, uint32_t *ndir,
2347 TIFFDirEntry *dir,
2348 uint16_t tag, uint32_t count,
2349 uint16_t *value)
2350{
2351 assert(count < 0x80000000);
2352 assert(sizeof(uint16_t) == 2);
2353 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2354 {
2355 EvaluateIFDdatasizeWrite(tif, count, 2, ndir);
2356 return 1;
2357 }
2358 if (tif->tif_flags & TIFF_SWAB)
2359 TIFFSwabArrayOfShort(value, count);
2360 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SHORT, count,
2361 count * 2, value));
2362}
2363
2364static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF *tif, uint32_t *ndir,
2365 TIFFDirEntry *dir,
2366 uint16_t tag, uint32_t count,
2367 int16_t *value)
2368{
2369 assert(count < 0x80000000);
2370 assert(sizeof(int16_t) == 2);
2371 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2372 {
2373 EvaluateIFDdatasizeWrite(tif, count, 2, ndir);
2374 return 1;
2375 }
2376 if (tif->tif_flags & TIFF_SWAB)
2377 TIFFSwabArrayOfShort((uint16_t *)value, count);
2378 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SSHORT, count,
2379 count * 2, value));
2380}
2381
2382static int TIFFWriteDirectoryTagCheckedLong(TIFF *tif, uint32_t *ndir,
2383 TIFFDirEntry *dir, uint16_t tag,
2384 uint32_t value)
2385{
2386 uint32_t m;
2387 assert(sizeof(uint32_t) == 4);
2388 if (dir == NULL)
2389 {
2390 /* No additional data to IFD data size just increment ndir. */
2391 (*ndir)++;
2392 return 1;
2393 }
2394 m = value;
2395 if (tif->tif_flags & TIFF_SWAB)
2396 TIFFSwabLong(&m);
2397 return (
2398 TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_LONG, 1, 4, &m));
2399}
2400
2401static int TIFFWriteDirectoryTagCheckedLongArray(TIFF *tif, uint32_t *ndir,
2402 TIFFDirEntry *dir,
2403 uint16_t tag, uint32_t count,
2404 uint32_t *value)
2405{
2406 assert(count < 0x40000000);
2407 assert(sizeof(uint32_t) == 4);
2408 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2409 {
2410 EvaluateIFDdatasizeWrite(tif, count, 4, ndir);
2411 return 1;
2412 }
2413 if (tif->tif_flags & TIFF_SWAB)
2414 TIFFSwabArrayOfLong(value, count);
2415 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_LONG, count,
2416 count * 4, value));
2417}
2418
2419static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF *tif, uint32_t *ndir,
2420 TIFFDirEntry *dir,
2421 uint16_t tag, uint32_t count,
2422 int32_t *value)
2423{
2424 assert(count < 0x40000000);
2425 assert(sizeof(int32_t) == 4);
2426 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2427 {
2428 EvaluateIFDdatasizeWrite(tif, count, 4, ndir);
2429 return 1;
2430 }
2431 if (tif->tif_flags & TIFF_SWAB)
2432 TIFFSwabArrayOfLong((uint32_t *)value, count);
2433 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SLONG, count,
2434 count * 4, value));
2435}
2436
2437static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF *tif, uint32_t *ndir,
2438 TIFFDirEntry *dir,
2439 uint16_t tag, uint32_t count,
2440 uint64_t *value)
2441{
2442 assert(count < 0x20000000);
2443 assert(sizeof(uint64_t) == 8);
2444 if (!(tif->tif_flags & TIFF_BIGTIFF))
2445 {
2446 TIFFErrorExtR(tif, "TIFFWriteDirectoryTagCheckedLong8Array",
2447 "LONG8 not allowed for ClassicTIFF");
2448 return (0);
2449 }
2450 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2451 {
2452 EvaluateIFDdatasizeWrite(tif, count, 8, ndir);
2453 return 1;
2454 }
2455 if (tif->tif_flags & TIFF_SWAB)
2456 TIFFSwabArrayOfLong8(value, count);
2457 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_LONG8, count,
2458 count * 8, value));
2459}
2460
2461static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF *tif, uint32_t *ndir,
2462 TIFFDirEntry *dir,
2463 uint16_t tag, uint32_t count,
2464 int64_t *value)
2465{
2466 assert(count < 0x20000000);
2467 assert(sizeof(int64_t) == 8);
2468 if (!(tif->tif_flags & TIFF_BIGTIFF))
2469 {
2470 TIFFErrorExtR(tif, "TIFFWriteDirectoryTagCheckedSlong8Array",
2471 "SLONG8 not allowed for ClassicTIFF");
2472 return (0);
2473 }
2474 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2475 {
2476 EvaluateIFDdatasizeWrite(tif, count, 8, ndir);
2477 return 1;
2478 }
2479 if (tif->tif_flags & TIFF_SWAB)
2480 TIFFSwabArrayOfLong8((uint64_t *)value, count);
2481 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SLONG8, count,
2482 count * 8, value));
2483}
2484
2485static int TIFFWriteDirectoryTagCheckedRational(TIFF *tif, uint32_t *ndir,
2486 TIFFDirEntry *dir, uint16_t tag,
2487 double value)
2488{
2489 static const char module[] = "TIFFWriteDirectoryTagCheckedRational";
2490 uint32_t m[2];
2491 assert(sizeof(uint32_t) == 4);
2492 if (value < 0)
2493 {
2494 TIFFErrorExtR(tif, module, "Negative value is illegal");
2495 return 0;
2496 }
2497 else if (value != value)
2498 {
2499 TIFFErrorExtR(tif, module, "Not-a-number value is illegal");
2500 return 0;
2501 }
2502
2503 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2504 {
2505 tif->tif_dir.td_dirdatasize_write +=
2506 (tif->tif_flags & TIFF_BIGTIFF) ? 0 : 0x8U;
2507 (*ndir)++;
2508 return 1;
2509 }
2510
2511 DoubleToRational(value, &m[0], &m[1]);
2512
2513 if (tif->tif_flags & TIFF_SWAB)
2514 {
2515 TIFFSwabLong(&m[0]);
2516 TIFFSwabLong(&m[1]);
2517 }
2518 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_RATIONAL, 1, 8,
2519 &m[0]));
2520}
2521
2522static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32_t *ndir,
2523 TIFFDirEntry *dir,
2524 uint16_t tag,
2525 uint32_t count,
2526 float *value)
2527{
2528 static const char module[] = "TIFFWriteDirectoryTagCheckedRationalArray";
2529 uint32_t *m;
2530 float *na;
2531 uint32_t *nb;
2532 uint32_t nc;
2533 int o;
2534 assert(sizeof(uint32_t) == 4);
2535 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2536 {
2537 EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(uint32_t), ndir);
2538 return 1;
2539 }
2540 m = _TIFFmallocExt(tif, count * 2 * sizeof(uint32_t));
2541 if (m == NULL)
2542 {
2543 TIFFErrorExtR(tif, module, "Out of memory");
2544 return (0);
2545 }
2546 for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
2547 {
2548 DoubleToRational(*na, &nb[0], &nb[1]);
2549 }
2550 if (tif->tif_flags & TIFF_SWAB)
2551 TIFFSwabArrayOfLong(m, count * 2);
2552 o = TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_RATIONAL, count,
2553 count * 8, &m[0]);
2554 _TIFFfreeExt(tif, m);
2555 return (o);
2556}
2557
2558static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32_t *ndir,
2559 TIFFDirEntry *dir,
2560 uint16_t tag,
2561 uint32_t count,
2562 float *value)
2563{
2564 static const char module[] = "TIFFWriteDirectoryTagCheckedSrationalArray";
2565 int32_t *m;
2566 float *na;
2567 int32_t *nb;
2568 uint32_t nc;
2569 int o;
2570 assert(sizeof(int32_t) == 4);
2571 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2572 {
2573 EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(int32_t), ndir);
2574 return 1;
2575 }
2576 m = _TIFFmallocExt(tif, count * 2 * sizeof(int32_t));
2577 if (m == NULL)
2578 {
2579 TIFFErrorExtR(tif, module, "Out of memory");
2580 return (0);
2581 }
2582 for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
2583 {
2584 DoubleToSrational(*na, &nb[0], &nb[1]);
2585 }
2586 if (tif->tif_flags & TIFF_SWAB)
2587 TIFFSwabArrayOfLong((uint32_t *)m, count * 2);
2588 o = TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SRATIONAL, count,
2589 count * 8, &m[0]);
2590 _TIFFfreeExt(tif, m);
2591 return (o);
2592}
2593
2594/*-- Rational2Double: additional write functions for double arrays */
2595static int
2596TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF *tif, uint32_t *ndir,
2597 TIFFDirEntry *dir, uint16_t tag,
2598 uint32_t count, double *value)
2599{
2600 static const char module[] =
2601 "TIFFWriteDirectoryTagCheckedRationalDoubleArray";
2602 uint32_t *m;
2603 double *na;
2604 uint32_t *nb;
2605 uint32_t nc;
2606 int o;
2607 assert(sizeof(uint32_t) == 4);
2608 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2609 {
2610 EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(uint32_t), ndir);
2611 return 1;
2612 }
2613 m = _TIFFmallocExt(tif, count * 2 * sizeof(uint32_t));
2614 if (m == NULL)
2615 {
2616 TIFFErrorExtR(tif, module, "Out of memory");
2617 return (0);
2618 }
2619 for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
2620 {
2621 DoubleToRational(*na, &nb[0], &nb[1]);
2622 }
2623 if (tif->tif_flags & TIFF_SWAB)
2624 TIFFSwabArrayOfLong(m, count * 2);
2625 o = TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_RATIONAL, count,
2626 count * 8, &m[0]);
2627 _TIFFfreeExt(tif, m);
2628 return (o);
2629} /*-- TIFFWriteDirectoryTagCheckedRationalDoubleArray() ------- */
2630
2631static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(
2632 TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count,
2633 double *value)
2634{
2635 static const char module[] =
2636 "TIFFWriteDirectoryTagCheckedSrationalDoubleArray";
2637 int32_t *m;
2638 double *na;
2639 int32_t *nb;
2640 uint32_t nc;
2641 int o;
2642 assert(sizeof(int32_t) == 4);
2643 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2644 {
2645 EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(int32_t), ndir);
2646 return 1;
2647 }
2648 m = _TIFFmallocExt(tif, count * 2 * sizeof(int32_t));
2649 if (m == NULL)
2650 {
2651 TIFFErrorExtR(tif, module, "Out of memory");
2652 return (0);
2653 }
2654 for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
2655 {
2656 DoubleToSrational(*na, &nb[0], &nb[1]);
2657 }
2658 if (tif->tif_flags & TIFF_SWAB)
2659 TIFFSwabArrayOfLong((uint32_t *)m, count * 2);
2660 o = TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_SRATIONAL, count,
2661 count * 8, &m[0]);
2662 _TIFFfreeExt(tif, m);
2663 return (o);
2664} /*--- TIFFWriteDirectoryTagCheckedSrationalDoubleArray() -------- */
2665
2687static void ToRationalEuclideanGCD(double value, int blnUseSignedRange,
2688 int blnUseSmallRange, uint64_t *ullNum,
2689 uint64_t *ullDenom)
2690{
2691 /* Internally, the integer variables can be bigger than the external ones,
2692 * as long as the result will fit into the external variable size.
2693 */
2694 uint64_t numSum[3] = {0, 1, 0}, denomSum[3] = {1, 0, 0};
2695 uint64_t aux, bigNum, bigDenom;
2696 uint64_t returnLimit;
2697 int i;
2698 uint64_t nMax;
2699 double fMax;
2700 unsigned long maxDenom;
2701 /*-- nMax and fMax defines the initial accuracy of the starting fractional,
2702 * or better, the highest used integer numbers used within the starting
2703 * fractional (bigNum/bigDenom). There are two approaches, which can
2704 * accidentally lead to different accuracies just depending on the value.
2705 * Therefore, blnUseSmallRange steers this behavior.
2706 * For long long nMax = ((9223372036854775807-1)/2); for long nMax =
2707 * ((2147483647-1)/2);
2708 */
2709 if (blnUseSmallRange)
2710 {
2711 nMax = (uint64_t)((2147483647 - 1) / 2); /* for ULONG range */
2712 }
2713 else
2714 {
2715 nMax = ((9223372036854775807 - 1) / 2); /* for ULLONG range */
2716 }
2717 fMax = (double)nMax;
2718
2719 /*-- For the Euclidean GCD define the denominator range, so that it stays
2720 * within size of unsigned long variables. maxDenom should be LONG_MAX for
2721 * negative values and ULONG_MAX for positive ones. Also the final returned
2722 * value of ullNum and ullDenom is limited according to signed- or
2723 * unsigned-range.
2724 */
2725 if (blnUseSignedRange)
2726 {
2727 maxDenom = 2147483647UL; /*LONG_MAX = 0x7FFFFFFFUL*/
2728 returnLimit = maxDenom;
2729 }
2730 else
2731 {
2732 maxDenom = 0xFFFFFFFFUL; /*ULONG_MAX = 0xFFFFFFFFUL*/
2733 returnLimit = maxDenom;
2734 }
2735
2736 /*-- First generate a rational fraction (bigNum/bigDenom) which represents
2737 *the value as a rational number with the highest accuracy. Therefore,
2738 *uint64_t (uint64_t) is needed. This rational fraction is then reduced
2739 *using the Euclidean algorithm to find the greatest common divisor (GCD).
2740 * bigNum = big numinator of value without fraction (or cut residual
2741 *fraction) bigDenom = big denominator of value
2742 *-- Break-criteria so that uint64_t cast to "bigNum" introduces no error
2743 *and bigDenom has no overflow, and stop with enlargement of fraction when
2744 *the double-value of it reaches an integer number without fractional part.
2745 */
2746 bigDenom = 1;
2747 while ((value != floor(value)) && (value < fMax) && (bigDenom < nMax))
2748 {
2749 bigDenom <<= 1;
2750 value *= 2;
2751 }
2752 bigNum = (uint64_t)value;
2753
2754 /*-- Start Euclidean algorithm to find the greatest common divisor (GCD) --
2755 */
2756#define MAX_ITERATIONS 64
2757 for (i = 0; i < MAX_ITERATIONS; i++)
2758 {
2759 uint64_t val;
2760 /* if bigDenom is not zero, calculate integer part of fraction. */
2761 if (bigDenom == 0)
2762 {
2763 break;
2764 }
2765 val = bigNum / bigDenom;
2766
2767 /* Set bigDenom to reminder of bigNum/bigDenom and bigNum to previous
2768 * denominator bigDenom. */
2769 aux = bigNum;
2770 bigNum = bigDenom;
2771 bigDenom = aux % bigDenom;
2772
2773 /* calculate next denominator and check for its given maximum */
2774 aux = val;
2775 if (denomSum[1] * val + denomSum[0] >= maxDenom)
2776 {
2777 aux = (maxDenom - denomSum[0]) / denomSum[1];
2778 if (aux * 2 >= val || denomSum[1] >= maxDenom)
2779 i = (MAX_ITERATIONS +
2780 1); /* exit but execute rest of for-loop */
2781 else
2782 break;
2783 }
2784 /* calculate next numerator to numSum2 and save previous one to numSum0;
2785 * numSum1 just copy of numSum2. */
2786 numSum[2] = aux * numSum[1] + numSum[0];
2787 numSum[0] = numSum[1];
2788 numSum[1] = numSum[2];
2789 /* calculate next denominator to denomSum2 and save previous one to
2790 * denomSum0; denomSum1 just copy of denomSum2. */
2791 denomSum[2] = aux * denomSum[1] + denomSum[0];
2792 denomSum[0] = denomSum[1];
2793 denomSum[1] = denomSum[2];
2794 }
2795
2796 /*-- Check and adapt for final variable size and return values; reduces
2797 * internal accuracy; denominator is kept in ULONG-range with maxDenom -- */
2798 while (numSum[1] > returnLimit || denomSum[1] > returnLimit)
2799 {
2800 numSum[1] = numSum[1] / 2;
2801 denomSum[1] = denomSum[1] / 2;
2802 }
2803
2804 /* return values */
2805 *ullNum = numSum[1];
2806 *ullDenom = denomSum[1];
2807
2808} /*-- ToRationalEuclideanGCD() -------------- */
2809
2815static void DoubleToRational(double value, uint32_t *num, uint32_t *denom)
2816{
2817 /*---- UN-SIGNED RATIONAL ---- */
2818 double dblDiff, dblDiff2;
2819 uint64_t ullNum, ullDenom, ullNum2, ullDenom2;
2820
2821 /*-- Check for negative values. If so it is an error. */
2822 /* Test written that way to catch NaN */
2823 if (!(value >= 0))
2824 {
2825 *num = *denom = 0;
2826 TIFFErrorExt(0, "TIFFLib: DoubleToRational()",
2827 " Negative Value for Unsigned Rational given.");
2828 return;
2829 }
2830
2831 /*-- Check for too big numbers (> ULONG_MAX) -- */
2832 if (value > 0xFFFFFFFFUL)
2833 {
2834 *num = 0xFFFFFFFFU;
2835 *denom = 0;
2836 return;
2837 }
2838 /*-- Check for easy integer numbers -- */
2839 if (value == (uint32_t)(value))
2840 {
2841 *num = (uint32_t)value;
2842 *denom = 1;
2843 return;
2844 }
2845 /*-- Check for too small numbers for "unsigned long" type rationals -- */
2846 if (value < 1.0 / (double)0xFFFFFFFFUL)
2847 {
2848 *num = 0;
2849 *denom = 0xFFFFFFFFU;
2850 return;
2851 }
2852
2853 /*-- There are two approaches using the Euclidean algorithm,
2854 * which can accidentally lead to different accuracies just depending on
2855 * the value. Try both and define which one was better.
2856 */
2857 ToRationalEuclideanGCD(value, FALSE, FALSE, &ullNum, &ullDenom);
2858 ToRationalEuclideanGCD(value, FALSE, TRUE, &ullNum2, &ullDenom2);
2859 /*-- Double-Check, that returned values fit into ULONG :*/
2860 if (ullNum > 0xFFFFFFFFUL || ullDenom > 0xFFFFFFFFUL ||
2861 ullNum2 > 0xFFFFFFFFUL || ullDenom2 > 0xFFFFFFFFUL)
2862 {
2863 TIFFErrorExt(0, "TIFFLib: DoubleToRational()",
2864 " Num or Denom exceeds ULONG: val=%14.6f, num=%12" PRIu64
2865 ", denom=%12" PRIu64 " | num2=%12" PRIu64
2866 ", denom2=%12" PRIu64 "",
2867 value, ullNum, ullDenom, ullNum2, ullDenom2);
2868 assert(0);
2869 }
2870
2871 /* Check, which one has higher accuracy and take that. */
2872 dblDiff = fabs(value - ((double)ullNum / (double)ullDenom));
2873 dblDiff2 = fabs(value - ((double)ullNum2 / (double)ullDenom2));
2874 if (dblDiff < dblDiff2)
2875 {
2876 *num = (uint32_t)ullNum;
2877 *denom = (uint32_t)ullDenom;
2878 }
2879 else
2880 {
2881 *num = (uint32_t)ullNum2;
2882 *denom = (uint32_t)ullDenom2;
2883 }
2884} /*-- DoubleToRational() -------------- */
2885
2891static void DoubleToSrational(double value, int32_t *num, int32_t *denom)
2892{
2893 /*---- SIGNED RATIONAL ----*/
2894 int neg = 1;
2895 double dblDiff, dblDiff2;
2896 uint64_t ullNum, ullDenom, ullNum2, ullDenom2;
2897
2898 /*-- Check for negative values and use then the positive one for internal
2899 * calculations, but take the sign into account before returning. */
2900 if (value < 0)
2901 {
2902 neg = -1;
2903 value = -value;
2904 }
2905
2906 /*-- Check for too big numbers (> LONG_MAX) -- */
2907 if (value > 0x7FFFFFFFL)
2908 {
2909 *num = 0x7FFFFFFFL;
2910 *denom = 0;
2911 return;
2912 }
2913 /*-- Check for easy numbers -- */
2914 if (value == (int32_t)(value))
2915 {
2916 *num = (int32_t)(neg * value);
2917 *denom = 1;
2918 return;
2919 }
2920 /*-- Check for too small numbers for "long" type rationals -- */
2921 if (value < 1.0 / (double)0x7FFFFFFFL)
2922 {
2923 *num = 0;
2924 *denom = 0x7FFFFFFFL;
2925 return;
2926 }
2927
2928 /*-- There are two approaches using the Euclidean algorithm,
2929 * which can accidentally lead to different accuracies just depending on
2930 * the value. Try both and define which one was better. Furthermore, set
2931 * behavior of ToRationalEuclideanGCD() to the range of signed-long.
2932 */
2933 ToRationalEuclideanGCD(value, TRUE, FALSE, &ullNum, &ullDenom);
2934 ToRationalEuclideanGCD(value, TRUE, TRUE, &ullNum2, &ullDenom2);
2935 /*-- Double-Check, that returned values fit into LONG :*/
2936 if (ullNum > 0x7FFFFFFFL || ullDenom > 0x7FFFFFFFL ||
2937 ullNum2 > 0x7FFFFFFFL || ullDenom2 > 0x7FFFFFFFL)
2938 {
2939 TIFFErrorExt(0, "TIFFLib: DoubleToSrational()",
2940 " Num or Denom exceeds LONG: val=%14.6f, num=%12" PRIu64
2941 ", denom=%12" PRIu64 " | num2=%12" PRIu64
2942 ", denom2=%12" PRIu64 "",
2943 neg * value, ullNum, ullDenom, ullNum2, ullDenom2);
2944 assert(0);
2945 }
2946
2947 /* Check, which one has higher accuracy and take that. */
2948 dblDiff = fabs(value - ((double)ullNum / (double)ullDenom));
2949 dblDiff2 = fabs(value - ((double)ullNum2 / (double)ullDenom2));
2950 if (dblDiff < dblDiff2)
2951 {
2952 *num = (int32_t)(neg * (long)ullNum);
2953 *denom = (int32_t)ullDenom;
2954 }
2955 else
2956 {
2957 *num = (int32_t)(neg * (long)ullNum2);
2958 *denom = (int32_t)ullDenom2;
2959 }
2960} /*-- DoubleToSrational() --------------*/
2961
2962static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF *tif, uint32_t *ndir,
2963 TIFFDirEntry *dir,
2964 uint16_t tag, uint32_t count,
2965 float *value)
2966{
2967 assert(count < 0x40000000);
2968 assert(sizeof(float) == 4);
2969 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2970 {
2971 EvaluateIFDdatasizeWrite(tif, count, 4, ndir);
2972 return 1;
2973 }
2974 TIFFCvtNativeToIEEEFloat(tif, count, value);
2975 if (tif->tif_flags & TIFF_SWAB)
2976 TIFFSwabArrayOfFloat(value, count);
2977 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_FLOAT, count,
2978 count * 4, value));
2979}
2980
2981static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF *tif, uint32_t *ndir,
2982 TIFFDirEntry *dir,
2983 uint16_t tag, uint32_t count,
2984 double *value)
2985{
2986 assert(count < 0x20000000);
2987 assert(sizeof(double) == 8);
2988 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
2989 {
2990 EvaluateIFDdatasizeWrite(tif, count, 8, ndir);
2991 return 1;
2992 }
2993 TIFFCvtNativeToIEEEDouble(tif, count, value);
2994 if (tif->tif_flags & TIFF_SWAB)
2995 TIFFSwabArrayOfDouble(value, count);
2996 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_DOUBLE, count,
2997 count * 8, value));
2998}
2999
3000static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF *tif, uint32_t *ndir,
3001 TIFFDirEntry *dir, uint16_t tag,
3002 uint32_t count, uint32_t *value)
3003{
3004 assert(count < 0x40000000);
3005 assert(sizeof(uint32_t) == 4);
3006 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
3007 {
3008 EvaluateIFDdatasizeWrite(tif, count, 4, ndir);
3009 return 1;
3010 }
3011 if (tif->tif_flags & TIFF_SWAB)
3012 TIFFSwabArrayOfLong(value, count);
3013 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_IFD, count,
3014 count * 4, value));
3015}
3016
3017static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF *tif, uint32_t *ndir,
3018 TIFFDirEntry *dir,
3019 uint16_t tag, uint32_t count,
3020 uint64_t *value)
3021{
3022 assert(count < 0x20000000);
3023 assert(sizeof(uint64_t) == 8);
3024 assert(tif->tif_flags & TIFF_BIGTIFF);
3025 if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
3026 {
3027 EvaluateIFDdatasizeWrite(tif, count, 8, ndir);
3028 return 1;
3029 }
3030 if (tif->tif_flags & TIFF_SWAB)
3031 TIFFSwabArrayOfLong8(value, count);
3032 return (TIFFWriteDirectoryTagData(tif, ndir, dir, tag, TIFF_IFD8, count,
3033 count * 8, value));
3034}
3035
3036static int TIFFWriteDirectoryTagData(TIFF *tif, uint32_t *ndir,
3037 TIFFDirEntry *dir, uint16_t tag,
3038 uint16_t datatype, uint32_t count,
3039 uint32_t datalength, void *data)
3040{
3041 static const char module[] = "TIFFWriteDirectoryTagData";
3042 uint32_t m;
3043 m = 0;
3044 while (m < (*ndir))
3045 {
3046 assert(dir[m].tdir_tag != tag);
3047 if (dir[m].tdir_tag > tag)
3048 break;
3049 m++;
3050 }
3051 if (m < (*ndir))
3052 {
3053 uint32_t n;
3054 for (n = *ndir; n > m; n--)
3055 dir[n] = dir[n - 1];
3056 }
3057 dir[m].tdir_tag = tag;
3058 dir[m].tdir_type = datatype;
3059 dir[m].tdir_count = count;
3060 dir[m].tdir_offset.toff_long8 = 0;
3061 if (datalength <= ((tif->tif_flags & TIFF_BIGTIFF) ? 0x8U : 0x4U))
3062 {
3063 if (data && datalength)
3064 {
3065 _TIFFmemcpy(&dir[m].tdir_offset, data, datalength);
3066 }
3067 }
3068 else
3069 {
3070 uint64_t na, nb;
3071 na = tif->tif_dataoff;
3072 nb = na + datalength;
3073 if (!(tif->tif_flags & TIFF_BIGTIFF))
3074 nb = (uint32_t)nb;
3075 if ((nb < na) || (nb < datalength))
3076 {
3077 TIFFErrorExtR(tif, module, "Maximum TIFF file size exceeded");
3078 return (0);
3079 }
3080 if (!SeekOK(tif, na))
3081 {
3082 TIFFErrorExtR(tif, module, "IO error writing tag data");
3083 return (0);
3084 }
3085 if (datalength >= 0x80000000UL)
3086 {
3087 TIFFErrorExtR(tif, module,
3088 "libtiff does not allow writing more than 2147483647 "
3089 "bytes in a tag");
3090 return (0);
3091 }
3092 if (!WriteOK(tif, data, (tmsize_t)datalength))
3093 {
3094 TIFFErrorExtR(tif, module, "IO error writing tag data");
3095 return (0);
3096 }
3097 tif->tif_dataoff = nb;
3098 if (tif->tif_dataoff & 1)
3099 tif->tif_dataoff++;
3100 if (!(tif->tif_flags & TIFF_BIGTIFF))
3101 {
3102 uint32_t o;
3103 o = (uint32_t)na;
3104 if (tif->tif_flags & TIFF_SWAB)
3105 TIFFSwabLong(&o);
3106 _TIFFmemcpy(&dir[m].tdir_offset, &o, 4);
3107 }
3108 else
3109 {
3110 dir[m].tdir_offset.toff_long8 = na;
3111 if (tif->tif_flags & TIFF_SWAB)
3112 TIFFSwabLong8(&dir[m].tdir_offset.toff_long8);
3113 }
3114 }
3115 (*ndir)++;
3116 return (1);
3117}
3118
3119/*
3120 * Link the current directory into the directory chain for the file.
3121 */
3122static int TIFFLinkDirectory(TIFF *tif)
3123{
3124 static const char module[] = "TIFFLinkDirectory";
3125
3126 tif->tif_diroff = (TIFFSeekFile(tif, 0, SEEK_END) + 1) & (~((toff_t)1));
3127
3128 /*
3129 * Handle SubIFDs
3130 */
3131 if (tif->tif_flags & TIFF_INSUBIFD)
3132 {
3133 if (!(tif->tif_flags & TIFF_BIGTIFF))
3134 {
3135 uint32_t m;
3136 m = (uint32_t)tif->tif_diroff;
3137 if (tif->tif_flags & TIFF_SWAB)
3138 TIFFSwabLong(&m);
3139 (void)TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
3140 if (!WriteOK(tif, &m, 4))
3141 {
3142 TIFFErrorExtR(tif, module,
3143 "Error writing SubIFD directory link");
3144 return (0);
3145 }
3146
3147 /*
3148 * Advance to the next SubIFD or, if this is
3149 * the last one configured, reverting back to the
3150 * normal directory linkage is done in TIFFWriteDirectorySec()
3151 * by tif->tif_flags &= ~TIFF_INSUBIFD;.
3152 */
3153 if (--tif->tif_nsubifd)
3154 tif->tif_subifdoff += 4;
3155 return (1);
3156 }
3157 else
3158 {
3159 uint64_t m;
3160 m = tif->tif_diroff;
3161 if (tif->tif_flags & TIFF_SWAB)
3162 TIFFSwabLong8(&m);
3163 (void)TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
3164 if (!WriteOK(tif, &m, 8))
3165 {
3166 TIFFErrorExtR(tif, module,
3167 "Error writing SubIFD directory link");
3168 return (0);
3169 }
3170
3171 /*
3172 * Advance to the next SubIFD or, if this is
3173 * the last one configured, reverting back to the
3174 * normal directory linkage is done in TIFFWriteDirectorySec()
3175 * by tif->tif_flags &= ~TIFF_INSUBIFD;.
3176 */
3177 if (--tif->tif_nsubifd)
3178 tif->tif_subifdoff += 8;
3179 return (1);
3180 }
3181 }
3182
3183 /*
3184 * Handle main-IFDs
3185 */
3186 tdir_t ndir = 1; /* count current number of main-IFDs */
3187 if (!(tif->tif_flags & TIFF_BIGTIFF))
3188 {
3189 uint32_t m;
3190 uint32_t nextdir;
3191 m = (uint32_t)(tif->tif_diroff);
3192 if (tif->tif_flags & TIFF_SWAB)
3193 TIFFSwabLong(&m);
3194 if (tif->tif_header.classic.tiff_diroff == 0)
3195 {
3196 /*
3197 * First directory, overwrite offset in header.
3198 */
3199 tif->tif_header.classic.tiff_diroff = (uint32_t)tif->tif_diroff;
3200 tif->tif_lastdiroff = tif->tif_diroff;
3201 (void)TIFFSeekFile(tif, 4, SEEK_SET);
3202 if (!WriteOK(tif, &m, 4))
3203 {
3204 TIFFErrorExtR(tif, tif->tif_name, "Error writing TIFF header");
3205 return (0);
3206 }
3207 if (!tif->tif_dir.td_iswrittentofile)
3208 tif->tif_curdircount = 0;
3209 return (1);
3210 }
3211 /*
3212 * Not the first directory, search to the last and append.
3213 */
3214 tdir_t dirn = 0;
3215 if (tif->tif_lastdiroff != 0 &&
3216 _TIFFGetDirNumberFromOffset(tif, tif->tif_lastdiroff, &dirn))
3217 {
3218 /* Start searching from the lastely written IFD. Thus get its IFD
3219 * number. */
3220 nextdir = (uint32_t)tif->tif_lastdiroff;
3221 ndir = dirn + 1;
3222 }
3223 else
3224 {
3225 nextdir = tif->tif_header.classic.tiff_diroff;
3226 ndir = 1; /* start searching from the first IFD */
3227 }
3228
3229 while (1)
3230 {
3231 uint16_t dircount;
3232 uint32_t nextnextdir;
3233
3234 if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount, 2))
3235 {
3236 TIFFErrorExtR(tif, module, "Error fetching directory count");
3237 return (0);
3238 }
3239 if (tif->tif_flags & TIFF_SWAB)
3240 TIFFSwabShort(&dircount);
3241 (void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12, SEEK_SET);
3242 if (!ReadOK(tif, &nextnextdir, 4))
3243 {
3244 TIFFErrorExtR(tif, module, "Error fetching directory link");
3245 return (0);
3246 }
3247 if (tif->tif_flags & TIFF_SWAB)
3248 TIFFSwabLong(&nextnextdir);
3249 if (nextnextdir == 0)
3250 {
3251 (void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12, SEEK_SET);
3252 if (!WriteOK(tif, &m, 4))
3253 {
3254 TIFFErrorExtR(tif, module, "Error writing directory link");
3255 return (0);
3256 }
3257 tif->tif_lastdiroff = tif->tif_diroff;
3258 break;
3259 }
3260 nextdir = nextnextdir;
3261 ndir++;
3262 }
3263 }
3264 else
3265 {
3266 /*- BigTIFF -*/
3267 uint64_t m;
3268 uint64_t nextdir;
3269 m = tif->tif_diroff;
3270 if (tif->tif_flags & TIFF_SWAB)
3271 TIFFSwabLong8(&m);
3272 if (tif->tif_header.big.tiff_diroff == 0)
3273 {
3274 /*
3275 * First directory, overwrite offset in header.
3276 */
3277 tif->tif_header.big.tiff_diroff = tif->tif_diroff;
3278 tif->tif_lastdiroff = tif->tif_diroff;
3279 (void)TIFFSeekFile(tif, 8, SEEK_SET);
3280 if (!WriteOK(tif, &m, 8))
3281 {
3282 TIFFErrorExtR(tif, tif->tif_name, "Error writing TIFF header");
3283 return (0);
3284 }
3285 if (!tif->tif_dir.td_iswrittentofile)
3286 tif->tif_curdircount = 0;
3287 return (1);
3288 }
3289 /*
3290 * Not the first directory, search to the last and append.
3291 */
3292 tdir_t dirn = 0;
3293 if (tif->tif_lastdiroff != 0 &&
3294 _TIFFGetDirNumberFromOffset(tif, tif->tif_lastdiroff, &dirn))
3295 {
3296 /* Start searching from the lastely written IFD. Thus get its IFD
3297 * number. */
3298 nextdir = tif->tif_lastdiroff;
3299 ndir = dirn + 1;
3300 }
3301 else
3302 {
3303 nextdir = tif->tif_header.big.tiff_diroff;
3304 ndir = 1; /* start searching from the first IFD */
3305 }
3306 while (1)
3307 {
3308 uint64_t dircount64;
3309 uint16_t dircount;
3310 uint64_t nextnextdir;
3311
3312 if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount64, 8))
3313 {
3314 TIFFErrorExtR(tif, module, "Error fetching directory count");
3315 return (0);
3316 }
3317 if (tif->tif_flags & TIFF_SWAB)
3318 TIFFSwabLong8(&dircount64);
3319 if (dircount64 > 0xFFFF)
3320 {
3321 TIFFErrorExtR(tif, module,
3322 "Sanity check on tag count failed, "
3323 "likely corrupt TIFF");
3324 return (0);
3325 }
3326 dircount = (uint16_t)dircount64;
3327 (void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20, SEEK_SET);
3328 if (!ReadOK(tif, &nextnextdir, 8))
3329 {
3330 TIFFErrorExtR(tif, module, "Error fetching directory link");
3331 return (0);
3332 }
3333 if (tif->tif_flags & TIFF_SWAB)
3334 TIFFSwabLong8(&nextnextdir);
3335 if (nextnextdir == 0)
3336 {
3337 (void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20, SEEK_SET);
3338 if (!WriteOK(tif, &m, 8))
3339 {
3340 TIFFErrorExtR(tif, module, "Error writing directory link");
3341 return (0);
3342 }
3343 tif->tif_lastdiroff = tif->tif_diroff;
3344 break;
3345 }
3346 nextdir = nextnextdir;
3347 ndir++;
3348 }
3349 }
3350 /* Offset of next IFD is written to file.
3351 * Update number of main-IFDs in file.
3352 * However, tif_curdircount shall count only newly written main-IFDs with
3353 * entries and not only number of linked offsets! Thus, tif_curdircount is
3354 * incremented at the end of TIFFWriteDirectorySec().
3355 * TIFF_NON_EXISTENT_DIR_NUMBER means 'dont know number of IFDs'
3356 * 0 means 'empty file opened for writing, but no IFD written yet' */
3357 if (!tif->tif_dir.td_iswrittentofile && !(tif->tif_flags & TIFF_INSUBIFD))
3358 {
3359 tif->tif_curdircount = ndir;
3360 }
3361 return (1);
3362}
3363
3364/************************************************************************/
3365/* TIFFRewriteField() */
3366/* */
3367/* Rewrite a field in the directory on disk without regard to */
3368/* updating the TIFF directory structure in memory. Currently */
3369/* only supported for field that already exist in the on-disk */
3370/* directory. Mainly used for updating stripoffset / */
3371/* stripbytecount values after the directory is already on */
3372/* disk. */
3373/* */
3374/* Returns zero on failure, and one on success. */
3375/************************************************************************/
3376
3377int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
3378 tmsize_t count, void *data)
3379{
3380 static const char module[] = "TIFFResetField";
3381 /* const TIFFField* fip = NULL; */
3382 uint16_t dircount;
3383 tmsize_t dirsize;
3384 uint8_t direntry_raw[20];
3385 uint16_t entry_tag = 0;
3386 uint16_t entry_type = 0;
3387 uint64_t entry_count = 0;
3388 uint64_t entry_offset = 0;
3389 int value_in_entry = 0;
3390 uint64_t read_offset;
3391 uint8_t *buf_to_write = NULL;
3392 TIFFDataType datatype;
3393
3394 /* -------------------------------------------------------------------- */
3395 /* Find field definition. */
3396 /* -------------------------------------------------------------------- */
3397 /*fip =*/TIFFFindField(tif, tag, TIFF_ANY);
3398
3399 /* -------------------------------------------------------------------- */
3400 /* Do some checking this is a straight forward case. */
3401 /* -------------------------------------------------------------------- */
3402 if (isMapped(tif))
3403 {
3404 TIFFErrorExtR(tif, module,
3405 "Memory mapped files not currently supported for "
3406 "this operation.");
3407 return 0;
3408 }
3409
3410 if (tif->tif_diroff == 0)
3411 {
3412 TIFFErrorExtR(
3413 tif, module,
3414 "Attempt to reset field on directory not already on disk.");
3415 return 0;
3416 }
3417
3418 /* -------------------------------------------------------------------- */
3419 /* Read the directory entry count. */
3420 /* -------------------------------------------------------------------- */
3421 if (!SeekOK(tif, tif->tif_diroff))
3422 {
3423 TIFFErrorExtR(tif, module, "%s: Seek error accessing TIFF directory",
3424 tif->tif_name);
3425 return 0;
3426 }
3427
3428 read_offset = tif->tif_diroff;
3429
3430 if (!(tif->tif_flags & TIFF_BIGTIFF))
3431 {
3432 if (!ReadOK(tif, &dircount, sizeof(uint16_t)))
3433 {
3434 TIFFErrorExtR(tif, module, "%s: Can not read TIFF directory count",
3435 tif->tif_name);
3436 return 0;
3437 }
3438 if (tif->tif_flags & TIFF_SWAB)
3439 TIFFSwabShort(&dircount);
3440 dirsize = 12;
3441 read_offset += 2;
3442 }
3443 else
3444 {
3445 uint64_t dircount64;
3446 if (!ReadOK(tif, &dircount64, sizeof(uint64_t)))
3447 {
3448 TIFFErrorExtR(tif, module, "%s: Can not read TIFF directory count",
3449 tif->tif_name);
3450 return 0;
3451 }
3452 if (tif->tif_flags & TIFF_SWAB)
3453 TIFFSwabLong8(&dircount64);
3454 dircount = (uint16_t)dircount64;
3455 dirsize = 20;
3456 read_offset += 8;
3457 }
3458
3459 /* -------------------------------------------------------------------- */
3460 /* Read through directory to find target tag. */
3461 /* -------------------------------------------------------------------- */
3462 while (dircount > 0)
3463 {
3464 if (!ReadOK(tif, direntry_raw, dirsize))
3465 {
3466 TIFFErrorExtR(tif, module, "%s: Can not read TIFF directory entry.",
3467 tif->tif_name);
3468 return 0;
3469 }
3470
3471 memcpy(&entry_tag, direntry_raw + 0, sizeof(uint16_t));
3472 if (tif->tif_flags & TIFF_SWAB)
3473 TIFFSwabShort(&entry_tag);
3474
3475 if (entry_tag == tag)
3476 break;
3477
3478 read_offset += dirsize;
3479 }
3480
3481 if (entry_tag != tag)
3482 {
3483 TIFFErrorExtR(tif, module, "%s: Could not find tag %" PRIu16 ".",
3484 tif->tif_name, tag);
3485 return 0;
3486 }
3487
3488 /* -------------------------------------------------------------------- */
3489 /* Extract the type, count and offset for this entry. */
3490 /* -------------------------------------------------------------------- */
3491 memcpy(&entry_type, direntry_raw + 2, sizeof(uint16_t));
3492 if (tif->tif_flags & TIFF_SWAB)
3493 TIFFSwabShort(&entry_type);
3494
3495 if (!(tif->tif_flags & TIFF_BIGTIFF))
3496 {
3497 uint32_t value;
3498
3499 memcpy(&value, direntry_raw + 4, sizeof(uint32_t));
3500 if (tif->tif_flags & TIFF_SWAB)
3501 TIFFSwabLong(&value);
3502 entry_count = value;
3503
3504 memcpy(&value, direntry_raw + 8, sizeof(uint32_t));
3505 if (tif->tif_flags & TIFF_SWAB)
3506 TIFFSwabLong(&value);
3507 entry_offset = value;
3508 }
3509 else
3510 {
3511 memcpy(&entry_count, direntry_raw + 4, sizeof(uint64_t));
3512 if (tif->tif_flags & TIFF_SWAB)
3513 TIFFSwabLong8(&entry_count);
3514
3515 memcpy(&entry_offset, direntry_raw + 12, sizeof(uint64_t));
3516 if (tif->tif_flags & TIFF_SWAB)
3517 TIFFSwabLong8(&entry_offset);
3518 }
3519
3520 /* -------------------------------------------------------------------- */
3521 /* When a dummy tag was written due to TIFFDeferStrileArrayWriting() */
3522 /* -------------------------------------------------------------------- */
3523 if (entry_offset == 0 && entry_count == 0 && entry_type == 0)
3524 {
3525 if (tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS)
3526 {
3527 entry_type =
3528 (tif->tif_flags & TIFF_BIGTIFF) ? TIFF_LONG8 : TIFF_LONG;
3529 }
3530 else
3531 {
3532 int write_aslong8 = 1;
3533 if (count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS)
3534 {
3535 write_aslong8 = WriteAsLong8(tif, TIFFStripSize64(tif));
3536 }
3537 else if (count > 1 && tag == TIFFTAG_TILEBYTECOUNTS)
3538 {
3539 write_aslong8 = WriteAsLong8(tif, TIFFTileSize64(tif));
3540 }
3541 if (write_aslong8)
3542 {
3543 entry_type = TIFF_LONG8;
3544 }
3545 else
3546 {
3547 int write_aslong4 = 1;
3548 if (count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS)
3549 {
3550 write_aslong4 = WriteAsLong4(tif, TIFFStripSize64(tif));
3551 }
3552 else if (count > 1 && tag == TIFFTAG_TILEBYTECOUNTS)
3553 {
3554 write_aslong4 = WriteAsLong4(tif, TIFFTileSize64(tif));
3555 }
3556 if (write_aslong4)
3557 {
3558 entry_type = TIFF_LONG;
3559 }
3560 else
3561 {
3562 entry_type = TIFF_SHORT;
3563 }
3564 }
3565 }
3566 }
3567
3568 /* -------------------------------------------------------------------- */
3569 /* What data type do we want to write this as? */
3570 /* -------------------------------------------------------------------- */
3571 if (TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags & TIFF_BIGTIFF))
3572 {
3573 if (in_datatype == TIFF_LONG8)
3574 datatype = entry_type == TIFF_SHORT ? TIFF_SHORT : TIFF_LONG;
3575 else if (in_datatype == TIFF_SLONG8)
3576 datatype = TIFF_SLONG;
3577 else if (in_datatype == TIFF_IFD8)
3578 datatype = TIFF_IFD;
3579 else
3580 datatype = in_datatype;
3581 }
3582 else
3583 {
3584 if (in_datatype == TIFF_LONG8 &&
3585 (entry_type == TIFF_SHORT || entry_type == TIFF_LONG ||
3586 entry_type == TIFF_LONG8))
3587 datatype = entry_type;
3588 else if (in_datatype == TIFF_SLONG8 &&
3589 (entry_type == TIFF_SLONG || entry_type == TIFF_SLONG8))
3590 datatype = entry_type;
3591 else if (in_datatype == TIFF_IFD8 &&
3592 (entry_type == TIFF_IFD || entry_type == TIFF_IFD8))
3593 datatype = entry_type;
3594 else
3595 datatype = in_datatype;
3596 }
3597
3598 /* -------------------------------------------------------------------- */
3599 /* Prepare buffer of actual data to write. This includes */
3600 /* swabbing as needed. */
3601 /* -------------------------------------------------------------------- */
3602 buf_to_write = (uint8_t *)_TIFFCheckMalloc(
3603 tif, count, TIFFDataWidth(datatype), "for field buffer.");
3604 if (!buf_to_write)
3605 return 0;
3606
3607 if (datatype == in_datatype)
3608 memcpy(buf_to_write, data, count * TIFFDataWidth(datatype));
3609 else if (datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8)
3610 {
3611 tmsize_t i;
3612
3613 for (i = 0; i < count; i++)
3614 {
3615 ((int32_t *)buf_to_write)[i] = (int32_t)((int64_t *)data)[i];
3616 if ((int64_t)((int32_t *)buf_to_write)[i] != ((int64_t *)data)[i])
3617 {
3618 _TIFFfreeExt(tif, buf_to_write);
3619 TIFFErrorExtR(tif, module,
3620 "Value exceeds 32bit range of output type.");
3621 return 0;
3622 }
3623 }
3624 }
3625 else if ((datatype == TIFF_LONG && in_datatype == TIFF_LONG8) ||
3626 (datatype == TIFF_IFD && in_datatype == TIFF_IFD8))
3627 {
3628 tmsize_t i;
3629
3630 for (i = 0; i < count; i++)
3631 {
3632 ((uint32_t *)buf_to_write)[i] = (uint32_t)((uint64_t *)data)[i];
3633 if ((uint64_t)((uint32_t *)buf_to_write)[i] !=
3634 ((uint64_t *)data)[i])
3635 {
3636 _TIFFfreeExt(tif, buf_to_write);
3637 TIFFErrorExtR(tif, module,
3638 "Value exceeds 32bit range of output type.");
3639 return 0;
3640 }
3641 }
3642 }
3643 else if (datatype == TIFF_SHORT && in_datatype == TIFF_LONG8)
3644 {
3645 tmsize_t i;
3646
3647 for (i = 0; i < count; i++)
3648 {
3649 ((uint16_t *)buf_to_write)[i] = (uint16_t)((uint64_t *)data)[i];
3650 if ((uint64_t)((uint16_t *)buf_to_write)[i] !=
3651 ((uint64_t *)data)[i])
3652 {
3653 _TIFFfreeExt(tif, buf_to_write);
3654 TIFFErrorExtR(tif, module,
3655 "Value exceeds 16bit range of output type.");
3656 return 0;
3657 }
3658 }
3659 }
3660 else
3661 {
3662 TIFFErrorExtR(tif, module, "Unhandled type conversion.");
3663 return 0;
3664 }
3665
3666 if (TIFFDataWidth(datatype) > 1 && (tif->tif_flags & TIFF_SWAB))
3667 {
3668 if (TIFFDataWidth(datatype) == 2)
3669 TIFFSwabArrayOfShort((uint16_t *)buf_to_write, count);
3670 else if (TIFFDataWidth(datatype) == 4)
3671 TIFFSwabArrayOfLong((uint32_t *)buf_to_write, count);
3672 else if (TIFFDataWidth(datatype) == 8)
3673 TIFFSwabArrayOfLong8((uint64_t *)buf_to_write, count);
3674 }
3675
3676 /* -------------------------------------------------------------------- */
3677 /* Is this a value that fits into the directory entry? */
3678 /* -------------------------------------------------------------------- */
3679 if (!(tif->tif_flags & TIFF_BIGTIFF))
3680 {
3681 if (TIFFDataWidth(datatype) * count <= 4)
3682 {
3683 entry_offset = read_offset + 8;
3684 value_in_entry = 1;
3685 }
3686 }
3687 else
3688 {
3689 if (TIFFDataWidth(datatype) * count <= 8)
3690 {
3691 entry_offset = read_offset + 12;
3692 value_in_entry = 1;
3693 }
3694 }
3695
3696 if ((tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS) &&
3697 tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
3698 tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
3699 tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0)
3700 {
3701 tif->tif_dir.td_stripoffset_entry.tdir_type = datatype;
3702 tif->tif_dir.td_stripoffset_entry.tdir_count = count;
3703 }
3704 else if ((tag == TIFFTAG_TILEBYTECOUNTS ||
3705 tag == TIFFTAG_STRIPBYTECOUNTS) &&
3706 tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
3707 tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
3708 tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0)
3709 {
3710 tif->tif_dir.td_stripbytecount_entry.tdir_type = datatype;
3711 tif->tif_dir.td_stripbytecount_entry.tdir_count = count;
3712 }
3713
3714 /* -------------------------------------------------------------------- */
3715 /* If the tag type, and count match, then we just write it out */
3716 /* over the old values without altering the directory entry at */
3717 /* all. */
3718 /* -------------------------------------------------------------------- */
3719 if (entry_count == (uint64_t)count && entry_type == (uint16_t)datatype)
3720 {
3721 if (!SeekOK(tif, entry_offset))
3722 {
3723 _TIFFfreeExt(tif, buf_to_write);
3724 TIFFErrorExtR(tif, module,
3725 "%s: Seek error accessing TIFF directory",
3726 tif->tif_name);
3727 return 0;
3728 }
3729 if (!WriteOK(tif, buf_to_write, count * TIFFDataWidth(datatype)))
3730 {
3731 _TIFFfreeExt(tif, buf_to_write);
3732 TIFFErrorExtR(tif, module, "Error writing directory link");
3733 return (0);
3734 }
3735
3736 _TIFFfreeExt(tif, buf_to_write);
3737 return 1;
3738 }
3739
3740 /* -------------------------------------------------------------------- */
3741 /* Otherwise, we write the new tag data at the end of the file. */
3742 /* -------------------------------------------------------------------- */
3743 if (!value_in_entry)
3744 {
3745 entry_offset = TIFFSeekFile(tif, 0, SEEK_END);
3746
3747 if (!WriteOK(tif, buf_to_write, count * TIFFDataWidth(datatype)))
3748 {
3749 _TIFFfreeExt(tif, buf_to_write);
3750 TIFFErrorExtR(tif, module, "Error writing directory link");
3751 return (0);
3752 }
3753 }
3754 else
3755 {
3756 if (count * TIFFDataWidth(datatype) == 4)
3757 {
3758 uint32_t value;
3759 memcpy(&value, buf_to_write, count * TIFFDataWidth(datatype));
3760 entry_offset = value;
3761 }
3762 else
3763 {
3764 memcpy(&entry_offset, buf_to_write,
3765 count * TIFFDataWidth(datatype));
3766 }
3767 }
3768
3769 _TIFFfreeExt(tif, buf_to_write);
3770 buf_to_write = 0;
3771
3772 /* -------------------------------------------------------------------- */
3773 /* Adjust the directory entry. */
3774 /* -------------------------------------------------------------------- */
3775 entry_type = datatype;
3776 entry_count = (uint64_t)count;
3777 memcpy(direntry_raw + 2, &entry_type, sizeof(uint16_t));
3778 if (tif->tif_flags & TIFF_SWAB)
3779 TIFFSwabShort((uint16_t *)(direntry_raw + 2));
3780
3781 if (!(tif->tif_flags & TIFF_BIGTIFF))
3782 {
3783 uint32_t value;
3784
3785 value = (uint32_t)entry_count;
3786 memcpy(direntry_raw + 4, &value, sizeof(uint32_t));
3787 if (tif->tif_flags & TIFF_SWAB)
3788 TIFFSwabLong((uint32_t *)(direntry_raw + 4));
3789
3790 value = (uint32_t)entry_offset;
3791 memcpy(direntry_raw + 8, &value, sizeof(uint32_t));
3792 if (tif->tif_flags & TIFF_SWAB)
3793 TIFFSwabLong((uint32_t *)(direntry_raw + 8));
3794 }
3795 else
3796 {
3797 memcpy(direntry_raw + 4, &entry_count, sizeof(uint64_t));
3798 if (tif->tif_flags & TIFF_SWAB)
3799 TIFFSwabLong8((uint64_t *)(direntry_raw + 4));
3800
3801 memcpy(direntry_raw + 12, &entry_offset, sizeof(uint64_t));
3802 if (tif->tif_flags & TIFF_SWAB)
3803 TIFFSwabLong8((uint64_t *)(direntry_raw + 12));
3804 }
3805
3806 /* -------------------------------------------------------------------- */
3807 /* Write the directory entry out to disk. */
3808 /* -------------------------------------------------------------------- */
3809 if (!SeekOK(tif, read_offset))
3810 {
3811 TIFFErrorExtR(tif, module, "%s: Seek error accessing TIFF directory",
3812 tif->tif_name);
3813 return 0;
3814 }
3815
3816 if (!WriteOK(tif, direntry_raw, dirsize))
3817 {
3818 TIFFErrorExtR(tif, module, "%s: Can not write TIFF directory entry.",
3819 tif->tif_name);
3820 return 0;
3821 }
3822
3823 return 1;
3824}
dir
unsigned int dir
Definition: maze.c:112
ok
#define ok(value,...)
Definition: atltest.h:57
compression
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t compression
Definition: btrfs_drv.h:1365
SEEK_END
#define SEEK_END
Definition: cabinet.c:29
fMax
double fMax(double a, double b)
Definition: cardcolor.cpp:12
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
int32_t
INT32 int32_t
Definition: types.h:71
uint32_t
UINT32 uint32_t
Definition: types.h:75
int16_t
INT16 int16_t
Definition: types.h:70
uint64_t
UINT64 uint64_t
Definition: types.h:77
int64_t
INT64 int64_t
Definition: types.h:72
assert
#define assert(_expr)
Definition: assert.h:32
O_RDONLY
#define O_RDONLY
Definition: fcntl.h:34
PRIu16
#define PRIu16
Definition: inttypes.h:83
PRIu32
#define PRIu32
Definition: inttypes.h:84
PRIi64
#define PRIi64
Definition: inttypes.h:26
PRIx64
#define PRIx64
Definition: inttypes.h:29
PRIu64
#define PRIu64
Definition: inttypes.h:28
fabs
_ACRTIMP double __cdecl fabs(double)
floor
_ACRTIMP double __cdecl floor(double)
Definition: floor.c:18
uint16_t
unsigned short uint16_t
Definition: stdint.h:35
uint8_t
unsigned char uint8_t
Definition: stdint.h:33
int8_t
signed char int8_t
Definition: stdint.h:32
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1592
switch
switch(r->id)
Definition: btrfs.c:3046
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
q
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
n
GLdouble n
Definition: glext.h:7729
val
GLuint GLfloat * val
Definition: glext.h:7180
p
GLfloat GLfloat p
Definition: glext.h:8902
num
GLuint GLuint num
Definition: glext.h:9618
m
const GLfloat * m
Definition: glext.h:10848
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
SEEK_SET
#define SEEK_SET
Definition: jmemansi.c:26
if
if(dx< 0)
Definition: linetemp.h:194
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
double
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:91
pa
static int ** pa
Definition: server.c:145
uint32_t
#define uint32_t
Definition: nsiface.idl:61
uint64_t
#define uint64_t
Definition: nsiface.idl:62
int32_t
#define int32_t
Definition: nsiface.idl:56
uint16_t
#define uint16_t
Definition: nsiface.idl:60
TIFFDirEntry::tdir_count
uint64_t tdir_count
Definition: tif_dir.h:57
TIFFDirEntry::tdir_type
uint16_t tdir_type
Definition: tif_dir.h:56
TIFFDirEntry::tdir_offset
union TIFFDirEntry::@3701 tdir_offset
TIFFDirEntry::toff_long8
uint64_t toff_long8
Definition: tif_dir.h:62
TIFFDirEntry::tdir_tag
uint16_t tdir_tag
Definition: tif_dir.h:55
TIFFDirectory::td_customValueCount
int td_customValueCount
Definition: tif_dir.h:142
TIFFDirectory::td_pagenumber
uint16_t td_pagenumber[2]
Definition: tif_dir.h:102
TIFFDirectory::td_xposition
float td_xposition
Definition: tif_dir.h:101
TIFFDirectory::td_tiledepth
uint32_t td_tiledepth
Definition: tif_dir.h:84
TIFFDirectory::td_fillorder
uint16_t td_fillorder
Definition: tif_dir.h:91
TIFFDirectory::td_xresolution
float td_xresolution
Definition: tif_dir.h:98
TIFFDirectory::td_dirdatasize_read
uint64_t td_dirdatasize_read
Definition: tif_dir.h:157
TIFFDirectory::td_inknameslen
int td_inknameslen
Definition: tif_dir.h:138
TIFFDirectory::td_refblackwhite
float * td_refblackwhite
Definition: tif_dir.h:136
TIFFDirectory::td_rowsperstrip
uint32_t td_rowsperstrip
Definition: tif_dir.h:94
TIFFDirectory::td_imagewidth
uint32_t td_imagewidth
Definition: tif_dir.h:83
TIFFDirectory::td_compression
uint16_t td_compression
Definition: tif_dir.h:88
TIFFDirectory::td_photometric
uint16_t td_photometric
Definition: tif_dir.h:89
TIFFDirectory::td_tilewidth
uint32_t td_tilewidth
Definition: tif_dir.h:84
TIFFDirectory::td_yresolution
float td_yresolution
Definition: tif_dir.h:98
TIFFDirectory::td_extrasamples
uint16_t td_extrasamples
Definition: tif_dir.h:105
TIFFDirectory::td_threshholding
uint16_t td_threshholding
Definition: tif_dir.h:90
TIFFDirectory::td_minsamplevalue
uint16_t td_minsamplevalue
Definition: tif_dir.h:95
TIFFDirectory::td_sminsamplevalue
double * td_sminsamplevalue
Definition: tif_dir.h:96
TIFFDirectory::td_bitspersample
uint16_t td_bitspersample
Definition: tif_dir.h:86
TIFFDirectory::td_inknames
char * td_inknames
Definition: tif_dir.h:139
TIFFDirectory::td_stripoffset_entry
TIFFDirEntry td_stripoffset_entry
Definition: tif_dir.h:127
TIFFDirectory::td_transferfunction
uint16_t * td_transferfunction[3]
Definition: tif_dir.h:135
TIFFDirectory::td_maxsamplevalue
uint16_t td_maxsamplevalue
Definition: tif_dir.h:95
TIFFDirectory::td_imagedepth
uint32_t td_imagedepth
Definition: tif_dir.h:83
TIFFDirectory::td_orientation
uint16_t td_orientation
Definition: tif_dir.h:92
TIFFDirectory::td_resolutionunit
uint16_t td_resolutionunit
Definition: tif_dir.h:99
TIFFDirectory::td_planarconfig
uint16_t td_planarconfig
Definition: tif_dir.h:100
TIFFDirectory::td_customValues
TIFFTagValue * td_customValues
Definition: tif_dir.h:143
TIFFDirectory::td_smaxsamplevalue
double * td_smaxsamplevalue
Definition: tif_dir.h:97
TIFFDirectory::td_stripbytecount_p
uint64_t * td_stripbytecount_p
Definition: tif_dir.h:114
TIFFDirectory::td_iswrittentofile
unsigned char td_iswrittentofile
Definition: tif_dir.h:149
TIFFDirectory::td_stripoffset_p
uint64_t * td_stripoffset_p
Definition: tif_dir.h:113
TIFFDirectory::td_colormap
uint16_t * td_colormap[3]
Definition: tif_dir.h:103
TIFFDirectory::td_sampleformat
uint16_t td_sampleformat
Definition: tif_dir.h:87
TIFFDirectory::td_ycbcrsubsampling
uint16_t td_ycbcrsubsampling[2]
Definition: tif_dir.h:132
TIFFDirectory::td_dirdatasize_write
uint64_t td_dirdatasize_write
Definition: tif_dir.h:155
TIFFDirectory::td_deferstrilearraywriting
unsigned char td_deferstrilearraywriting
Definition: tif_dir.h:146
TIFFDirectory::td_samplesperpixel
uint16_t td_samplesperpixel
Definition: tif_dir.h:93
TIFFDirectory::td_subfiletype
uint32_t td_subfiletype
Definition: tif_dir.h:85
TIFFDirectory::td_nstrips
uint32_t td_nstrips
Definition: tif_dir.h:111
TIFFDirectory::td_numberofinks
uint16_t td_numberofinks
Definition: tif_dir.h:140
TIFFDirectory::td_stripbytecount_entry
TIFFDirEntry td_stripbytecount_entry
Definition: tif_dir.h:128
TIFFDirectory::td_imagelength
uint32_t td_imagelength
Definition: tif_dir.h:83
TIFFDirectory::td_tilelength
uint32_t td_tilelength
Definition: tif_dir.h:84
TIFFDirectory::td_nsubifd
uint16_t td_nsubifd
Definition: tif_dir.h:129
TIFFDirectory::td_subifd
uint64_t * td_subifd
Definition: tif_dir.h:130
TIFFDirectory::td_yposition
float td_yposition
Definition: tif_dir.h:101
TIFFDirectory::td_ycbcrpositioning
uint16_t td_ycbcrpositioning
Definition: tif_dir.h:133
TIFFDirectory::td_halftonehints
uint16_t td_halftonehints[2]
Definition: tif_dir.h:104
TIFFHeaderBig::tiff_diroff
uint64_t tiff_diroff
Definition: tiff.h:122
TIFFHeaderClassic::tiff_diroff
uint32_t tiff_diroff
Definition: tiff.h:114
TIFFTagValue::value
void * value
Definition: tif_dir.h:39
TIFFTagValue::count
int count
Definition: tif_dir.h:38
TIFFTagValue::info
const TIFFField * info
Definition: tif_dir.h:37
_TIFFField
Definition: tif_dir.h:331
_TIFFField::field_type
TIFFDataType field_type
Definition: tif_dir.h:335
_TIFFField::field_passcount
unsigned char field_passcount
Definition: tif_dir.h:342
_TIFFField::field_name
char * field_name
Definition: tif_dir.h:343
_TIFFField::field_bit
unsigned short field_bit
Definition: tif_dir.h:340
_TIFFField::field_tag
uint32_t field_tag
Definition: tif_dir.h:332
_TIFFField::field_readcount
short field_readcount
Definition: tif_dir.h:333
_TIFFField::set_get_field_type
TIFFSetGetFieldType set_get_field_type
Definition: tif_dir.h:338
tag
Definition: ecma_167.h:138
tiff
Definition: tiffiop.h:113
tiff::tif_subifdoff
uint64_t tif_subifdoff
Definition: tiffiop.h:191
tiff::tif_curdircount
tdir_t tif_curdircount
Definition: tiffiop.h:183
tiff::tif_nsubifd
uint16_t tif_nsubifd
Definition: tiffiop.h:190
tiff::tif_rawdataloaded
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:223
tiff::tif_rawcc
tmsize_t tif_rawcc
Definition: tiffiop.h:225
tiff::tif_nfields
size_t tif_nfields
Definition: tiffiop.h:242
tiff::tif_nextdiroff
uint64_t tif_nextdiroff
Definition: tiffiop.h:151
tiff::tif_fields
TIFFField ** tif_fields
Definition: tiffiop.h:241
tiff::tif_diroff
uint64_t tif_diroff
Definition: tiffiop.h:150
tiff::tif_name
char * tif_name
Definition: tiffiop.h:114
tiff::tif_dir
TIFFDirectory tif_dir
Definition: tiffiop.h:157
tiff::tif_postencode
TIFFBoolMethod tif_postencode
Definition: tiffiop.h:204
tiff::tif_close
TIFFVoidMethod tif_close
Definition: tiffiop.h:211
tiff::tif_dataoff
uint64_t tif_dataoff
Definition: tiffiop.h:188
tiff::tif_curdir
tdir_t tif_curdir
Definition: tiffiop.h:179
tiff::tif_rawcp
uint8_t * tif_rawcp
Definition: tiffiop.h:224
tiff::tif_rawdata
uint8_t * tif_rawdata
Definition: tiffiop.h:220
tiff::tif_header
TIFFHeaderUnion tif_header
Definition: tiffiop.h:160
tiff::tif_rawdatasize
tmsize_t tif_rawdatasize
Definition: tiffiop.h:221
tiff::tif_rawdataoff
tmsize_t tif_rawdataoff
Definition: tiffiop.h:222
tiff::tif_flags
uint32_t tif_flags
Definition: tiffiop.h:117
tiff::tif_lastdiroff
uint64_t tif_lastdiroff
Definition: tiffiop.h:152
tiff::tif_mode
int tif_mode
Definition: tiffiop.h:116
TIFFGetFieldDefaulted
int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag,...)
Definition: tif_aux.c:380
_TIFFCheckMalloc
void * _TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:122
_TIFFClampDoubleToFloat
float _TIFFClampDoubleToFloat(double val)
Definition: tif_aux.c:391
TIFFNumberOfDirectories
tdir_t TIFFNumberOfDirectories(TIFF *tif)
Definition: tif_dir.c:2032
TIFFFreeDirectory
void TIFFFreeDirectory(TIFF *tif)
Definition: tif_dir.c:1619
TIFFCreateDirectory
int TIFFCreateDirectory(TIFF *tif)
Definition: tif_dir.c:1689
TIFFGetField
int TIFFGetField(TIFF *tif, uint32_t tag,...)
Definition: tif_dir.c:1582
FIELD_RESOLUTION
#define FIELD_RESOLUTION
Definition: tif_dir.h:183
FIELD_CODEC
#define FIELD_CODEC
Definition: tif_dir.h:220
FIELD_SUBFILETYPE
#define FIELD_SUBFILETYPE
Definition: tif_dir.h:187
FIELD_STRIPOFFSETS
#define FIELD_STRIPOFFSETS
Definition: tif_dir.h:202
FIELD_TRANSFERFUNCTION
#define FIELD_TRANSFERFUNCTION
Definition: tif_dir.h:214
FIELD_HALFTONEHINTS
#define FIELD_HALFTONEHINTS
Definition: tif_dir.h:210
FIELD_ORIENTATION
#define FIELD_ORIENTATION
Definition: tif_dir.h:193
FIELD_MINSAMPLEVALUE
#define FIELD_MINSAMPLEVALUE
Definition: tif_dir.h:196
FIELD_FILLORDER
#define FIELD_FILLORDER
Definition: tif_dir.h:192
FIELD_SMAXSAMPLEVALUE
#define FIELD_SMAXSAMPLEVALUE
Definition: tif_dir.h:207
FIELD_IMAGEDIMENSIONS
#define FIELD_IMAGEDIMENSIONS
Definition: tif_dir.h:181
FIELD_YCBCRSUBSAMPLING
#define FIELD_YCBCRSUBSAMPLING
Definition: tif_dir.h:211
FIELD_COLORMAP
#define FIELD_COLORMAP
Definition: tif_dir.h:203
FIELD_SUBIFD
#define FIELD_SUBIFD
Definition: tif_dir.h:216
FIELD_EXTRASAMPLES
#define FIELD_EXTRASAMPLES
Definition: tif_dir.h:204
FIELD_IMAGEDEPTH
#define FIELD_IMAGEDEPTH
Definition: tif_dir.h:208
FIELD_SMINSAMPLEVALUE
#define FIELD_SMINSAMPLEVALUE
Definition: tif_dir.h:206
TIFFFieldSet
#define TIFFFieldSet(tif, field)
Definition: tif_dir.h:236
FIELD_MAXSAMPLEVALUE
#define FIELD_MAXSAMPLEVALUE
Definition: tif_dir.h:197
FIELD_NUMBEROFINKS
#define FIELD_NUMBEROFINKS
Definition: tif_dir.h:217
FIELD_TILEDEPTH
#define FIELD_TILEDEPTH
Definition: tif_dir.h:209
FIELD_TILEDIMENSIONS
#define FIELD_TILEDIMENSIONS
Definition: tif_dir.h:182
FIELD_POSITION
#define FIELD_POSITION
Definition: tif_dir.h:184
FIELD_ROWSPERSTRIP
#define FIELD_ROWSPERSTRIP
Definition: tif_dir.h:195
FIELD_COMPRESSION
#define FIELD_COMPRESSION
Definition: tif_dir.h:189
FIELD_STRIPBYTECOUNTS
#define FIELD_STRIPBYTECOUNTS
Definition: tif_dir.h:201
FIELD_YCBCRPOSITIONING
#define FIELD_YCBCRPOSITIONING
Definition: tif_dir.h:212
FIELD_REFBLACKWHITE
#define FIELD_REFBLACKWHITE
Definition: tif_dir.h:213
FIELD_SAMPLEFORMAT
#define FIELD_SAMPLEFORMAT
Definition: tif_dir.h:205
FIELD_PAGENUMBER
#define FIELD_PAGENUMBER
Definition: tif_dir.h:200
FIELD_BITSPERSAMPLE
#define FIELD_BITSPERSAMPLE
Definition: tif_dir.h:188
TIFF_SETGET_C32_UINT8
@ TIFF_SETGET_C32_UINT8
Definition: tif_dir.h:285
TIFF_SETGET_UINT16
@ TIFF_SETGET_UINT16
Definition: tif_dir.h:249
TIFF_SETGET_ASCII
@ TIFF_SETGET_ASCII
Definition: tif_dir.h:246
TIFF_SETGET_UINT32
@ TIFF_SETGET_UINT32
Definition: tif_dir.h:251
FIELD_INKNAMES
#define FIELD_INKNAMES
Definition: tif_dir.h:215
FIELD_RESOLUTIONUNIT
#define FIELD_RESOLUTIONUNIT
Definition: tif_dir.h:199
FIELD_PLANARCONFIG
#define FIELD_PLANARCONFIG
Definition: tif_dir.h:198
FIELD_SAMPLESPERPIXEL
#define FIELD_SAMPLESPERPIXEL
Definition: tif_dir.h:194
FIELD_PHOTOMETRIC
#define FIELD_PHOTOMETRIC
Definition: tif_dir.h:190
FIELD_THRESHHOLDING
#define FIELD_THRESHHOLDING
Definition: tif_dir.h:191
TIFFDataWidth
int TIFFDataWidth(TIFFDataType type)
Definition: tif_dirinfo.c:637
TIFFFieldTag
uint32_t TIFFFieldTag(const TIFFField *fip)
Definition: tif_dirinfo.c:867
TIFFFindField
const TIFFField * TIFFFindField(TIFF *tif, uint32_t tag, TIFFDataType dt)
Definition: tif_dirinfo.c:795
TIFFFieldSetGetSize
int TIFFFieldSetGetSize(const TIFFField *fip)
Definition: tif_dirinfo.c:673
_TIFFRemoveEntryFromDirectoryListByOffset
int _TIFFRemoveEntryFromDirectoryListByOffset(TIFF *tif, uint64_t diroff)
Definition: tif_dirread.c:5900
_TIFFCheckDirNumberAndOffset
int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
Definition: tif_dirread.c:5665
_TIFFGetDirNumberFromOffset
int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff, tdir_t *dirn)
Definition: tif_dirread.c:5828
_TIFFFillStriles
int _TIFFFillStriles(TIFF *tif)
Definition: tif_dirread.c:8381
TIFFWriteDirectoryTagShortLong
static int TIFFWriteDirectoryTagShortLong(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t value)
Definition: tif_dirwrite.c:1850
TIFFCheckpointDirectory
int TIFFCheckpointDirectory(TIFF *tif)
Definition: tif_dirwrite.c:292
TIFFWriteDirectoryTagCheckedSlongArray
static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int32_t *value)
Definition: tif_dirwrite.c:2419
MAX_ITERATIONS
#define MAX_ITERATIONS
TIFFLinkDirectory
static int TIFFLinkDirectory(TIFF *)
Definition: tif_dirwrite.c:3122
TIFFWriteDirectoryTagSlongArray
static int TIFFWriteDirectoryTagSlongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int32_t *value)
Definition: tif_dirwrite.c:1643
TIFFWriteDirectoryTagLong
static int TIFFWriteDirectoryTagLong(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t value)
Definition: tif_dirwrite.c:1628
TIFFClampDoubleToUInt16
static uint16_t TIFFClampDoubleToUInt16(double val)
Definition: tif_dirwrite.c:1440
TIFFWriteDirectoryTagSbyteArray
static int TIFFWriteDirectoryTagSbyteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int8_t *value)
Definition: tif_dirwrite.c:1568
TIFFWriteDirectoryTagRationalDoubleArray
static int TIFFWriteDirectoryTagRationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1806
TIFFWriteDirectoryTagAscii
static int TIFFWriteDirectoryTagAscii(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, char *value)
Definition: tif_dirwrite.c:1544
_WriteAsType
static int _WriteAsType(TIFF *tif, uint64_t strile_size, uint64_t uncompressed_threshold)
Definition: tif_dirwrite.c:1861
TIFFWriteDirectoryTagIfdArray
static int TIFFWriteDirectoryTagIfdArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:1842
TIFFWriteDirectoryTagCheckedDoubleArray
static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:2981
TIFFCvtNativeToIEEEDouble
void TIFFCvtNativeToIEEEDouble(TIFF *tif, uint32_t n, double *dp)
TIFFWriteDirectoryTagCheckedLong
static int TIFFWriteDirectoryTagCheckedLong(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t value)
Definition: tif_dirwrite.c:2382
TIFFRewriteDirectorySec
static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone, uint64_t *pdiroff)
Definition: tif_dirwrite.c:315
TIFFWriteDirectoryTagCheckedRationalArray
static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:2522
EvaluateIFDdatasizeWrite
static void EvaluateIFDdatasizeWrite(TIFF *tif, uint32_t count, uint32_t typesize, uint32_t *ndir)
Definition: tif_dirwrite.c:2084
DoubleToSrational
static void DoubleToSrational(double value, int32_t *num, int32_t *denom)
Definition: tif_dirwrite.c:2891
TIFFWriteDirectoryTagCheckedAscii
static int TIFFWriteDirectoryTagCheckedAscii(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, char *value)
Definition: tif_dirwrite.c:2267
TIFFWriteDirectoryTagSrationalDoubleArray
static int TIFFWriteDirectoryTagSrationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1816
TIFFWriteDirectoryTagCheckedSbyteArray
static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int8_t *value)
Definition: tif_dirwrite.c:2312
TIFFWriteDirectoryTagCheckedUndefinedArray
static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:2281
TIFFWriteDirectoryTagCheckedShort
static int TIFFWriteDirectoryTagCheckedShort(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t value)
Definition: tif_dirwrite.c:2327
TIFFWriteDirectoryTagDoubleArray
static int TIFFWriteDirectoryTagDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1834
TIFFWriteDirectoryTagLongArray
static int TIFFWriteDirectoryTagLongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:1635
TIFFWriteDirectoryTagSlong8Array
static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int64_t *value)
Definition: tif_dirwrite.c:1717
TIFFWriteDirectoryTagCheckedByteArray
static int TIFFWriteDirectoryTagCheckedByteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:2297
TIFFWriteDirectoryTagColormap
static int TIFFWriteDirectoryTagColormap(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2099
TIFFWriteDirectoryTagTransferfunction
static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2128
TIFFWriteDirectoryTagCheckedIfdArray
static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:3000
TIFFWriteDirectoryTagSrationalArray
static int TIFFWriteDirectoryTagSrationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:1797
TIFFWriteDirectoryTagCheckedSlong8Array
static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int64_t *value)
Definition: tif_dirwrite.c:2461
TIFFClampDoubleToInt32
static int32_t TIFFClampDoubleToInt32(double val)
Definition: tif_dirwrite.c:1422
TIFFWriteDirectoryTagCheckedSrationalArray
static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:2558
TIFFWriteDirectoryTagByteArray
static int TIFFWriteDirectoryTagByteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:1560
TIFFClampDoubleToInt8
static int8_t TIFFClampDoubleToInt8(double val)
Definition: tif_dirwrite.c:1404
TIFFWriteDirectoryTagCheckedShortArray
static int TIFFWriteDirectoryTagCheckedShortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint16_t *value)
Definition: tif_dirwrite.c:2346
TIFFWriteDirectoryTagData
static int TIFFWriteDirectoryTagData(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t datatype, uint32_t count, uint32_t datalength, void *data)
Definition: tif_dirwrite.c:3036
WriteAsLong4
static int WriteAsLong4(TIFF *tif, uint64_t strile_size)
Definition: tif_dirwrite.c:1891
TIFFWriteDirectoryTagCheckedRational
static int TIFFWriteDirectoryTagCheckedRational(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, double value)
Definition: tif_dirwrite.c:2485
TIFFWriteDirectoryTagRationalArray
static int TIFFWriteDirectoryTagRationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:1789
TIFFWriteDirectoryTagSampleformatArray
static int TIFFWriteDirectoryTagSampleformatArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1458
TIFFWriteDirectoryTagCheckedLong8Array
static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:2437
DoubleToRational
static void DoubleToRational(double value, uint32_t *num, uint32_t *denom)
Definition: tif_dirwrite.c:2815
_TIFFRewriteField
int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype, tmsize_t count, void *data)
Definition: tif_dirwrite.c:3377
TIFFWriteDirectoryTagIfdIfd8Array
static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:2032
TIFFWriteDirectoryTagFloatArray
static int TIFFWriteDirectoryTagFloatArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:1826
TIFFWriteDirectoryTagLongLong8Array
static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:1903
TIFFRewriteDirectory
int TIFFRewriteDirectory(TIFF *tif)
Definition: tif_dirwrite.c:483
TIFFClampDoubleToUInt32
static uint32_t TIFFClampDoubleToUInt32(double val)
Definition: tif_dirwrite.c:1449
TIFFWriteDirectoryTagSshortArray
static int TIFFWriteDirectoryTagSshortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int16_t *value)
Definition: tif_dirwrite.c:1620
ToRationalEuclideanGCD
static void ToRationalEuclideanGCD(double value, int blnUseSignedRange, int blnUseSmallRange, uint64_t *ullNum, uint64_t *ullDenom)
Definition: tif_dirwrite.c:2687
WriteAsLong8
static int WriteAsLong8(TIFF *tif, uint64_t strile_size)
Definition: tif_dirwrite.c:1886
TIFFDeferStrileArrayWriting
int TIFFDeferStrileArrayWriting(TIFF *tif)
Definition: tif_dirwrite.c:268
TIFFWriteDirectorySec
static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone, uint64_t *pdiroff)
Definition: tif_dirwrite.c:488
TIFFWriteDirectoryTagShortArray
static int TIFFWriteDirectoryTagShortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint16_t *value)
Definition: tif_dirwrite.c:1583
TIFFWriteDirectoryTagCheckedFloatArray
static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:2962
TIFFWriteDirectoryTagShortPerSample
static int TIFFWriteDirectoryTagShortPerSample(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t value)
Definition: tif_dirwrite.c:1591
TIFFWriteDirectoryTagCheckedSshortArray
static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int16_t *value)
Definition: tif_dirwrite.c:2364
TIFFWriteDirectoryTagUndefinedArray
static int TIFFWriteDirectoryTagUndefinedArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:1552
TIFFWriteDirectoryTagCheckedIfd8Array
static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:3017
TIFFWriteDirectoryTagCheckedRationalDoubleArray
static int TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:2596
TIFFWriteDirectoryTagCheckedSrationalDoubleArray
static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:2631
TIFFWriteDirectoryTagShort
static int TIFFWriteDirectoryTagShort(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t value)
Definition: tif_dirwrite.c:1576
TIFFWriteDirectory
int TIFFWriteDirectory(TIFF *tif)
Definition: tif_dirwrite.c:238
TIFFWriteDirectoryTagLong8Array
static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:1656
TIFFCvtNativeToIEEEFloat
void TIFFCvtNativeToIEEEFloat(TIFF *tif, uint32_t n, float *fp)
TIFFWriteDirectoryTagCheckedLongArray
static int TIFFWriteDirectoryTagCheckedLongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:2401
TIFFClampDoubleToInt16
static int16_t TIFFClampDoubleToInt16(double val)
Definition: tif_dirwrite.c:1413
TIFFWriteDirectoryTagRational
static int TIFFWriteDirectoryTagRational(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, double value)
Definition: tif_dirwrite.c:1782
TIFFWriteDirectoryTagSubifd
static int TIFFWriteDirectoryTagSubifd(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2197
TIFFWriteCustomDirectory
int TIFFWriteCustomDirectory(TIFF *tif, uint64_t *pdiroff)
Definition: tif_dirwrite.c:303
TIFFClampDoubleToUInt8
static uint8_t TIFFClampDoubleToUInt8(double val)
Definition: tif_dirwrite.c:1431
TIFFErrorExt
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
TIFFErrorExtR
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_error.c:107
_TIFFfreeExt
void _TIFFfreeExt(TIFF *tif, void *p)
Definition: tif_open.c:275
_TIFFmallocExt
void * _TIFFmallocExt(TIFF *tif, tmsize_t s)
Definition: tif_open.c:173
TIFFStripSize64
uint64_t TIFFStripSize64(TIFF *tif)
Definition: tif_strip.c:196
TIFFSwabArrayOfLong
void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
Definition: tif_swab.c:117
TIFFSwabArrayOfFloat
void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
Definition: tif_swab.c:180
TIFFSwabArrayOfDouble
void TIFFSwabArrayOfDouble(double *dp, tmsize_t n)
Definition: tif_swab.c:222
TIFFSwabLong8
void TIFFSwabLong8(uint64_t *lp)
Definition: tif_swab.c:60
TIFFSwabShort
void TIFFSwabShort(uint16_t *wp)
Definition: tif_swab.c:33
TIFFSwabArrayOfLong8
void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
Definition: tif_swab.c:138
TIFFSwabLong
void TIFFSwabLong(uint32_t *lp)
Definition: tif_swab.c:45
TIFFSwabArrayOfShort
void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
Definition: tif_swab.c:81
TIFFTileSize64
uint64_t TIFFTileSize64(TIFF *tif)
Definition: tif_tile.c:249
_TIFFmemcmp
int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
Definition: tif_unix.c:360
_TIFFmemcpy
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
Definition: tif_unix.c:355
TIFFWarningExtR
void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_warning.c:80
TIFFSetWriteOffset
void TIFFSetWriteOffset(TIFF *tif, toff_t off)
Definition: tif_write.c:961
TIFFFlushData1
int TIFFFlushData1(TIFF *tif)
Definition: tif_write.c:931
TIFFSetupStrips
int TIFFSetupStrips(TIFF *tif)
Definition: tif_write.c:553
COMPRESSION_NONE
#define COMPRESSION_NONE
Definition: tiff.h:182
TIFFTAG_BITSPERSAMPLE
#define TIFFTAG_BITSPERSAMPLE
Definition: tiff.h:180
TIFFTAG_RESOLUTIONUNIT
#define TIFFTAG_RESOLUTIONUNIT
Definition: tiff.h:287
COMPRESSION_ZSTD
#define COMPRESSION_ZSTD
Definition: tiff.h:216
TIFFTAG_SUBIFD
#define TIFFTAG_SUBIFD
Definition: tiff.h:321
TIFFTAG_FILLORDER
#define TIFFTAG_FILLORDER
Definition: tiff.h:240
TIFFTAG_SAMPLESPERPIXEL
#define TIFFTAG_SAMPLESPERPIXEL
Definition: tiff.h:257
COMPRESSION_DEFLATE
#define COMPRESSION_DEFLATE
Definition: tiff.h:205
COMPRESSION_JXL
#define COMPRESSION_JXL
Definition: tiff.h:218
TIFFTAG_YPOSITION
#define TIFFTAG_YPOSITION
Definition: tiff.h:269
SAMPLEFORMAT_UINT
#define SAMPLEFORMAT_UINT
Definition: tiff.h:334
TIFFTAG_COLORMAP
#define TIFFTAG_COLORMAP
Definition: tiff.h:309
TIFFDataType
TIFFDataType
Definition: tiff.h:146
TIFF_SSHORT
@ TIFF_SSHORT
Definition: tiff.h:155
TIFF_SLONG
@ TIFF_SLONG
Definition: tiff.h:156
TIFF_BYTE
@ TIFF_BYTE
Definition: tiff.h:148
TIFF_SBYTE
@ TIFF_SBYTE
Definition: tiff.h:153
TIFF_IFD
@ TIFF_IFD
Definition: tiff.h:160
TIFF_SHORT
@ TIFF_SHORT
Definition: tiff.h:150
TIFF_UNDEFINED
@ TIFF_UNDEFINED
Definition: tiff.h:154
TIFF_LONG
@ TIFF_LONG
Definition: tiff.h:151
TIFF_SLONG8
@ TIFF_SLONG8
Definition: tiff.h:162
TIFF_LONG8
@ TIFF_LONG8
Definition: tiff.h:161
TIFF_ASCII
@ TIFF_ASCII
Definition: tiff.h:149
TIFF_NOTYPE
@ TIFF_NOTYPE
Definition: tiff.h:147
TIFF_FLOAT
@ TIFF_FLOAT
Definition: tiff.h:158
TIFF_DOUBLE
@ TIFF_DOUBLE
Definition: tiff.h:159
TIFF_IFD8
@ TIFF_IFD8
Definition: tiff.h:163
TIFF_SRATIONAL
@ TIFF_SRATIONAL
Definition: tiff.h:157
TIFF_RATIONAL
@ TIFF_RATIONAL
Definition: tiff.h:152
TIFFTAG_IMAGEDEPTH
#define TIFFTAG_IMAGEDEPTH
Definition: tiff.h:407
TIFFTAG_PHOTOMETRIC
#define TIFFTAG_PHOTOMETRIC
Definition: tiff.h:220
TIFFTAG_TILELENGTH
#define TIFFTAG_TILELENGTH
Definition: tiff.h:312
TIFFTAG_MAXSAMPLEVALUE
#define TIFFTAG_MAXSAMPLEVALUE
Definition: tiff.h:261
TIFFTAG_TILEDEPTH
#define TIFFTAG_TILEDEPTH
Definition: tiff.h:408
COMPRESSION_LZMA
#define COMPRESSION_LZMA
Definition: tiff.h:215
TIFFTAG_EXTRASAMPLES
#define TIFFTAG_EXTRASAMPLES
Definition: tiff.h:329
TIFFTAG_IMAGEWIDTH
#define TIFFTAG_IMAGEWIDTH
Definition: tiff.h:178
COMPRESSION_WEBP
#define COMPRESSION_WEBP
Definition: tiff.h:217
TIFFTAG_XRESOLUTION
#define TIFFTAG_XRESOLUTION
Definition: tiff.h:262
COMPRESSION_LERC
#define COMPRESSION_LERC
Definition: tiff.h:213
TIFFTAG_ORIENTATION
#define TIFFTAG_ORIENTATION
Definition: tiff.h:248
COMPRESSION_ADOBE_DEFLATE
#define COMPRESSION_ADOBE_DEFLATE
Definition: tiff.h:206
TIFFTAG_HALFTONEHINTS
#define TIFFTAG_HALFTONEHINTS
Definition: tiff.h:310
TIFFTAG_MINSAMPLEVALUE
#define TIFFTAG_MINSAMPLEVALUE
Definition: tiff.h:260
TIFFTAG_NUMBEROFINKS
#define TIFFTAG_NUMBEROFINKS
Definition: tiff.h:326
SAMPLEFORMAT_IEEEFP
#define SAMPLEFORMAT_IEEEFP
Definition: tiff.h:336
TIFFTAG_TRANSFERFUNCTION
#define TIFFTAG_TRANSFERFUNCTION
Definition: tiff.h:298
TIFFTAG_YRESOLUTION
#define TIFFTAG_YRESOLUTION
Definition: tiff.h:263
COMPRESSION_LZW
#define COMPRESSION_LZW
Definition: tiff.h:188
TIFFTAG_TILEBYTECOUNTS
#define TIFFTAG_TILEBYTECOUNTS
Definition: tiff.h:314
TIFFTAG_STRIPBYTECOUNTS
#define TIFFTAG_STRIPBYTECOUNTS
Definition: tiff.h:259
TIFFTAG_SMINSAMPLEVALUE
#define TIFFTAG_SMINSAMPLEVALUE
Definition: tiff.h:340
TIFFTAG_YCBCRSUBSAMPLING
#define TIFFTAG_YCBCRSUBSAMPLING
Definition: tiff.h:388
TIFFTAG_TILEOFFSETS
#define TIFFTAG_TILEOFFSETS
Definition: tiff.h:313
TIFFTAG_ROWSPERSTRIP
#define TIFFTAG_ROWSPERSTRIP
Definition: tiff.h:258
TIFFTAG_SMAXSAMPLEVALUE
#define TIFFTAG_SMAXSAMPLEVALUE
Definition: tiff.h:341
TIFFTAG_SAMPLEFORMAT
#define TIFFTAG_SAMPLEFORMAT
Definition: tiff.h:333
TIFFTAG_REFERENCEBLACKWHITE
#define TIFFTAG_REFERENCEBLACKWHITE
Definition: tiff.h:392
TIFFTAG_TILEWIDTH
#define TIFFTAG_TILEWIDTH
Definition: tiff.h:311
TIFFTAG_IMAGELENGTH
#define TIFFTAG_IMAGELENGTH
Definition: tiff.h:179
TIFFTAG_PAGENUMBER
#define TIFFTAG_PAGENUMBER
Definition: tiff.h:291
TIFFTAG_COMPRESSION
#define TIFFTAG_COMPRESSION
Definition: tiff.h:181
TIFFTAG_PLANARCONFIG
#define TIFFTAG_PLANARCONFIG
Definition: tiff.h:264
TIFFTAG_STRIPOFFSETS
#define TIFFTAG_STRIPOFFSETS
Definition: tiff.h:247
TIFFTAG_SUBFILETYPE
#define TIFFTAG_SUBFILETYPE
Definition: tiff.h:170
TIFFTAG_XPOSITION
#define TIFFTAG_XPOSITION
Definition: tiff.h:268
TIFFTAG_YCBCRPOSITIONING
#define TIFFTAG_YCBCRPOSITIONING
Definition: tiff.h:389
TIFFTAG_INKNAMES
#define TIFFTAG_INKNAMES
Definition: tiff.h:325
TIFFTAG_THRESHHOLDING
#define TIFFTAG_THRESHHOLDING
Definition: tiff.h:234
SAMPLEFORMAT_INT
#define SAMPLEFORMAT_INT
Definition: tiff.h:335
COMPRESSION_JPEG
#define COMPRESSION_JPEG
Definition: tiff.h:190
tmsize_t
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:67
TIFF_VARIABLE
#define TIFF_VARIABLE
Definition: tiffio.h:342
toff_t
uint64_t toff_t
Definition: tiffio.h:70
tdir_t
uint32_t tdir_t
Definition: tiffio.h:71
TIFF_ANY
#define TIFF_ANY
Definition: tiffio.h:341
TIFF_VARIABLE2
#define TIFF_VARIABLE2
Definition: tiffio.h:344
TIFF_NON_EXISTENT_DIR_NUMBER
#define TIFF_NON_EXISTENT_DIR_NUMBER
Definition: tiffiop.h:64
isTiled
#define isTiled(tif)
Definition: tiffiop.h:274
WriteOK
#define WriteOK(tif, buf, size)
Definition: tiffiop.h:301
TIFF_MYBUFFER
#define TIFF_MYBUFFER
Definition: tiffiop.h:126
TIFF_BUFFERSETUP
#define TIFF_BUFFERSETUP
Definition: tiffiop.h:121
ReadOK
#define ReadOK(tif, buf, size)
Definition: tiffiop.h:295
TIFF_POSTENCODE
#define TIFF_POSTENCODE
Definition: tiffiop.h:129
SeekOK
#define SeekOK(tif, off)
Definition: tiffiop.h:298
TIFF_INSUBIFD
#define TIFF_INSUBIFD
Definition: tiffiop.h:130
isMapped
#define isMapped(tif)
Definition: tiffiop.h:275
TIFF_BEENWRITING
#define TIFF_BEENWRITING
Definition: tiffiop.h:123
TIFFSeekFile
#define TIFFSeekFile(tif, off, whence)
Definition: tiffiop.h:282
TIFF_BIGTIFF
#define TIFF_BIGTIFF
Definition: tiffiop.h:138
TIFF_SWAB
#define TIFF_SWAB
Definition: tiffiop.h:124
TIFFHeaderUnion::classic
TIFFHeaderClassic classic
Definition: tiffiop.h:108
TIFFHeaderUnion::big
TIFFHeaderBig big
Definition: tiffiop.h:109
value
Definition: pdh_main.c:96