Include dependency graph for tif_dirwrite.c:
Go to the source code of this file.
Macros | |
| #define | MAX_ITERATIONS 64 |
Macro Definition Documentation
◆ MAX_ITERATIONS
| #define MAX_ITERATIONS 64 |
Function Documentation
◆ _TIFFRewriteField()
| int _TIFFRewriteField | ( | TIFF * | tif, |
| uint16_t | tag, | ||
| TIFFDataType | in_datatype, | ||
| tmsize_t | count, | ||
| void * | data | ||
| ) |
Definition at line 3377 of file tif_dirwrite.c.
3379{
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;
3392 TIFFDataType datatype;
3393
3394 /* -------------------------------------------------------------------- */
3395 /* Find field definition. */
3396 /* -------------------------------------------------------------------- */
3398
3399 /* -------------------------------------------------------------------- */
3400 /* Do some checking this is a straight forward case. */
3401 /* -------------------------------------------------------------------- */
3403 {
3405 "Memory mapped files not currently supported for "
3406 "this operation.");
3407 return 0;
3408 }
3409
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 /* -------------------------------------------------------------------- */
3422 {
3424 tif->tif_name);
3425 return 0;
3426 }
3427
3428 read_offset = tif->tif_diroff;
3429
3431 {
3433 {
3435 tif->tif_name);
3436 return 0;
3437 }
3439 TIFFSwabShort(&dircount);
3440 dirsize = 12;
3441 read_offset += 2;
3442 }
3443 else
3444 {
3445 uint64_t dircount64;
3447 {
3449 tif->tif_name);
3450 return 0;
3451 }
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 {
3465 {
3467 tif->tif_name);
3468 return 0;
3469 }
3470
3473 TIFFSwabShort(&entry_tag);
3474
3476 break;
3477
3478 read_offset += dirsize;
3479 }
3480
3482 {
3485 return 0;
3486 }
3487
3488 /* -------------------------------------------------------------------- */
3489 /* Extract the type, count and offset for this entry. */
3490 /* -------------------------------------------------------------------- */
3493 TIFFSwabShort(&entry_type);
3494
3496 {
3498
3502 entry_count = value;
3503
3507 entry_offset = value;
3508 }
3509 else
3510 {
3513 TIFFSwabLong8(&entry_count);
3514
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 {
3526 {
3527 entry_type =
3529 }
3530 else
3531 {
3532 int write_aslong8 = 1;
3534 {
3536 }
3538 {
3540 }
3541 if (write_aslong8)
3542 {
3543 entry_type = TIFF_LONG8;
3544 }
3545 else
3546 {
3547 int write_aslong4 = 1;
3549 {
3551 }
3553 {
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 /* -------------------------------------------------------------------- */
3572 {
3576 datatype = TIFF_SLONG;
3578 datatype = TIFF_IFD;
3579 else
3580 datatype = in_datatype;
3581 }
3582 else
3583 {
3586 entry_type == TIFF_LONG8))
3587 datatype = entry_type;
3590 datatype = entry_type;
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 /* -------------------------------------------------------------------- */
3604 if (!buf_to_write)
3605 return 0;
3606
3607 if (datatype == in_datatype)
3610 {
3612
3614 {
3617 {
3618 _TIFFfreeExt(tif, buf_to_write);
3620 "Value exceeds 32bit range of output type.");
3621 return 0;
3622 }
3623 }
3624 }
3627 {
3629
3631 {
3635 {
3636 _TIFFfreeExt(tif, buf_to_write);
3638 "Value exceeds 32bit range of output type.");
3639 return 0;
3640 }
3641 }
3642 }
3644 {
3646
3648 {
3652 {
3653 _TIFFfreeExt(tif, buf_to_write);
3655 "Value exceeds 16bit range of output type.");
3656 return 0;
3657 }
3658 }
3659 }
3660 else
3661 {
3663 return 0;
3664 }
3665
3667 {
3674 }
3675
3676 /* -------------------------------------------------------------------- */
3677 /* Is this a value that fits into the directory entry? */
3678 /* -------------------------------------------------------------------- */
3680 {
3682 {
3683 entry_offset = read_offset + 8;
3684 value_in_entry = 1;
3685 }
3686 }
3687 else
3688 {
3690 {
3691 entry_offset = read_offset + 12;
3692 value_in_entry = 1;
3693 }
3694 }
3695
3700 {
3703 }
3709 {
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 /* -------------------------------------------------------------------- */
3720 {
3722 {
3723 _TIFFfreeExt(tif, buf_to_write);
3725 "%s: Seek error accessing TIFF directory",
3726 tif->tif_name);
3727 return 0;
3728 }
3730 {
3731 _TIFFfreeExt(tif, buf_to_write);
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 {
3746
3748 {
3749 _TIFFfreeExt(tif, buf_to_write);
3751 return (0);
3752 }
3753 }
3754 else
3755 {
3757 {
3760 entry_offset = value;
3761 }
3762 else
3763 {
3764 memcpy(&entry_offset, buf_to_write,
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;
3780
3782 {
3784
3789
3794 }
3795 else
3796 {
3800
3804 }
3805
3806 /* -------------------------------------------------------------------- */
3807 /* Write the directory entry out to disk. */
3808 /* -------------------------------------------------------------------- */
3810 {
3812 tif->tif_name);
3813 return 0;
3814 }
3815
3817 {
3819 tif->tif_name);
3820 return 0;
3821 }
3822
3823 return 1;
3824}
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
union TIFFDirEntry::@3701 tdir_offset
Definition: dbghelp_private.h:377
Definition: ecma_167.h:138
void * _TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:122
const TIFFField * TIFFFindField(TIFF *tif, uint32_t tag, TIFFDataType dt)
Definition: tif_dirinfo.c:795
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_error.c:107
void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
Definition: tif_swab.c:117
void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
Definition: tif_swab.c:138
void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
Definition: tif_swab.c:81
Definition: pdh_main.c:96
Referenced by TIFFForceStrileArrayWriting().
◆ _WriteAsType()
|
static |
Definition at line 1861 of file tif_dirwrite.c.
1863{
1866 {
1867 return strile_size > uncompressed_threshold;
1868 }
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}
_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
Referenced by WriteAsLong4(), and WriteAsLong8().
◆ DoubleToRational()
-— DoubleToRational() --------------------------------------------— Calculates the rational fractional of a double input value for UN-SIGNED rationals,
using the Euclidean algorithm to find the greatest common divisor (GCD)
Definition at line 2815 of file tif_dirwrite.c.
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 */
2824 {
2825 *num = *denom = 0;
2827 " Negative Value for Unsigned Rational given.");
2828 return;
2829 }
2830
2831 /*-- Check for too big numbers (> ULONG_MAX) -- */
2833 {
2834 *num = 0xFFFFFFFFU;
2835 *denom = 0;
2836 return;
2837 }
2838 /*-- Check for easy integer numbers -- */
2840 {
2842 *denom = 1;
2843 return;
2844 }
2845 /*-- Check for too small numbers for "unsigned long" type rationals -- */
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 */
2859 /*-- Double-Check, that returned values fit into ULONG :*/
2860 if (ullNum > 0xFFFFFFFFUL || ullDenom > 0xFFFFFFFFUL ||
2861 ullNum2 > 0xFFFFFFFFUL || ullDenom2 > 0xFFFFFFFFUL)
2862 {
2867 value, ullNum, ullDenom, ullNum2, ullDenom2);
2868 assert(0);
2869 }
2870
2871 /* Check, which one has higher accuracy and take that. */
2874 if (dblDiff < dblDiff2)
2875 {
2877 *denom = (uint32_t)ullDenom;
2878 }
2879 else
2880 {
2882 *denom = (uint32_t)ullDenom2;
2883 }
2884} /*-- DoubleToRational() -------------- */
_ACRTIMP double __cdecl fabs(double)
static void ToRationalEuclideanGCD(double value, int blnUseSignedRange, int blnUseSmallRange, uint64_t *ullNum, uint64_t *ullDenom)
Definition: tif_dirwrite.c:2687
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
Referenced by TIFFWriteDirectoryTagCheckedRational(), TIFFWriteDirectoryTagCheckedRationalArray(), and TIFFWriteDirectoryTagCheckedRationalDoubleArray().
◆ DoubleToSrational()
-— DoubleToSrational() --------------------------------------------— Calculates the rational fractional of a double input value for SIGNED rationals,
using the Euclidean algorithm to find the greatest common divisor (GCD)
Definition at line 2891 of file tif_dirwrite.c.
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. */
2901 {
2902 neg = -1;
2904 }
2905
2906 /*-- Check for too big numbers (> LONG_MAX) -- */
2908 {
2909 *num = 0x7FFFFFFFL;
2910 *denom = 0;
2911 return;
2912 }
2913 /*-- Check for easy numbers -- */
2915 {
2917 *denom = 1;
2918 return;
2919 }
2920 /*-- Check for too small numbers for "long" type rationals -- */
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 */
2935 /*-- Double-Check, that returned values fit into LONG :*/
2936 if (ullNum > 0x7FFFFFFFL || ullDenom > 0x7FFFFFFFL ||
2937 ullNum2 > 0x7FFFFFFFL || ullDenom2 > 0x7FFFFFFFL)
2938 {
2943 neg * value, ullNum, ullDenom, ullNum2, ullDenom2);
2944 assert(0);
2945 }
2946
2947 /* Check, which one has higher accuracy and take that. */
2950 if (dblDiff < dblDiff2)
2951 {
2953 *denom = (int32_t)ullDenom;
2954 }
2955 else
2956 {
2958 *denom = (int32_t)ullDenom2;
2959 }
2960} /*-- DoubleToSrational() --------------*/
Referenced by TIFFWriteDirectoryTagCheckedSrationalArray(), and TIFFWriteDirectoryTagCheckedSrationalDoubleArray().
◆ EvaluateIFDdatasizeWrite()
|
static |
Definition at line 2084 of file tif_dirwrite.c.
2086{
2089 {
2090 /* LibTIFF increments write address to an even offset, thus datalength
2091 * written is also incremented. */
2092 if (datalength & 1)
2093 datalength++;
2095 }
2096 (*ndir)++;
2097}
Referenced by TIFFWriteDirectoryTagCheckedAscii(), TIFFWriteDirectoryTagCheckedByteArray(), TIFFWriteDirectoryTagCheckedDoubleArray(), TIFFWriteDirectoryTagCheckedFloatArray(), TIFFWriteDirectoryTagCheckedIfd8Array(), TIFFWriteDirectoryTagCheckedIfdArray(), TIFFWriteDirectoryTagCheckedLong8Array(), TIFFWriteDirectoryTagCheckedLongArray(), TIFFWriteDirectoryTagCheckedRationalArray(), TIFFWriteDirectoryTagCheckedRationalDoubleArray(), TIFFWriteDirectoryTagCheckedSbyteArray(), TIFFWriteDirectoryTagCheckedShortArray(), TIFFWriteDirectoryTagCheckedSlong8Array(), TIFFWriteDirectoryTagCheckedSlongArray(), TIFFWriteDirectoryTagCheckedSrationalArray(), TIFFWriteDirectoryTagCheckedSrationalDoubleArray(), TIFFWriteDirectoryTagCheckedSshortArray(), TIFFWriteDirectoryTagCheckedUndefinedArray(), TIFFWriteDirectoryTagColormap(), and TIFFWriteDirectoryTagTransferfunction().
◆ TIFFCheckpointDirectory()
Definition at line 292 of file tif_dirwrite.c.
293{
294 int rc;
295 /* Setup the strips arrays, if they haven't already been. */
300 return rc;
301}
Definition: nsiface.idl:2307
static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone, uint64_t *pdiroff)
Definition: tif_dirwrite.c:488
◆ TIFFClampDoubleToInt16()
Definition at line 1413 of file tif_dirwrite.c.
1414{
1416 return 32767;
1418 return -32768;
1420}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToInt32()
Definition at line 1422 of file tif_dirwrite.c.
1423{
1425 return 0x7FFFFFFF;
1427 return -0x7FFFFFFF - 1;
1429}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToInt8()
Definition at line 1404 of file tif_dirwrite.c.
1405{
1407 return 127;
1409 return -128;
1411}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToUInt16()
Definition at line 1440 of file tif_dirwrite.c.
1441{
1443 return 0;
1445 return 65535;
1447}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToUInt32()
Definition at line 1449 of file tif_dirwrite.c.
1450{
1452 return 0;
1454 return 0xFFFFFFFFU;
1456}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToUInt8()
Definition at line 1431 of file tif_dirwrite.c.
1432{
1434 return 0;
1436 return 255;
1438}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFCvtNativeToIEEEDouble()
Referenced by TIFFWriteDirectoryTagCheckedDoubleArray().
◆ TIFFCvtNativeToIEEEFloat()
Referenced by TIFFWriteDirectoryTagCheckedFloatArray().
◆ TIFFDeferStrileArrayWriting()
Definition at line 268 of file tif_dirwrite.c.
269{
272 {
274 return 0;
275 }
277 {
279 return 0;
280 }
281
283 return 1;
284}
unsigned char td_deferstrilearraywriting
Definition: tif_dir.h:146
◆ TIFFLinkDirectory()
Definition at line 3122 of file tif_dirwrite.c.
3123{
3125
3127
3128 /*
3129 * Handle SubIFDs
3130 */
3132 {
3134 {
3141 {
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 */
3154 tif->tif_subifdoff += 4;
3155 return (1);
3156 }
3157 else
3158 {
3165 {
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 */
3178 tif->tif_subifdoff += 8;
3179 return (1);
3180 }
3181 }
3182
3183 /*
3184 * Handle main-IFDs
3185 */
3188 {
3190 uint32_t nextdir;
3195 {
3196 /*
3197 * First directory, overwrite offset in header.
3198 */
3203 {
3205 return (0);
3206 }
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;
3217 {
3218 /* Start searching from the lastely written IFD. Thus get its IFD
3219 * number. */
3221 ndir = dirn + 1;
3222 }
3223 else
3224 {
3226 ndir = 1; /* start searching from the first IFD */
3227 }
3228
3229 while (1)
3230 {
3231 uint16_t dircount;
3232 uint32_t nextnextdir;
3233
3235 {
3237 return (0);
3238 }
3240 TIFFSwabShort(&dircount);
3243 {
3245 return (0);
3246 }
3248 TIFFSwabLong(&nextnextdir);
3249 if (nextnextdir == 0)
3250 {
3253 {
3255 return (0);
3256 }
3258 break;
3259 }
3260 nextdir = nextnextdir;
3261 ndir++;
3262 }
3263 }
3264 else
3265 {
3266 /*- BigTIFF -*/
3268 uint64_t nextdir;
3273 {
3274 /*
3275 * First directory, overwrite offset in header.
3276 */
3281 {
3283 return (0);
3284 }
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;
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 {
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
3313 {
3315 return (0);
3316 }
3318 TIFFSwabLong8(&dircount64);
3319 if (dircount64 > 0xFFFF)
3320 {
3322 "Sanity check on tag count failed, "
3323 "likely corrupt TIFF");
3324 return (0);
3325 }
3326 dircount = (uint16_t)dircount64;
3329 {
3331 return (0);
3332 }
3334 TIFFSwabLong8(&nextnextdir);
3335 if (nextnextdir == 0)
3336 {
3339 {
3341 return (0);
3342 }
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' */
3358 {
3359 tif->tif_curdircount = ndir;
3360 }
3361 return (1);
3362}
int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff, tdir_t *dirn)
Definition: tif_dirread.c:5828
Referenced by TIFFWriteDirectorySec().
◆ TIFFRewriteDirectory()
Definition at line 483 of file tif_dirwrite.c.
484{
486}
static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone, uint64_t *pdiroff)
Definition: tif_dirwrite.c:315
Referenced by TIFFFlush().
◆ TIFFRewriteDirectorySec()
|
static |
Definition at line 315 of file tif_dirwrite.c.
317{
319
320 /* We don't need to do anything special if it hasn't been written. */
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 */
329
331 {
333 {
335 tif->tif_diroff = 0;
336
339 {
341 return (0);
342 }
343 }
345 {
347 "tif->tif_diroff exceeds 32 bit range allowed for "
348 "Classic TIFF");
349 return (0);
350 }
351 else
352 {
353 uint32_t nextdir;
355 while (1)
356 {
357 uint16_t dircount;
358 uint32_t nextnextdir;
359
361 {
363 "Error fetching directory count");
364 return (0);
365 }
367 TIFFSwabShort(&dircount);
370 {
372 return (0);
373 }
375 TIFFSwabLong(&nextnextdir);
377 {
379 m = 0;
381 SEEK_SET);
383 {
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 {
402 {
404 tif->tif_diroff = 0;
405
408 {
410 return (0);
411 }
412 }
413 else
414 {
415 uint64_t nextdir;
417 while (1)
418 {
419 uint64_t dircount64;
420 uint16_t dircount;
421 uint64_t nextnextdir;
422
424 {
426 "Error fetching directory count");
427 return (0);
428 }
430 TIFFSwabLong8(&dircount64);
431 if (dircount64 > 0xFFFF)
432 {
434 "Sanity check on tag count failed, likely "
435 "corrupt TIFF");
436 return (0);
437 }
438 dircount = (uint16_t)dircount64;
441 {
443 return (0);
444 }
446 TIFFSwabLong8(&nextnextdir);
448 {
450 m = 0;
452 SEEK_SET);
454 {
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 */
475} /*-- TIFFRewriteDirectorySec() --*/
int _TIFFRemoveEntryFromDirectoryListByOffset(TIFF *tif, uint64_t diroff)
Definition: tif_dirread.c:5900
Referenced by TIFFRewriteDirectory(), and TIFFWriteDirectorySec().
◆ TIFFWriteCustomDirectory()
Definition at line 303 of file tif_dirwrite.c.
◆ TIFFWriteDirectory()
Definition at line 238 of file tif_dirwrite.c.
Referenced by tiff_encoder_create_frame(), and TIFFRewriteDirectorySec().
◆ TIFFWriteDirectorySec()
|
static |
Definition at line 488 of file tif_dirwrite.c.
490{
492 uint32_t ndir;
494 uint32_t dirsize;
495 void *dirmem;
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 {
510 {
511 tif->tif_flags &= ~TIFF_POSTENCODE;
513 {
515 "Error post-encoding before directory write");
516 return (0);
517 }
518 }
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 */
528 {
530 {
532 "Error flushing data before directory write");
533 return (0);
534 }
535 }
537 {
541 tif->tif_rawcc = 0;
542 tif->tif_rawdatasize = 0;
543 tif->tif_rawdataoff = 0;
544 tif->tif_rawdataloaded = 0;
545 }
547 }
548
551 {
553 "Creating TIFF with legacy Deflate codec identifier, "
554 "COMPRESSION_ADOBE_DEFLATE is more widely supported");
555 }
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;
567 if (isimage)
568 {
569 /*-- Step 1: Process named tags for an image with FIELD bits
570 * associated. --*/
572 {
574 TIFFTAG_IMAGEWIDTH,
576 goto bad;
580 goto bad;
581 }
583 {
585 TIFFTAG_TILEWIDTH,
587 goto bad;
589 TIFFTAG_TILELENGTH,
591 goto bad;
592 }
594 {
596 TIFFTAG_XRESOLUTION,
598 goto bad;
600 TIFFTAG_YRESOLUTION,
602 goto bad;
603 }
605 {
607 TIFFTAG_XPOSITION,
609 goto bad;
611 TIFFTAG_YPOSITION,
613 goto bad;
614 }
616 {
618 TIFFTAG_SUBFILETYPE,
620 goto bad;
621 }
623 {
627 goto bad;
628 }
630 {
632 TIFFTAG_COMPRESSION,
634 goto bad;
635 }
637 {
639 TIFFTAG_PHOTOMETRIC,
641 goto bad;
642 }
644 {
648 goto bad;
649 }
651 {
653 TIFFTAG_FILLORDER,
655 goto bad;
656 }
658 {
660 TIFFTAG_ORIENTATION,
662 goto bad;
663 }
665 {
669 goto bad;
670 }
672 {
676 goto bad;
677 }
679 {
683 goto bad;
684 }
686 {
690 goto bad;
691 }
693 {
695 TIFFTAG_PLANARCONFIG,
697 goto bad;
698 }
700 {
704 goto bad;
705 }
707 {
711 goto bad;
712 }
714 {
716 {
721 goto bad;
722 }
723 else
724 {
729 goto bad;
730 }
731 }
733 {
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 */
752 goto bad;
753 }
754 else
755 {
760 goto bad;
761 }
762 }
764 {
766 goto bad;
767 }
769 {
771 {
772 uint16_t na;
773 uint16_t *nb;
777 goto bad;
778 }
779 }
781 {
785 goto bad;
786 }
788 {
793 goto bad;
794 }
796 {
801 goto bad;
802 }
804 {
806 TIFFTAG_IMAGEDEPTH,
808 goto bad;
809 }
811 {
813 TIFFTAG_TILEDEPTH,
815 goto bad;
816 }
818 {
822 goto bad;
823 }
825 {
829 goto bad;
830 }
832 {
836 goto bad;
837 }
839 {
843 goto bad;
844 }
846 {
848 goto bad;
849 }
851 {
855 goto bad;
856 }
858 {
860 TIFFTAG_NUMBEROFINKS,
862 goto bad;
863 }
865 {
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 {
876 {
881 {
883 {
885 {
887 char *pb;
895 pa, pb))
896 goto bad;
897 }
898 break;
900 {
908 p))
909 goto bad;
910 }
911 break;
913 {
921 p))
922 goto bad;
923 }
924 break;
926 {
928 void *pb;
935 pa, pb))
936 goto bad;
937 }
938 break;
939 default:
940 TIFFErrorExtR(
941 tif, module,
943 TIFFFieldTag(o),
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. --*/
954 {
959 {
964 goto bad;
965 break;
970 goto bad;
971 break;
976 goto bad;
977 break;
982 goto bad;
983 break;
988 goto bad;
989 break;
994 goto bad;
995 break;
1000 goto bad;
1001 break;
1006 goto bad;
1007 break;
1012 goto bad;
1013 break;
1018 goto bad;
1019 break;
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(
1028 if (tv_size == 8)
1029 {
1033 goto bad;
1034 }
1035 else
1036 {
1037 /*-- default should be tv_size == 4 */
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;
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(
1063 if (tv_size == 8)
1064 {
1068 goto bad;
1069 }
1070 else
1071 {
1072 /*-- default should be tv_size == 4 */
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;
1094 goto bad;
1095 break;
1100 goto bad;
1101 break;
1106 goto bad;
1107 break;
1112 goto bad;
1113 break;
1114 default:
1116 break;
1117 }
1118 }
1119 /* "break" if IFD has been written above in second pass.*/
1121 break;
1122
1123 /* Evaluate IFD data size: Finally, add the size of the IFD tag entries
1124 * themselves. */
1127 else
1129
1130 /* Setup a new directory within first pass. */
1133 {
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 */
1148 {
1150 goto bad;
1151 }
1154 {
1156 {
1159 }
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 */
1174 {
1175 /* Append at end of file and increment to an even offset. */
1176 tif->tif_diroff =
1178 }
1179 }
1180 /* Return IFD offset */
1182 *pdiroff = tif->tif_diroff;
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 */
1196 {
1198 goto bad;
1199 }
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. */
1209 {
1210 uint32_t na;
1211 TIFFDirEntry *nb;
1213 {
1214 if (na == ndir)
1215 {
1217 goto bad;
1218 }
1220 break;
1221 }
1224 else
1226 }
1227 }
1228 /* Copy/swab IFD entries from "dir" into "dirmem",
1229 * which is then written to file. */
1230 dirmem = _TIFFmallocExt(tif, dirsize);
1232 {
1234 goto bad;
1235 }
1237 {
1239 uint32_t nTmp;
1240 TIFFDirEntry *o;
1241 n = dirmem;
1245 n += 2;
1246 o = dir;
1248 {
1252 n += 2;
1256 n += 2;
1261 n += 4;
1262 /* This is correct. The data has been */
1263 /* swabbed previously in TIFFWriteDirectoryTagData */
1265 n += 4;
1266 o++;
1267 }
1270 TIFFSwabLong(&nTmp);
1272 }
1273 else
1274 {
1276 TIFFDirEntry *o;
1277 n = dirmem;
1281 n += 8;
1282 o = dir;
1284 {
1288 n += 2;
1292 n += 2;
1296 n += 8;
1298 n += 8;
1299 o++;
1300 }
1304 }
1308 {
1310 "IO error writing directory at seek to offset");
1311 goto bad;
1312 }
1314 {
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. */
1323 {
1326 {
1327 /*-- Normal main-IFD case --*/
1329 {
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() */
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. */
1364 tif->tif_curdircount++;
1365
1367
1368 /* Reset SubIFD writing stage after last SubIFD has been written. */
1370 tif->tif_flags &= ~TIFF_INSUBIFD;
1371
1372 /* Add or update this directory to the IFD list. */
1374 {
1377 ") might cause an IFD loop",
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. */
1394 }
1395 return (1);
1396bad:
1400 _TIFFfreeExt(tif, dirmem);
1401 return (0);
1402}
Definition: tif_dir.h:54
Definition: tif_dir.h:331
int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag,...)
Definition: tif_aux.c:380
int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
Definition: tif_dirread.c:5665
static int TIFFWriteDirectoryTagShortLong(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t value)
Definition: tif_dirwrite.c:1850
static int TIFFWriteDirectoryTagSlongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int32_t *value)
Definition: tif_dirwrite.c:1643
static int TIFFWriteDirectoryTagLong(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t value)
Definition: tif_dirwrite.c:1628
static int TIFFWriteDirectoryTagSbyteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int8_t *value)
Definition: tif_dirwrite.c:1568
static int TIFFWriteDirectoryTagRationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1806
static int TIFFWriteDirectoryTagAscii(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, char *value)
Definition: tif_dirwrite.c:1544
static int TIFFWriteDirectoryTagIfdArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:1842
static int TIFFWriteDirectoryTagSrationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1816
static int TIFFWriteDirectoryTagDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1834
static int TIFFWriteDirectoryTagLongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:1635
static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int64_t *value)
Definition: tif_dirwrite.c:1717
static int TIFFWriteDirectoryTagColormap(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2099
static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2128
static int TIFFWriteDirectoryTagSrationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:1797
static int TIFFWriteDirectoryTagByteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:1560
static int TIFFWriteDirectoryTagRationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:1789
static int TIFFWriteDirectoryTagSampleformatArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:1458
static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:2032
static int TIFFWriteDirectoryTagFloatArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:1826
static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:1903
static int TIFFWriteDirectoryTagSshortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int16_t *value)
Definition: tif_dirwrite.c:1620
static int TIFFWriteDirectoryTagShortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint16_t *value)
Definition: tif_dirwrite.c:1583
static int TIFFWriteDirectoryTagShortPerSample(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t value)
Definition: tif_dirwrite.c:1591
static int TIFFWriteDirectoryTagUndefinedArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:1552
static int TIFFWriteDirectoryTagShort(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t value)
Definition: tif_dirwrite.c:1576
static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:1656
static int TIFFWriteDirectoryTagRational(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, double value)
Definition: tif_dirwrite.c:1782
static int TIFFWriteDirectoryTagSubifd(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2197
void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_warning.c:80
Referenced by TIFFCheckpointDirectory(), TIFFRewriteDirectorySec(), TIFFWriteCustomDirectory(), and TIFFWriteDirectory().
◆ TIFFWriteDirectoryTagAscii()
|
static |
Definition at line 1544 of file tif_dirwrite.c.
1547{
1548 return (
1550}
static int TIFFWriteDirectoryTagCheckedAscii(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, char *value)
Definition: tif_dirwrite.c:2267
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagByteArray()
|
static |
Definition at line 1560 of file tif_dirwrite.c.
1563{
1565 value));
1566}
static int TIFFWriteDirectoryTagCheckedByteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:2297
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagCheckedAscii()
|
static |
Definition at line 2267 of file tif_dirwrite.c.
2270{
2273 {
2275 return 1;
2276 }
2279}
static void EvaluateIFDdatasizeWrite(TIFF *tif, uint32_t count, uint32_t typesize, uint32_t *ndir)
Definition: tif_dirwrite.c:2084
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
Referenced by TIFFWriteDirectoryTagAscii().
◆ TIFFWriteDirectoryTagCheckedByteArray()
|
static |
Definition at line 2297 of file tif_dirwrite.c.
2301{
2304 {
2306 return 1;
2307 }
2310}
Referenced by TIFFWriteDirectoryTagByteArray().
◆ TIFFWriteDirectoryTagCheckedDoubleArray()
|
static |
Definition at line 2981 of file tif_dirwrite.c.
2985{
2989 {
2991 return 1;
2992 }
2998}
void TIFFCvtNativeToIEEEDouble(TIFF *tif, uint32_t n, double *dp)
Referenced by TIFFWriteDirectoryTagDoubleArray().
◆ TIFFWriteDirectoryTagCheckedFloatArray()
|
static |
Definition at line 2962 of file tif_dirwrite.c.
2966{
2970 {
2972 return 1;
2973 }
2979}
void TIFFCvtNativeToIEEEFloat(TIFF *tif, uint32_t n, float *fp)
void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
Definition: tif_swab.c:180
Referenced by TIFFWriteDirectoryTagFloatArray().
◆ TIFFWriteDirectoryTagCheckedIfd8Array()
|
static |
Definition at line 3017 of file tif_dirwrite.c.
3021{
3026 {
3028 return 1;
3029 }
3034}
Referenced by TIFFWriteDirectoryTagIfdIfd8Array(), and TIFFWriteDirectoryTagSubifd().
◆ TIFFWriteDirectoryTagCheckedIfdArray()
|
static |
Definition at line 3000 of file tif_dirwrite.c.
3003{
3007 {
3009 return 1;
3010 }
3015}
Referenced by TIFFWriteDirectoryTagIfdArray(), TIFFWriteDirectoryTagIfdIfd8Array(), and TIFFWriteDirectoryTagSubifd().
◆ TIFFWriteDirectoryTagCheckedLong()
|
static |
Definition at line 2382 of file tif_dirwrite.c.
2385{
2389 {
2390 /* No additional data to IFD data size just increment ndir. */
2391 (*ndir)++;
2392 return 1;
2393 }
2397 return (
2399}
Referenced by TIFFWriteDirectoryTagLong(), and TIFFWriteDirectoryTagShortLong().
◆ TIFFWriteDirectoryTagCheckedLong8Array()
|
static |
Definition at line 2437 of file tif_dirwrite.c.
2441{
2445 {
2447 "LONG8 not allowed for ClassicTIFF");
2448 return (0);
2449 }
2451 {
2453 return 1;
2454 }
2459}
Referenced by TIFFWriteDirectoryTagLong8Array(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFWriteDirectoryTagCheckedLongArray()
|
static |
Definition at line 2401 of file tif_dirwrite.c.
2405{
2409 {
2411 return 1;
2412 }
2417}
Referenced by TIFFWriteDirectoryTagLong8Array(), TIFFWriteDirectoryTagLongArray(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFWriteDirectoryTagCheckedRational()
|
static |
Definition at line 2485 of file tif_dirwrite.c.
2488{
2493 {
2495 return 0;
2496 }
2498 {
2500 return 0;
2501 }
2502
2504 {
2507 (*ndir)++;
2508 return 1;
2509 }
2510
2512
2514 {
2517 }
2519 &m[0]));
2520}
static void DoubleToRational(double value, uint32_t *num, uint32_t *denom)
Definition: tif_dirwrite.c:2815
Referenced by TIFFWriteDirectoryTagRational().
◆ TIFFWriteDirectoryTagCheckedRationalArray()
|
static |
Definition at line 2522 of file tif_dirwrite.c.
2527{
2530 float *na;
2531 uint32_t *nb;
2532 uint32_t nc;
2533 int o;
2536 {
2538 return 1;
2539 }
2542 {
2544 return (0);
2545 }
2547 {
2548 DoubleToRational(*na, &nb[0], &nb[1]);
2549 }
2555 return (o);
2556}
Referenced by TIFFWriteDirectoryTagRationalArray().
◆ TIFFWriteDirectoryTagCheckedRationalDoubleArray()
|
static |
Definition at line 2596 of file tif_dirwrite.c.
2599{
2601 "TIFFWriteDirectoryTagCheckedRationalDoubleArray";
2603 double *na;
2604 uint32_t *nb;
2605 uint32_t nc;
2606 int o;
2609 {
2611 return 1;
2612 }
2615 {
2617 return (0);
2618 }
2620 {
2621 DoubleToRational(*na, &nb[0], &nb[1]);
2622 }
2628 return (o);
2629} /*-- TIFFWriteDirectoryTagCheckedRationalDoubleArray() ------- */
Referenced by TIFFWriteDirectoryTagRationalDoubleArray().
◆ TIFFWriteDirectoryTagCheckedSbyteArray()
|
static |
Definition at line 2312 of file tif_dirwrite.c.
2316{
2319 {
2321 return 1;
2322 }
2325}
Referenced by TIFFWriteDirectoryTagSbyteArray().
◆ TIFFWriteDirectoryTagCheckedShort()
|
static |
Definition at line 2327 of file tif_dirwrite.c.
2330{
2334 {
2335 /* No additional data to IFD data size just increment ndir. */
2336 (*ndir)++;
2337 return 1;
2338 }
2342 return (
2344}
Referenced by TIFFWriteDirectoryTagShort(), and TIFFWriteDirectoryTagShortLong().
◆ TIFFWriteDirectoryTagCheckedShortArray()
|
static |
Definition at line 2346 of file tif_dirwrite.c.
2350{
2354 {
2356 return 1;
2357 }
2362}
Referenced by TIFFWriteDirectoryTagColormap(), TIFFWriteDirectoryTagLongLong8Array(), TIFFWriteDirectoryTagShortArray(), TIFFWriteDirectoryTagShortPerSample(), and TIFFWriteDirectoryTagTransferfunction().
◆ TIFFWriteDirectoryTagCheckedSlong8Array()
|
static |
Definition at line 2461 of file tif_dirwrite.c.
2465{
2469 {
2471 "SLONG8 not allowed for ClassicTIFF");
2472 return (0);
2473 }
2475 {
2477 return 1;
2478 }
2483}
Referenced by TIFFWriteDirectoryTagSlong8Array().
◆ TIFFWriteDirectoryTagCheckedSlongArray()
|
static |
Definition at line 2419 of file tif_dirwrite.c.
2423{
2427 {
2429 return 1;
2430 }
2435}
Referenced by TIFFWriteDirectoryTagSlong8Array(), and TIFFWriteDirectoryTagSlongArray().
◆ TIFFWriteDirectoryTagCheckedSrationalArray()
|
static |
Definition at line 2558 of file tif_dirwrite.c.
2563{
2566 float *na;
2567 int32_t *nb;
2568 uint32_t nc;
2569 int o;
2572 {
2574 return 1;
2575 }
2578 {
2580 return (0);
2581 }
2583 {
2584 DoubleToSrational(*na, &nb[0], &nb[1]);
2585 }
2591 return (o);
2592}
static void DoubleToSrational(double value, int32_t *num, int32_t *denom)
Definition: tif_dirwrite.c:2891
Referenced by TIFFWriteDirectoryTagSrationalArray().
◆ TIFFWriteDirectoryTagCheckedSrationalDoubleArray()
|
static |
Definition at line 2631 of file tif_dirwrite.c.
2634{
2636 "TIFFWriteDirectoryTagCheckedSrationalDoubleArray";
2638 double *na;
2639 int32_t *nb;
2640 uint32_t nc;
2641 int o;
2644 {
2646 return 1;
2647 }
2650 {
2652 return (0);
2653 }
2655 {
2656 DoubleToSrational(*na, &nb[0], &nb[1]);
2657 }
2663 return (o);
2664} /*--- TIFFWriteDirectoryTagCheckedSrationalDoubleArray() -------- */
Referenced by TIFFWriteDirectoryTagSrationalDoubleArray().
◆ TIFFWriteDirectoryTagCheckedSshortArray()
|
static |
Definition at line 2364 of file tif_dirwrite.c.
2368{
2372 {
2374 return 1;
2375 }
2380}
Referenced by TIFFWriteDirectoryTagSshortArray().
◆ TIFFWriteDirectoryTagCheckedUndefinedArray()
|
static |
Definition at line 2281 of file tif_dirwrite.c.
2286{
2289 {
2291 return 1;
2292 }
2295}
Referenced by TIFFWriteDirectoryTagUndefinedArray().
◆ TIFFWriteDirectoryTagColormap()
|
static |
Definition at line 2099 of file tif_dirwrite.c.
2101{
2105 int o;
2108 {
2110 return 1;
2111 }
2112
2115 {
2117 return (0);
2118 }
2125 return (o);
2126}
static int TIFFWriteDirectoryTagCheckedShortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint16_t *value)
Definition: tif_dirwrite.c:2346
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagData()
|
static |
Definition at line 3036 of file tif_dirwrite.c.
3040{
3043 m = 0;
3045 {
3048 break;
3049 m++;
3050 }
3052 {
3056 }
3062 {
3064 {
3066 }
3067 }
3068 else
3069 {
3070 uint64_t na, nb;
3071 na = tif->tif_dataoff;
3072 nb = na + datalength;
3074 nb = (uint32_t)nb;
3075 if ((nb < na) || (nb < datalength))
3076 {
3078 return (0);
3079 }
3081 {
3083 return (0);
3084 }
3085 if (datalength >= 0x80000000UL)
3086 {
3088 "libtiff does not allow writing more than 2147483647 "
3089 "bytes in a tag");
3090 return (0);
3091 }
3093 {
3095 return (0);
3096 }
3097 tif->tif_dataoff = nb;
3099 tif->tif_dataoff++;
3101 {
3102 uint32_t o;
3103 o = (uint32_t)na;
3105 TIFFSwabLong(&o);
3107 }
3108 else
3109 {
3113 }
3114 }
3115 (*ndir)++;
3116 return (1);
3117}
Referenced by TIFFWriteDirectoryTagCheckedAscii(), TIFFWriteDirectoryTagCheckedByteArray(), TIFFWriteDirectoryTagCheckedDoubleArray(), TIFFWriteDirectoryTagCheckedFloatArray(), TIFFWriteDirectoryTagCheckedIfd8Array(), TIFFWriteDirectoryTagCheckedIfdArray(), TIFFWriteDirectoryTagCheckedLong(), TIFFWriteDirectoryTagCheckedLong8Array(), TIFFWriteDirectoryTagCheckedLongArray(), TIFFWriteDirectoryTagCheckedRational(), TIFFWriteDirectoryTagCheckedRationalArray(), TIFFWriteDirectoryTagCheckedRationalDoubleArray(), TIFFWriteDirectoryTagCheckedSbyteArray(), TIFFWriteDirectoryTagCheckedShort(), TIFFWriteDirectoryTagCheckedShortArray(), TIFFWriteDirectoryTagCheckedSlong8Array(), TIFFWriteDirectoryTagCheckedSlongArray(), TIFFWriteDirectoryTagCheckedSrationalArray(), TIFFWriteDirectoryTagCheckedSrationalDoubleArray(), TIFFWriteDirectoryTagCheckedSshortArray(), TIFFWriteDirectoryTagCheckedUndefinedArray(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFWriteDirectoryTagDoubleArray()
|
static |
Definition at line 1834 of file tif_dirwrite.c.
1837{
1839 value));
1840}
static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:2981
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagFloatArray()
|
static |
Definition at line 1826 of file tif_dirwrite.c.
1829{
1831 value));
1832}
static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:2962
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagIfdArray()
|
static |
Definition at line 1842 of file tif_dirwrite.c.
1845{
1847 value));
1848}
static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:3000
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagIfdIfd8Array()
|
static |
Definition at line 2032 of file tif_dirwrite.c.
2035{
2037 uint64_t *ma;
2038 uint32_t mb;
2041 int o;
2042
2043 /* We always write IFD8 for BigTIFF, no checking needed. */
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
2055 {
2057 return (0);
2058 }
2059
2061 {
2062 if (*ma > 0xFFFFFFFF)
2063 {
2065 "Attempt to write value larger than 0xFFFFFFFF in "
2066 "Classic TIFF file.");
2068 return (0);
2069 }
2071 }
2072
2075
2076 return (o);
2077}
static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:3017
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagLong()
|
static |
Definition at line 1628 of file tif_dirwrite.c.
1631{
1633}
static int TIFFWriteDirectoryTagCheckedLong(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t value)
Definition: tif_dirwrite.c:2382
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagLong8Array()
|
static |
Definition at line 1656 of file tif_dirwrite.c.
1659{
1661 uint64_t *ma;
1662 uint32_t mb;
1665 int o;
1666
1667 /* is this just a counting pass? */
1669 {
1670 /* only evaluate IFD data size and inc. ndir */
1673 }
1674
1675 /* We always write Long8 for BigTIFF, no checking needed. */
1679
1680 /*
1681 ** For classic tiff we want to verify everything is in range for long
1682 ** and convert to long format.
1683 */
1686 {
1688 return (0);
1689 }
1690
1692 {
1693 if (*ma > 0xFFFFFFFF)
1694 {
1697 " larger than 0xFFFFFFFF for tag %d in Classic TIFF "
1698 "file. TIFF file writing aborted",
1699 *ma, tag);
1701 return (0);
1702 }
1704 }
1705
1708
1709 return (o);
1710}
static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint64_t *value)
Definition: tif_dirwrite.c:2437
static int TIFFWriteDirectoryTagCheckedLongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint32_t *value)
Definition: tif_dirwrite.c:2401
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagLongArray()
|
static |
Definition at line 1635 of file tif_dirwrite.c.
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagLongLong8Array()
|
static |
Definition at line 1903 of file tif_dirwrite.c.
1906{
1908 int o;
1909 int write_aslong4;
1910
1912 {
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 }
1922 NULL);
1923 }
1924
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. */
1933 {
1935 }
1937 {
1939 }
1940 if (write_aslong8)
1941 {
1944 }
1945 }
1946
1947 write_aslong4 = 1;
1949 {
1951 }
1953 {
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
1965 uint64_t *ma;
1966 uint32_t mb;
1967
1969 {
1971 return (0);
1972 }
1973
1975 {
1976 if (*ma > 0xFFFFFFFF)
1977 {
1979 "Attempt to write value larger than 0xFFFFFFFF "
1980 "in LONG array.");
1982 return (0);
1983 }
1985 }
1986
1988 p);
1990 }
1991 else
1992 {
1995 uint64_t *ma;
1996 uint32_t mb;
1997
1999 {
2001 return (0);
2002 }
2003
2005 {
2006 if (*ma > 0xFFFF)
2007 {
2008 /* Should not happen normally given the check we did before */
2010 "Attempt to write value larger than 0xFFFF in "
2011 "SHORT array.");
2013 return (0);
2014 }
2016 }
2017
2019 p);
2021 }
2022
2023 return (o);
2024}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagRational()
|
static |
Definition at line 1782 of file tif_dirwrite.c.
1785{
1787}
static int TIFFWriteDirectoryTagCheckedRational(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, double value)
Definition: tif_dirwrite.c:2485
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagRationalArray()
|
static |
Definition at line 1789 of file tif_dirwrite.c.
1792{
1795}
static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:2522
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagRationalDoubleArray()
|
static |
Definition at line 1806 of file tif_dirwrite.c.
1811{
1814}
static int TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:2596
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSampleformatArray()
|
static |
Definition at line 1458 of file tif_dirwrite.c.
1462{
1464 void *conv;
1469 {
1471 return (0);
1472 }
1473
1475 {
1478 {
1482 (float *)conv);
1483 }
1484 else
1485 {
1488 }
1489 break;
1492 {
1496 (int8_t *)conv);
1497 }
1499 {
1504 }
1505 else
1506 {
1510 (int32_t *)conv);
1511 }
1512 break;
1515 {
1519 (uint8_t *)conv);
1520 }
1522 {
1526 (uint16_t *)conv);
1527 }
1528 else
1529 {
1533 (uint32_t *)conv);
1534 }
1535 break;
1536 default:
1537 ok = 0;
1538 }
1539
1540 _TIFFfreeExt(tif, conv);
1542}
static uint16_t TIFFClampDoubleToUInt16(double val)
Definition: tif_dirwrite.c:1440
static int32_t TIFFClampDoubleToInt32(double val)
Definition: tif_dirwrite.c:1422
static uint32_t TIFFClampDoubleToUInt32(double val)
Definition: tif_dirwrite.c:1449
static int16_t TIFFClampDoubleToInt16(double val)
Definition: tif_dirwrite.c:1413
static uint8_t TIFFClampDoubleToUInt8(double val)
Definition: tif_dirwrite.c:1431
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSbyteArray()
|
static |
Definition at line 1568 of file tif_dirwrite.c.
1571{
1573 value));
1574}
static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int8_t *value)
Definition: tif_dirwrite.c:2312
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagShort()
|
static |
Definition at line 1576 of file tif_dirwrite.c.
1579{
1581}
static int TIFFWriteDirectoryTagCheckedShort(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint16_t value)
Definition: tif_dirwrite.c:2327
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagShortArray()
|
static |
Definition at line 1583 of file tif_dirwrite.c.
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagShortLong()
|
static |
Definition at line 1850 of file tif_dirwrite.c.
1853{
1857 else
1859}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagShortPerSample()
|
static |
Definition at line 1591 of file tif_dirwrite.c.
1594{
1597 uint16_t *na;
1598 uint16_t nb;
1599 int o;
1601 {
1602 /* only evaluate IFD data size and inc. ndir */
1605 }
1608 {
1610 return (0);
1611 }
1613 *na = value;
1614 o = TIFFWriteDirectoryTagCheckedShortArray(
1617 return (o);
1618}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSlong8Array()
|
static |
Definition at line 1717 of file tif_dirwrite.c.
1720{
1722 int64_t *ma;
1723 uint32_t mb;
1726 int o;
1727
1728 /* is this just a counting pass? */
1730 {
1731 /* only evaluate IFD data size and inc. ndir */
1734 }
1735 /* We always write SLong8 for BigTIFF, no checking needed. */
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 */
1746 {
1748 return (0);
1749 }
1750
1752 {
1753 if (*ma > (2147483647))
1754 {
1757 " larger than 0x7FFFFFFF (2147483647) for tag %d in "
1758 "Classic TIFF file. TIFF writing to file aborted",
1759 *ma, tag);
1761 return (0);
1762 }
1763 else if (*ma < (-2147483647 - 1))
1764 {
1767 " smaller than 0x80000000 (-2147483648) for tag %d "
1768 "in Classic TIFF file. TIFF writing to file aborted",
1769 *ma, tag);
1771 return (0);
1772 }
1774 }
1775
1778
1779 return (o);
1780}
static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int32_t *value)
Definition: tif_dirwrite.c:2419
static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int64_t *value)
Definition: tif_dirwrite.c:2461
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSlongArray()
|
static |
Definition at line 1643 of file tif_dirwrite.c.
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagSrationalArray()
|
static |
Definition at line 1797 of file tif_dirwrite.c.
1800{
1803}
static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, float *value)
Definition: tif_dirwrite.c:2558
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSrationalDoubleArray()
|
static |
Definition at line 1816 of file tif_dirwrite.c.
1821{
1824}
static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, double *value)
Definition: tif_dirwrite.c:2631
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSshortArray()
|
static |
Definition at line 1620 of file tif_dirwrite.c.
1623{
1625 value));
1626}
static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, int16_t *value)
Definition: tif_dirwrite.c:2364
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagSubifd()
|
static |
Definition at line 2197 of file tif_dirwrite.c.
2199{
2204 return (1);
2207 {
2208 uint32_t *o;
2210 uint32_t *pb;
2214 {
2216 return (0);
2217 }
2219 pb = o;
2221 {
2223
2224 /* Could happen if an classicTIFF has a SubIFD of type LONG8 (which
2225 * is illegal) */
2227 {
2229 _TIFFfreeExt(tif, o);
2230 return (0);
2231 }
2233 }
2236 _TIFFfreeExt(tif, o);
2237 }
2238 else
2242
2244 /* Just have evaluated IFD data size and incremented ndir
2245 * above in sub-functions. */
2247
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 */
2261 tif->tif_subifdoff = 0;
2262 else
2264 return (1);
2265}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagTransferfunction()
|
static |
Definition at line 2128 of file tif_dirwrite.c.
2130{
2134 uint16_t *o;
2136 /* TIFFTAG_TRANSFERFUNCTION expects (1 or 3) pointer to arrays with
2137 * (1 << BitsPerSample) * uint16_t values.
2138 */
2140 /* clang-format off */
2142 /* clang-format on */
2143
2144 /* Check for proper number of transferfunctions */
2146 {
2148 {
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 */
2162 {
2169 n = 1;
2170 }
2172 {
2174 return 1;
2175 }
2176
2179 {
2181 return (0);
2182 }
2193 _TIFFfreeExt(tif, o);
2195}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagUndefinedArray()
|
static |
Definition at line 1552 of file tif_dirwrite.c.
1555{
1558}
static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF *tif, uint32_t *ndir, TIFFDirEntry *dir, uint16_t tag, uint32_t count, uint8_t *value)
Definition: tif_dirwrite.c:2281
Referenced by TIFFWriteDirectorySec().
◆ ToRationalEuclideanGCD()
|
static |
--— Rational2Double: Double To Rational Conversion
There is a mathematical theorem to convert real numbers into a rational (integer fraction) number. This is called "continuous fraction" which uses the Euclidean algorithm to find the greatest common divisor (GCD). (ref. e.g. https://de.wikipedia.org/wiki/Kettenbruch or https://en.wikipedia.org/wiki/Continued_fraction https://en.wikipedia.org/wiki/Euclidean_algorithm) The following functions implement the
- ToRationalEuclideanGCD() auxiliary function which mainly implements euclidean GCD
- DoubleToRational() conversion function for un-signed rationals
- DoubleToSrational() conversion function for signed rationals
-— ToRationalEuclideanGCD() --------------------------------------— Calculates the rational fractional of a double input value
using the Euclidean algorithm to find the greatest common divisor (GCD)
Definition at line 2687 of file tif_dirwrite.c.
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;
2698 uint64_t nMax;
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 {
2712 }
2713 else
2714 {
2715 nMax = ((9223372036854775807 - 1) / 2); /* for ULLONG range */
2716 }
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;
2748 {
2749 bigDenom <<= 1;
2750 value *= 2;
2751 }
2753
2754 /*-- Start Euclidean algorithm to find the greatest common divisor (GCD) --
2755 */
2756#define MAX_ITERATIONS 64
2758 {
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;
2776 {
2777 aux = (maxDenom - denomSum[0]) / denomSum[1];
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() -------------- */
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:91
#define MAX_ITERATIONS
Referenced by DoubleToRational(), and DoubleToSrational().
◆ WriteAsLong4()
Definition at line 1891 of file tif_dirwrite.c.
1892{
1894}
static int _WriteAsType(TIFF *tif, uint64_t strile_size, uint64_t uncompressed_threshold)
Definition: tif_dirwrite.c:1861
Referenced by _TIFFRewriteField(), and TIFFWriteDirectoryTagLongLong8Array().
◆ WriteAsLong8()
Definition at line 1886 of file tif_dirwrite.c.
Referenced by _TIFFRewriteField(), and TIFFWriteDirectoryTagLongLong8Array().
