| blob | d8844bbd8a36a0dfc902f811bc8dee7ab59ea325 |
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 */
25 /*
26 * TIFF Library.
27 *
28 * Directory Write Support Routines.
29 */
34 #ifdef HAVE_IEEEFP
35 #define TIFFCvtNativeToIEEEFloat(tif, n, fp)
36 #define TIFFCvtNativeToIEEEDouble(tif, n, dp)
37 #else
40 #endif
183 /*--: Rational2Double: New functions to support true double-precision for custom
184 * rational tag types. */
195 static int
229 /*
230 * Write the contents of the current directory
231 * to the specified file. This routine doesn't
232 * handle overwriting a directory with auxiliary
233 * storage that's been changed.
234 */
236 {
238 }
240 /*
241 * This is an advanced writing function that must be used in a particular
242 * sequence, and generally together with TIFFForceStrileArrayWriting(),
243 * to make its intended effect. Its aim is to modify the location
244 * where the [Strip/Tile][Offsets/ByteCounts] arrays are located in the file.
245 * More precisely, when TIFFWriteCheck() will be called, the tag entries for
246 * those arrays will be written with type = count = offset = 0 as a temporary
247 * value.
248 *
249 * Its effect is only valid for the current directory, and before
250 * TIFFWriteDirectory() is first called, and will be reset when
251 * changing directory.
252 *
253 * The typical sequence of calls is:
254 * TIFFOpen()
255 * [ TIFFCreateDirectory(tif) ]
256 * Set fields with calls to TIFFSetField(tif, ...)
257 * TIFFDeferStrileArrayWriting(tif)
258 * TIFFWriteCheck(tif, ...)
259 * TIFFWriteDirectory(tif)
260 * ... potentially create other directories and come back to the above directory
261 * TIFFForceStrileArrayWriting(tif): emit the arrays at the end of file
262 *
263 * Returns 1 in case of success, 0 otherwise.
264 */
266 {
269 {
272 }
274 {
277 }
281 }
283 /*
284 * Similar to TIFFWriteDirectory(), writes the directory out
285 * but leaves all data structures in memory so that it can be
286 * written again. This will make a partially written TIFF file
287 * readable before it is successfully completed/closed.
288 */
290 {
292 /* Setup the strips arrays, if they haven't already been. */
298 }
301 {
303 }
305 /*
306 * Similar to TIFFWriteDirectory(), but if the directory has already
307 * been written once, it is relocated to the end of the file, in case it
308 * has changed in size. Note that this will result in the loss of the
309 * previously used directory space.
310 */
312 {
315 /* We don't need to do anything special if it hasn't been written. */
319 /*
320 * Find and zero the pointer to this directory, so that TIFFLinkDirectory
321 * will cause it to be added after this directories current pre-link.
322 */
326 {
328 {
334 {
337 }
338 }
340 {
342 "tif->tif_diroff exceeds 32 bit range allowed for "
345 }
346 else
347 {
351 {
356 {
360 }
365 {
368 }
372 {
376 SEEK_SET);
378 {
382 }
384 /* Force a full-traversal to reach the zeroed pointer */
387 }
389 }
390 }
391 /* Remove skipped offset from IFD loop directory list. */
393 }
394 else
395 {
397 {
403 {
406 }
407 }
408 else
409 {
413 {
419 {
423 }
427 {
429 "Sanity check on tag count failed, likely "
432 }
436 {
439 }
443 {
447 SEEK_SET);
449 {
453 }
455 /* Force a full-traversal to reach the zeroed pointer */
458 }
460 }
461 }
462 /* Remove skipped offset from IFD loop directory list. */
464 }
466 /*
467 * Now use TIFFWriteDirectory() normally.
468 */
471 }
475 {
487 /*
488 * Clear write state so that subsequent images with
489 * different characteristics get the right buffers
490 * setup for them.
491 */
493 {
495 {
498 {
502 }
503 }
505 /*
506 * Flush any data that might have been written
507 * by the compression close+cleanup routines. But
508 * be careful not to write stuff if we didn't add data
509 * in the previous steps as the "rawcc" data may well be
510 * a previously read tile/strip in mixed read/write mode.
511 */
513 {
515 {
519 }
520 }
522 {
529 }
531 }
535 {
537 "Creating TIFF with legacy Deflate codec identifier, "
539 }
544 {
547 {
549 {
551 TIFFTAG_IMAGEWIDTH,
558 }
560 {
562 TIFFTAG_TILEWIDTH,
566 TIFFTAG_TILELENGTH,
569 }
571 {
573 TIFFTAG_XRESOLUTION,
577 TIFFTAG_YRESOLUTION,
580 }
582 {
584 TIFFTAG_XPOSITION,
588 TIFFTAG_YPOSITION,
591 }
593 {
595 TIFFTAG_SUBFILETYPE,
598 }
600 {
605 }
607 {
609 TIFFTAG_COMPRESSION,
612 }
614 {
616 TIFFTAG_PHOTOMETRIC,
619 }
621 {
623 TIFFTAG_THRESHHOLDING,
626 }
628 {
630 TIFFTAG_FILLORDER,
633 }
635 {
637 TIFFTAG_ORIENTATION,
640 }
642 {
647 }
649 {
654 }
656 {
661 }
663 {
668 }
670 {
672 TIFFTAG_PLANARCONFIG,
675 }
677 {
679 TIFFTAG_RESOLUTIONUNIT,
682 }
684 {
689 }
691 {
693 {
699 }
700 else
701 {
707 }
708 }
710 {
712 {
713 /* td_stripoffset_p might be NULL in an odd OJPEG case. See
714 * tif_dirread.c around line 3634.
715 * XXX: OJPEG hack.
716 * If a) compression is OJPEG, b) it's not a tiled TIFF,
717 * and c) the number of strips is 1,
718 * then we tolerate the absence of stripoffsets tag,
719 * because, presumably, all required data is in the
720 * JpegInterchangeFormat stream.
721 * We can get here when using tiffset on such a file.
722 * See http://bugzilla.maptools.org/show_bug.cgi?id=2500
723 */
730 }
731 else
732 {
738 }
739 }
741 {
744 }
746 {
748 {
755 }
756 }
758 {
763 }
765 {
771 }
773 {
779 }
781 {
783 TIFFTAG_IMAGEDEPTH,
786 }
788 {
790 TIFFTAG_TILEDEPTH,
793 }
795 {
800 }
802 {
807 }
809 {
814 }
816 {
821 }
823 {
826 }
828 {
833 }
835 {
837 TIFFTAG_NUMBEROFINKS,
840 }
842 {
845 }
846 {
849 {
854 {
856 {
858 {
870 }
873 {
881 p))
883 }
886 {
894 p))
896 }
899 {
910 }
919 }
920 }
921 }
922 }
923 }
925 {
930 {
992 {
993 /*-- Rational2Double: For Rationals evaluate
994 * "set_field_type" to determine internal storage size. */
999 {
1004 }
1005 else
1006 {
1007 /*-- default should be tv_size == 4 */
1012 /*-- ToDo: After Testing, this should be removed and
1013 * tv_size==4 should be set as default. */
1015 {
1018 "Rational2Double: .set_field_type is "
1020 tv_size);
1021 }
1022 }
1023 }
1026 {
1027 /*-- Rational2Double: For Rationals evaluate
1028 * "set_field_type" to determine internal storage size. */
1033 {
1038 }
1039 else
1040 {
1041 /*-- default should be tv_size == 4 */
1046 /*-- ToDo: After Testing, this should be removed and
1047 * tv_size==4 should be set as default. */
1049 {
1052 "Rational2Double: .set_field_type is "
1054 tv_size);
1055 }
1056 }
1057 }
1086 }
1087 }
1092 {
1095 }
1097 {
1100 }
1101 else
1108 else
1115 {
1118 }
1122 {
1125 else
1127 }
1128 }
1130 {
1132 {
1136 {
1138 {
1141 }
1144 }
1147 else
1149 }
1150 }
1153 {
1156 }
1158 {
1169 {
1183 /* This is correct. The data has been */
1184 /* swabbed previously in TIFFWriteDirectoryTagData */
1187 o++;
1188 }
1193 }
1194 else
1195 {
1205 {
1220 o++;
1221 }
1225 }
1229 {
1232 }
1234 {
1237 }
1240 {
1245 /*
1246 * Reset directory-related state for subsequent
1247 * directories.
1248 */
1250 }
1252 bad:
1258 }
1261 {
1267 }
1270 {
1276 }
1279 {
1285 }
1288 {
1294 }
1297 {
1303 }
1306 {
1312 }
1318 {
1325 {
1328 }
1331 {
1334 {
1339 }
1340 else
1341 {
1344 }
1348 {
1353 }
1355 {
1360 }
1361 else
1362 {
1367 }
1371 {
1376 }
1378 {
1383 }
1384 else
1385 {
1390 }
1394 }
1398 }
1403 {
1405 {
1408 }
1411 }
1416 {
1418 {
1421 }
1424 }
1429 {
1431 {
1434 }
1436 value));
1437 }
1442 {
1444 {
1447 }
1449 value));
1450 }
1455 {
1457 {
1460 }
1462 }
1467 {
1469 {
1472 }
1474 value));
1475 }
1480 {
1487 {
1490 }
1493 {
1496 }
1503 }
1508 {
1510 {
1513 }
1515 value));
1516 }
1521 {
1523 {
1526 }
1528 }
1533 {
1535 {
1538 }
1540 value));
1541 }
1546 {
1548 {
1551 }
1553 value));
1554 }
1556 /************************************************************************/
1557 /* TIFFWriteDirectoryTagLong8Array() */
1558 /* */
1559 /* Write either Long8 or Long array depending on file type. */
1560 /************************************************************************/
1564 {
1572 /* is this just a counting pass? */
1574 {
1577 }
1579 /* We always write Long8 for BigTIFF, no checking needed. */
1584 /*
1585 ** For classic tiff we want to verify everything is in range for long
1586 ** and convert to long format.
1587 */
1590 {
1593 }
1596 {
1598 {
1600 "Attempt to write unsigned long value %" PRIu64
1601 " larger than 0xFFFFFFFF for tag %d in Classic TIFF "
1606 }
1608 }
1614 }
1616 /************************************************************************/
1617 /* TIFFWriteDirectoryTagSlong8Array() */
1618 /* */
1619 /* Write either SLong8 or SLong array depending on file type. */
1620 /************************************************************************/
1624 {
1632 /* is this just a counting pass? */
1634 {
1637 }
1638 /* We always write SLong8 for BigTIFF, no checking needed. */
1643 /*
1644 ** For classic tiff we want to verify everything is in range for signed-long
1645 ** and convert to signed-long format.
1646 */
1649 {
1652 }
1655 {
1657 {
1659 "Attempt to write signed long value %" PRIi64
1660 " larger than 0x7FFFFFFF (2147483647) for tag %d in "
1665 }
1667 {
1669 "Attempt to write signed long value %" PRIi64
1670 " smaller than 0x80000000 (-2147483648) for tag %d "
1675 }
1677 }
1683 }
1688 {
1690 {
1693 }
1695 }
1700 {
1702 {
1705 }
1708 }
1713 {
1715 {
1718 }
1721 }
1723 /*-- Rational2Double: additional write functions */
1729 {
1731 {
1734 }
1737 }
1744 {
1746 {
1749 }
1752 }
1757 {
1759 {
1762 }
1764 value));
1765 }
1770 {
1772 {
1775 }
1777 value));
1778 }
1783 {
1785 {
1788 }
1790 value));
1791 }
1796 {
1798 {
1801 }
1805 else
1807 }
1811 {
1814 {
1816 }
1825 {
1826 /* For a few select compression types, we assume that in the worst */
1827 /* case the compressed size will be 10 times the uncompressed size */
1828 /* This is overly pessismistic ! */
1830 }
1832 }
1835 {
1837 }
1840 {
1842 }
1844 /************************************************************************/
1845 /* TIFFWriteDirectoryTagLongLong8Array() */
1846 /* */
1847 /* Write out LONG8 array and write a SHORT/LONG/LONG8 depending */
1848 /* on strile size and Classic/BigTIFF mode. */
1849 /************************************************************************/
1854 {
1859 /* is this just a counting pass? */
1861 {
1864 }
1867 {
1869 NULL);
1870 }
1873 {
1875 /* In the case of ByteCounts array, we may be able to write them on */
1876 /* LONG if the strip/tilesize is not too big. */
1877 /* Also do that for count > 1 in the case someone would want to create
1878 */
1879 /* a single-strip file with a growing height, in which case using */
1880 /* LONG8 will be safer. */
1882 {
1884 }
1886 {
1888 }
1890 {
1893 }
1894 }
1898 {
1900 }
1902 {
1904 }
1906 {
1907 /*
1908 ** For classic tiff we want to verify everything is in range for LONG
1909 ** and convert to long format.
1910 */
1918 {
1921 }
1924 {
1926 {
1928 "Attempt to write value larger than 0xFFFFFFFF "
1932 }
1934 }
1937 p);
1939 }
1940 else
1941 {
1948 {
1951 }
1954 {
1956 {
1957 /* Should not happen normally given the check we did before */
1959 "Attempt to write value larger than 0xFFFF in "
1963 }
1965 }
1968 p);
1970 }
1973 }
1975 /************************************************************************/
1976 /* TIFFWriteDirectoryTagIfdIfd8Array() */
1977 /* */
1978 /* Write either IFD8 or IFD array depending on file type. */
1979 /************************************************************************/
1984 {
1992 /* is this just a counting pass? */
1994 {
1997 }
1999 /* We always write IFD8 for BigTIFF, no checking needed. */
2002 value);
2004 /*
2005 ** For classic tiff we want to verify everything is in range for IFD
2006 ** and convert to long format.
2007 */
2011 {
2014 }
2017 {
2019 {
2021 "Attempt to write value larger than 0xFFFFFFFF in "
2025 }
2027 }
2033 }
2037 {
2043 {
2046 }
2050 {
2053 }
2061 }
2065 {
2072 {
2075 }
2076 /* TIFFTAG_TRANSFERFUNCTION expects (1 or 3) pointer to arrays with
2077 * (1 << BitsPerSample) * uint16_t values.
2078 */
2080 /* clang-format off */
2082 /* clang-format on */
2084 /* Check for proper number of transferfunctions */
2086 {
2088 {
2093 }
2094 }
2095 /*
2096 * Check if the table can be written as a single column,
2097 * or if it must be written as 3 columns. Note that we
2098 * write a 3-column tag if there are 2 samples/pixel and
2099 * a single column of data won't suffice--hmm.
2100 */
2102 {
2110 }
2113 {
2116 }
2129 }
2133 {
2140 {
2143 }
2146 {
2153 {
2156 }
2160 {
2163 /* Could happen if an classicTIFF has a SubIFD of type LONG8 (which
2164 * is illegal) */
2166 {
2170 }
2172 }
2176 }
2177 else
2183 /*
2184 * Total hack: if this directory includes a SubIFD
2185 * tag then force the next <n> directories to be
2186 * written as ``sub directories'' of this one. This
2187 * is used to write things like thumbnails and
2188 * image masks that one wants to keep out of the
2189 * normal directory linkage access mechanism.
2190 */
2195 else
2198 }
2203 {
2207 }
2214 {
2218 }
2224 {
2228 }
2234 {
2238 }
2243 {
2251 }
2257 {
2264 }
2270 {
2277 }
2282 {
2290 }
2296 {
2303 }
2309 {
2316 }
2322 {
2326 {
2330 }
2335 }
2341 {
2345 {
2349 }
2354 }
2359 {
2364 {
2367 }
2369 {
2372 }
2373 /*--Rational2Double: New function also used for non-custom rational tags.
2374 * However, could be omitted here, because
2375 * TIFFWriteDirectoryTagCheckedRational() is not used by code for custom
2376 * tags, only by code for named-tiff-tags like FIELD_RESOLUTION and
2377 * FIELD_POSITION */
2378 else
2379 {
2381 }
2384 {
2387 }
2390 }
2397 {
2407 {
2410 }
2412 {
2414 }
2421 }
2428 {
2438 {
2441 }
2443 {
2445 }
2452 }
2454 /*-- Rational2Double: additional write functions for double arrays */
2455 static int
2459 {
2470 {
2473 }
2475 {
2477 }
2489 {
2500 {
2503 }
2505 {
2507 }
2516 /** ----- Rational2Double: Double To Rational Conversion
2517 ----------------------------------------------------------
2518 * There is a mathematical theorem to convert real numbers into a rational
2519 (integer fraction) number.
2520 * This is called "continuous fraction" which uses the Euclidean algorithm to
2521 find the greatest common divisor (GCD).
2522 * (ref. e.g. https://de.wikipedia.org/wiki/Kettenbruch or
2523 https://en.wikipedia.org/wiki/Continued_fraction
2524 * https://en.wikipedia.org/wiki/Euclidean_algorithm)
2525 * The following functions implement the
2526 * - ToRationalEuclideanGCD() auxiliary function which mainly
2527 implements euclidean GCD
2528 * - DoubleToRational() conversion function for un-signed
2529 rationals
2530 * - DoubleToSrational() conversion function for signed rationals
2531 ------------------------------------------------------------------------------------------------------------------*/
2533 /**---- ToRationalEuclideanGCD() -----------------------------------------
2534 * Calculates the rational fractional of a double input value
2535 * using the Euclidean algorithm to find the greatest common divisor (GCD)
2536 ------------------------------------------------------------------------*/
2540 {
2541 /* Internally, the integer variables can be bigger than the external ones,
2542 * as long as the result will fit into the external variable size.
2543 */
2551 /*-- nMax and fMax defines the initial accuracy of the starting fractional,
2552 * or better, the highest used integer numbers used within the starting
2553 * fractional (bigNum/bigDenom). There are two approaches, which can
2554 * accidentally lead to different accuracies just depending on the value.
2555 * Therefore, blnUseSmallRange steers this behavior.
2556 * For long long nMax = ((9223372036854775807-1)/2); for long nMax =
2557 * ((2147483647-1)/2);
2558 */
2560 {
2562 }
2563 else
2564 {
2566 }
2569 /*-- For the Euclidean GCD define the denominator range, so that it stays
2570 * within size of unsigned long variables. maxDenom should be LONG_MAX for
2571 * negative values and ULONG_MAX for positive ones. Also the final returned
2572 * value of ullNum and ullDenom is limited according to signed- or
2573 * unsigned-range.
2574 */
2576 {
2579 }
2580 else
2581 {
2584 }
2586 /*-- First generate a rational fraction (bigNum/bigDenom) which represents
2587 *the value as a rational number with the highest accuracy. Therefore,
2588 *uint64_t (uint64_t) is needed. This rational fraction is then reduced
2589 *using the Euclidean algorithm to find the greatest common divisor (GCD).
2590 * bigNum = big numinator of value without fraction (or cut residual
2591 *fraction) bigDenom = big denominator of value
2592 *-- Break-criteria so that uint64_t cast to "bigNum" introduces no error
2593 *and bigDenom has no overflow, and stop with enlargement of fraction when
2594 *the double-value of it reaches an integer number without fractional part.
2595 */
2598 {
2601 }
2604 /*-- Start Euclidean algorithm to find the greatest common divisor (GCD) --
2605 */
2606 #define MAX_ITERATIONS 64
2608 {
2610 /* if bigDenom is not zero, calculate integer part of fraction. */
2612 {
2614 }
2617 /* Set bigDenom to reminder of bigNum/bigDenom and bigNum to previous
2618 * denominator bigDenom. */
2623 /* calculate next denominator and check for its given maximum */
2626 {
2631 else
2633 }
2634 /* calculate next numerator to numSum2 and save previous one to numSum0;
2635 * numSum1 just copy of numSum2. */
2639 /* calculate next denominator to denomSum2 and save previous one to
2640 * denomSum0; denomSum1 just copy of denomSum2. */
2644 }
2646 /*-- Check and adapt for final variable size and return values; reduces
2647 * internal accuracy; denominator is kept in ULONG-range with maxDenom -- */
2649 {
2652 }
2654 /* return values */
2660 /**---- DoubleToRational() -----------------------------------------------
2661 * Calculates the rational fractional of a double input value
2662 * for UN-SIGNED rationals,
2663 * using the Euclidean algorithm to find the greatest common divisor (GCD)
2664 ------------------------------------------------------------------------*/
2666 {
2667 /*---- UN-SIGNED RATIONAL ---- */
2671 /*-- Check for negative values. If so it is an error. */
2672 /* Test written that way to catch NaN */
2674 {
2679 }
2681 /*-- Check for too big numbers (> ULONG_MAX) -- */
2683 {
2687 }
2688 /*-- Check for easy integer numbers -- */
2690 {
2694 }
2695 /*-- Check for too small numbers for "unsigned long" type rationals -- */
2697 {
2701 }
2703 /*-- There are two approaches using the Euclidean algorithm,
2704 * which can accidentally lead to different accuracies just depending on
2705 * the value. Try both and define which one was better.
2706 */
2709 /*-- Double-Check, that returned values fit into ULONG :*/
2712 {
2714 " Num or Denom exceeds ULONG: val=%14.6f, num=%12" PRIu64
2719 }
2721 /* Check, which one has higher accuracy and take that. */
2725 {
2728 }
2729 else
2730 {
2733 }
2736 /**---- DoubleToSrational() -----------------------------------------------
2737 * Calculates the rational fractional of a double input value
2738 * for SIGNED rationals,
2739 * using the Euclidean algorithm to find the greatest common divisor (GCD)
2740 ------------------------------------------------------------------------*/
2742 {
2743 /*---- SIGNED RATIONAL ----*/
2748 /*-- Check for negative values and use then the positive one for internal
2749 * calculations, but take the sign into account before returning. */
2751 {
2754 }
2756 /*-- Check for too big numbers (> LONG_MAX) -- */
2758 {
2762 }
2763 /*-- Check for easy numbers -- */
2765 {
2769 }
2770 /*-- Check for too small numbers for "long" type rationals -- */
2772 {
2776 }
2778 /*-- There are two approaches using the Euclidean algorithm,
2779 * which can accidentally lead to different accuracies just depending on
2780 * the value. Try both and define which one was better. Furthermore, set
2781 * behavior of ToRationalEuclideanGCD() to the range of signed-long.
2782 */
2785 /*-- Double-Check, that returned values fit into LONG :*/
2788 {
2790 " Num or Denom exceeds LONG: val=%14.6f, num=%12" PRIu64
2795 }
2797 /* Check, which one has higher accuracy and take that. */
2801 {
2804 }
2805 else
2806 {
2809 }
2816 {
2824 }
2830 {
2838 }
2843 {
2850 }
2856 {
2864 }
2870 {
2875 {
2879 m++;
2880 }
2882 {
2886 }
2892 {
2894 {
2896 }
2897 }
2898 else
2899 {
2906 {
2909 }
2911 {
2914 }
2916 {
2918 "libtiff does not allow writing more than 2147483647 "
2921 }
2923 {
2926 }
2931 {
2937 }
2938 else
2939 {
2943 }
2944 }
2947 }
2949 /*
2950 * Link the current directory into the directory chain for the file.
2951 */
2953 {
2958 /*
2959 * Handle SubIFDs
2960 */
2962 {
2964 {
2971 {
2975 }
2976 /*
2977 * Advance to the next SubIFD or, if this is
2978 * the last one configured, revert back to the
2979 * normal directory linkage.
2980 */
2983 else
2986 }
2987 else
2988 {
2995 {
2999 }
3000 /*
3001 * Advance to the next SubIFD or, if this is
3002 * the last one configured, revert back to the
3003 * normal directory linkage.
3004 */
3007 else
3010 }
3011 }
3014 {
3021 {
3022 /*
3023 * First directory, overwrite offset in header.
3024 */
3029 {
3032 }
3034 }
3035 /*
3036 * Not the first directory, search to the last and append.
3037 */
3039 {
3041 }
3042 else
3043 {
3045 }
3048 {
3053 {
3056 }
3061 {
3064 }
3068 {
3071 {
3074 }
3077 }
3079 }
3080 }
3081 else
3082 {
3089 {
3090 /*
3091 * First directory, overwrite offset in header.
3092 */
3097 {
3100 }
3102 }
3103 /*
3104 * Not the first directory, search to the last and append.
3105 */
3107 {
3109 }
3110 else
3111 {
3113 }
3115 {
3121 {
3124 }
3128 {
3133 }
3137 {
3140 }
3144 {
3147 {
3150 }
3153 }
3155 }
3156 }
3158 }
3160 /************************************************************************/
3161 /* TIFFRewriteField() */
3162 /* */
3163 /* Rewrite a field in the directory on disk without regard to */
3164 /* updating the TIFF directory structure in memory. Currently */
3165 /* only supported for field that already exist in the on-disk */
3166 /* directory. Mainly used for updating stripoffset / */
3167 /* stripbytecount values after the directory is already on */
3168 /* disk. */
3169 /* */
3170 /* Returns zero on failure, and one on success. */
3171 /************************************************************************/
3175 {
3177 /* const TIFFField* fip = NULL; */
3179 tmsize_t dirsize;
3188 TIFFDataType datatype;
3190 /* -------------------------------------------------------------------- */
3191 /* Find field definition. */
3192 /* -------------------------------------------------------------------- */
3195 /* -------------------------------------------------------------------- */
3196 /* Do some checking this is a straight forward case. */
3197 /* -------------------------------------------------------------------- */
3199 {
3204 }
3207 {
3212 }
3214 /* -------------------------------------------------------------------- */
3215 /* Read the directory entry count. */
3216 /* -------------------------------------------------------------------- */
3218 {
3222 }
3227 {
3229 {
3233 }
3238 }
3239 else
3240 {
3243 {
3247 }
3253 }
3255 /* -------------------------------------------------------------------- */
3256 /* Read through directory to find target tag. */
3257 /* -------------------------------------------------------------------- */
3259 {
3261 {
3265 }
3275 }
3278 {
3282 }
3284 /* -------------------------------------------------------------------- */
3285 /* Extract the type, count and offset for this entry. */
3286 /* -------------------------------------------------------------------- */
3292 {
3304 }
3305 else
3306 {
3314 }
3316 /* -------------------------------------------------------------------- */
3317 /* When a dummy tag was written due to TIFFDeferStrileArrayWriting() */
3318 /* -------------------------------------------------------------------- */
3320 {
3322 {
3323 entry_type =
3325 }
3326 else
3327 {
3330 {
3332 }
3334 {
3336 }
3338 {
3340 }
3341 else
3342 {
3345 {
3347 }
3349 {
3351 }
3353 {
3355 }
3356 else
3357 {
3359 }
3360 }
3361 }
3362 }
3364 /* -------------------------------------------------------------------- */
3365 /* What data type do we want to write this as? */
3366 /* -------------------------------------------------------------------- */
3368 {
3375 else
3377 }
3378 else
3379 {
3390 else
3392 }
3394 /* -------------------------------------------------------------------- */
3395 /* Prepare buffer of actual data to write. This includes */
3396 /* swabbing as needed. */
3397 /* -------------------------------------------------------------------- */
3406 {
3407 tmsize_t i;
3410 {
3413 {
3418 }
3419 }
3420 }
3423 {
3424 tmsize_t i;
3427 {
3431 {
3436 }
3437 }
3438 }
3440 {
3441 tmsize_t i;
3444 {
3448 {
3453 }
3454 }
3455 }
3456 else
3457 {
3460 }
3463 {
3470 }
3472 /* -------------------------------------------------------------------- */
3473 /* Is this a value that fits into the directory entry? */
3474 /* -------------------------------------------------------------------- */
3476 {
3478 {
3481 }
3482 }
3483 else
3484 {
3486 {
3489 }
3490 }
3496 {
3499 }
3505 {
3508 }
3510 /* -------------------------------------------------------------------- */
3511 /* If the tag type, and count match, then we just write it out */
3512 /* over the old values without altering the directory entry at */
3513 /* all. */
3514 /* -------------------------------------------------------------------- */
3516 {
3518 {
3524 }
3526 {
3530 }
3534 }
3536 /* -------------------------------------------------------------------- */
3537 /* Otherwise, we write the new tag data at the end of the file. */
3538 /* -------------------------------------------------------------------- */
3540 {
3544 {
3548 }
3549 }
3550 else
3551 {
3553 {
3557 }
3558 else
3559 {
3562 }
3563 }
3568 /* -------------------------------------------------------------------- */
3569 /* Adjust the directory entry. */
3570 /* -------------------------------------------------------------------- */
3578 {
3590 }
3591 else
3592 {
3600 }
3602 /* -------------------------------------------------------------------- */
3603 /* Write the directory entry out to disk. */
3604 /* -------------------------------------------------------------------- */
3606 {
3610 }
3613 {
3617 }
3620 }