tif_dirwrite.c File Reference
Include dependency graph for tif_dirwrite.c:
Go to the source code of this file.
Function Documentation
◆ _TIFFRewriteField()
| int _TIFFRewriteField | ( | TIFF * | tif, |
| uint16 | tag, | ||
| TIFFDataType | in_datatype, | ||
| tmsize_t | count, | ||
| void * | data | ||
| ) |
Definition at line 2824 of file tif_dirwrite.c.
2826{
2828 /* const TIFFField* fip = NULL; */
2829 uint16 dircount;
2830 tmsize_t dirsize;
2831 uint8 direntry_raw[20];
2832 uint16 entry_tag = 0;
2833 uint16 entry_type = 0;
2834 uint64 entry_count = 0;
2835 uint64 entry_offset = 0;
2836 int value_in_entry = 0;
2837 uint64 read_offset;
2839 TIFFDataType datatype;
2840
2841/* -------------------------------------------------------------------- */
2842/* Find field definition. */
2843/* -------------------------------------------------------------------- */
2845
2846/* -------------------------------------------------------------------- */
2847/* Do some checking this is a straight forward case. */
2848/* -------------------------------------------------------------------- */
2850 {
2852 "Memory mapped files not currently supported for this operation." );
2853 return 0;
2854 }
2855
2857 {
2859 "Attempt to reset field on directory not already on disk." );
2860 return 0;
2861 }
2862
2863/* -------------------------------------------------------------------- */
2864/* Read the directory entry count. */
2865/* -------------------------------------------------------------------- */
2868 "%s: Seek error accessing TIFF directory",
2869 tif->tif_name);
2870 return 0;
2871 }
2872
2873 read_offset = tif->tif_diroff;
2874
2876 {
2879 "%s: Can not read TIFF directory count",
2880 tif->tif_name);
2881 return 0;
2882 }
2884 TIFFSwabShort(&dircount);
2885 dirsize = 12;
2886 read_offset += 2;
2887 } else {
2888 uint64 dircount64;
2891 "%s: Can not read TIFF directory count",
2892 tif->tif_name);
2893 return 0;
2894 }
2896 TIFFSwabLong8(&dircount64);
2897 dircount = (uint16)dircount64;
2898 dirsize = 20;
2899 read_offset += 8;
2900 }
2901
2902/* -------------------------------------------------------------------- */
2903/* Read through directory to find target tag. */
2904/* -------------------------------------------------------------------- */
2905 while( dircount > 0 )
2906 {
2909 "%s: Can not read TIFF directory entry.",
2910 tif->tif_name);
2911 return 0;
2912 }
2913
2916 TIFFSwabShort( &entry_tag );
2917
2919 break;
2920
2921 read_offset += dirsize;
2922 }
2923
2925 {
2927 "%s: Could not find tag %d.",
2929 return 0;
2930 }
2931
2932/* -------------------------------------------------------------------- */
2933/* Extract the type, count and offset for this entry. */
2934/* -------------------------------------------------------------------- */
2937 TIFFSwabShort( &entry_type );
2938
2940 {
2942
2946 entry_count = value;
2947
2951 entry_offset = value;
2952 }
2953 else
2954 {
2957 TIFFSwabLong8( &entry_count );
2958
2961 TIFFSwabLong8( &entry_offset );
2962 }
2963
2964/* -------------------------------------------------------------------- */
2965/* When a dummy tag was written due to TIFFDeferStrileArrayWriting() */
2966/* -------------------------------------------------------------------- */
2967 if( entry_offset == 0 && entry_count == 0 && entry_type == 0 )
2968 {
2970 {
2972 }
2973 else
2974 {
2975 int write_aslong8 = 1;
2977 {
2979 }
2981 {
2983 }
2984 if( write_aslong8 )
2985 {
2986 entry_type = TIFF_LONG8;
2987 }
2988 else
2989 {
2990 int write_aslong4 = 1;
2992 {
2994 }
2996 {
2998 }
2999 if( write_aslong4 )
3000 {
3001 entry_type = TIFF_LONG;
3002 }
3003 else
3004 {
3005 entry_type = TIFF_SHORT;
3006 }
3007 }
3008 }
3009 }
3010
3011/* -------------------------------------------------------------------- */
3012/* What data type do we want to write this as? */
3013/* -------------------------------------------------------------------- */
3015 {
3019 datatype = TIFF_SLONG;
3021 datatype = TIFF_IFD;
3022 else
3023 datatype = in_datatype;
3024 }
3025 else
3026 {
3029 entry_type == TIFF_LONG8 ) )
3030 datatype = entry_type;
3033 datatype = entry_type;
3036 datatype = entry_type;
3037 else
3038 datatype = in_datatype;
3039 }
3040
3041/* -------------------------------------------------------------------- */
3042/* Prepare buffer of actual data to write. This includes */
3043/* swabbing as needed. */
3044/* -------------------------------------------------------------------- */
3045 buf_to_write =
3047 "for field buffer.");
3048 if (!buf_to_write)
3049 return 0;
3050
3051 if( datatype == in_datatype )
3054 {
3056
3058 {
3062 {
3063 _TIFFfree( buf_to_write );
3065 "Value exceeds 32bit range of output type." );
3066 return 0;
3067 }
3068 }
3069 }
3072 {
3074
3076 {
3080 {
3081 _TIFFfree( buf_to_write );
3083 "Value exceeds 32bit range of output type." );
3084 return 0;
3085 }
3086 }
3087 }
3089 {
3091
3093 {
3097 {
3098 _TIFFfree( buf_to_write );
3100 "Value exceeds 16bit range of output type." );
3101 return 0;
3102 }
3103 }
3104 }
3105 else
3106 {
3108 "Unhandled type conversion." );
3109 return 0;
3110 }
3111
3113 {
3120 }
3121
3122/* -------------------------------------------------------------------- */
3123/* Is this a value that fits into the directory entry? */
3124/* -------------------------------------------------------------------- */
3126 {
3128 {
3129 entry_offset = read_offset + 8;
3130 value_in_entry = 1;
3131 }
3132 }
3133 else
3134 {
3136 {
3137 entry_offset = read_offset + 12;
3138 value_in_entry = 1;
3139 }
3140 }
3141
3146 {
3149 }
3154 {
3157 }
3158
3159/* -------------------------------------------------------------------- */
3160/* If the tag type, and count match, then we just write it out */
3161/* over the old values without altering the directory entry at */
3162/* all. */
3163/* -------------------------------------------------------------------- */
3165 {
3167 _TIFFfree( buf_to_write );
3169 "%s: Seek error accessing TIFF directory",
3170 tif->tif_name);
3171 return 0;
3172 }
3174 _TIFFfree( buf_to_write );
3176 "Error writing directory link");
3177 return (0);
3178 }
3179
3180 _TIFFfree( buf_to_write );
3181 return 1;
3182 }
3183
3184/* -------------------------------------------------------------------- */
3185/* Otherwise, we write the new tag data at the end of the file. */
3186/* -------------------------------------------------------------------- */
3187 if( !value_in_entry )
3188 {
3190
3192 _TIFFfree( buf_to_write );
3194 "Error writing directory link");
3195 return (0);
3196 }
3197 }
3198 else
3199 {
3201 }
3202
3203 _TIFFfree( buf_to_write );
3204 buf_to_write = 0;
3205
3206/* -------------------------------------------------------------------- */
3207/* Adjust the directory entry. */
3208/* -------------------------------------------------------------------- */
3209 entry_type = datatype;
3214
3216 {
3218
3223
3228 }
3229 else
3230 {
3234
3238 }
3239
3240/* -------------------------------------------------------------------- */
3241/* Write the directory entry out to disk. */
3242/* -------------------------------------------------------------------- */
3245 "%s: Seek error accessing TIFF directory",
3246 tif->tif_name);
3247 return 0;
3248 }
3249
3251 {
3253 "%s: Can not write TIFF directory entry.",
3254 tif->tif_name);
3255 return 0;
3256 }
3257
3258 return 1;
3259}
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::@3466 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:121
const TIFFField * TIFFFindField(TIFF *tif, uint32 tag, TIFFDataType dt)
Definition: tif_dirinfo.c:506
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
void TIFFSwabArrayOfShort(register uint16 *wp, tmsize_t n)
Definition: tif_swab.c:71
void TIFFSwabArrayOfLong8(register uint64 *lp, tmsize_t n)
Definition: tif_swab.c:120
void TIFFSwabArrayOfLong(register uint32 *lp, tmsize_t n)
Definition: tif_swab.c:103
Definition: pdh_main.c:94
Referenced by TIFFForceStrileArrayWriting().
◆ _WriteAsType()
Definition at line 1700 of file tif_dirwrite.c.
1701{
1704 {
1705 return strile_size > uncompressed_threshold;
1706 }
1714 {
1715 /* For a few select compression types, we assume that in the worst */
1716 /* case the compressed size will be 10 times the uncompressed size */
1717 /* This is overly pessismistic ! */
1718 return strile_size >= uncompressed_threshold / 10;
1719 }
1720 return 1;
1721}
_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().
◆ TIFFCheckpointDirectory()
Definition at line 237 of file tif_dirwrite.c.
238{
239 int rc;
240 /* Setup the strips arrays, if they haven't already been. */
245 return rc;
246}
Definition: nsiface.idl:2307
static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone, uint64 *pdiroff)
Definition: tif_dirwrite.c:407
◆ TIFFClampDoubleToInt16()
Definition at line 1003 of file tif_dirwrite.c.
1004{
1006 return 32767;
1008 return -32768;
1010}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToInt32()
Definition at line 1012 of file tif_dirwrite.c.
1013{
1015 return 0x7FFFFFFF;
1017 return -0x7FFFFFFF-1;
1019}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToInt8()
Definition at line 994 of file tif_dirwrite.c.
995{
997 return 127;
999 return -128;
1001}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToUInt16()
Definition at line 1030 of file tif_dirwrite.c.
1031{
1033 return 0;
1035 return 65535;
1037}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToUInt32()
Definition at line 1039 of file tif_dirwrite.c.
1040{
1042 return 0;
1044 return 0xFFFFFFFFU;
1046}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFClampDoubleToUInt8()
Definition at line 1021 of file tif_dirwrite.c.
1022{
1024 return 0;
1026 return 255;
1028}
Referenced by TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFCvtNativeToIEEEDouble()
Referenced by TIFFWriteDirectoryTagCheckedDoubleArray().
◆ TIFFCvtNativeToIEEEFloat()
Referenced by TIFFWriteDirectoryTagCheckedFloatArray().
◆ TIFFDeferStrileArrayWriting()
Definition at line 210 of file tif_dirwrite.c.
211{
214 {
216 "File opened in read-only mode");
217 return 0;
218 }
220 {
222 "Directory has already been written");
223 return 0;
224 }
225
227 return 1;
228}
unsigned char td_deferstrilearraywriting
Definition: tif_dir.h:124
◆ TIFFLinkDirectory()
Definition at line 2622 of file tif_dirwrite.c.
2623{
2625
2627
2628 /*
2629 * Handle SubIFDs
2630 */
2632 {
2634 {
2642 "Error writing SubIFD directory link");
2643 return (0);
2644 }
2645 /*
2646 * Advance to the next SubIFD or, if this is
2647 * the last one configured, revert back to the
2648 * normal directory linkage.
2649 */
2651 tif->tif_subifdoff += 4;
2652 else
2653 tif->tif_flags &= ~TIFF_INSUBIFD;
2654 return (1);
2655 }
2656 else
2657 {
2665 "Error writing SubIFD directory link");
2666 return (0);
2667 }
2668 /*
2669 * Advance to the next SubIFD or, if this is
2670 * the last one configured, revert back to the
2671 * normal directory linkage.
2672 */
2674 tif->tif_subifdoff += 8;
2675 else
2676 tif->tif_flags &= ~TIFF_INSUBIFD;
2677 return (1);
2678 }
2679 }
2680
2682 {
2684 uint32 nextdir;
2689 /*
2690 * First directory, overwrite offset in header.
2691 */
2696 "Error writing TIFF header");
2697 return (0);
2698 }
2699 return (1);
2700 }
2701 /*
2702 * Not the first directory, search to the last and append.
2703 */
2705 while(1) {
2706 uint16 dircount;
2707 uint32 nextnextdir;
2708
2710 !ReadOK(tif, &dircount, 2)) {
2712 "Error fetching directory count");
2713 return (0);
2714 }
2716 TIFFSwabShort(&dircount);
2718 nextdir+2+dircount*12, SEEK_SET);
2721 "Error fetching directory link");
2722 return (0);
2723 }
2725 TIFFSwabLong(&nextnextdir);
2726 if (nextnextdir==0)
2727 {
2729 nextdir+2+dircount*12, SEEK_SET);
2732 "Error writing directory link");
2733 return (0);
2734 }
2735 break;
2736 }
2737 nextdir=nextnextdir;
2738 }
2739 }
2740 else
2741 {
2743 uint64 nextdir;
2748 /*
2749 * First directory, overwrite offset in header.
2750 */
2755 "Error writing TIFF header");
2756 return (0);
2757 }
2758 return (1);
2759 }
2760 /*
2761 * Not the first directory, search to the last and append.
2762 */
2764 while(1) {
2765 uint64 dircount64;
2766 uint16 dircount;
2767 uint64 nextnextdir;
2768
2770 !ReadOK(tif, &dircount64, 8)) {
2772 "Error fetching directory count");
2773 return (0);
2774 }
2776 TIFFSwabLong8(&dircount64);
2777 if (dircount64>0xFFFF)
2778 {
2780 "Sanity check on tag count failed, likely corrupt TIFF");
2781 return (0);
2782 }
2783 dircount=(uint16)dircount64;
2785 nextdir+8+dircount*20, SEEK_SET);
2788 "Error fetching directory link");
2789 return (0);
2790 }
2792 TIFFSwabLong8(&nextnextdir);
2793 if (nextnextdir==0)
2794 {
2796 nextdir+8+dircount*20, SEEK_SET);
2799 "Error writing directory link");
2800 return (0);
2801 }
2802 break;
2803 }
2804 nextdir=nextnextdir;
2805 }
2806 }
2807 return (1);
2808}
union tiff::@3468 tif_header
Referenced by TIFFWriteDirectorySec().
◆ TIFFRewriteDirectory()
Definition at line 261 of file tif_dirwrite.c.
262{
264
265 /* We don't need to do anything special if it hasn't been written. */
268
269 /*
270 * Find and zero the pointer to this directory, so that TIFFLinkDirectory
271 * will cause it to be added after this directories current pre-link.
272 */
273
275 {
277 {
279 tif->tif_diroff = 0;
280
283 {
285 "Error updating TIFF header");
286 return (0);
287 }
288 }
289 else
290 {
291 uint32 nextdir;
293 while(1) {
294 uint16 dircount;
295 uint32 nextnextdir;
296
298 !ReadOK(tif, &dircount, 2)) {
300 "Error fetching directory count");
301 return (0);
302 }
304 TIFFSwabShort(&dircount);
306 nextdir+2+dircount*12, SEEK_SET);
309 "Error fetching directory link");
310 return (0);
311 }
313 TIFFSwabLong(&nextnextdir);
315 {
317 m=0;
319 nextdir+2+dircount*12, SEEK_SET);
322 "Error writing directory link");
323 return (0);
324 }
325 tif->tif_diroff=0;
326 break;
327 }
328 nextdir=nextnextdir;
329 }
330 }
331 }
332 else
333 {
335 {
337 tif->tif_diroff = 0;
338
341 {
343 "Error updating TIFF header");
344 return (0);
345 }
346 }
347 else
348 {
349 uint64 nextdir;
351 while(1) {
352 uint64 dircount64;
353 uint16 dircount;
354 uint64 nextnextdir;
355
357 !ReadOK(tif, &dircount64, 8)) {
359 "Error fetching directory count");
360 return (0);
361 }
363 TIFFSwabLong8(&dircount64);
364 if (dircount64>0xFFFF)
365 {
367 "Sanity check on tag count failed, likely corrupt TIFF");
368 return (0);
369 }
370 dircount=(uint16)dircount64;
372 nextdir+8+dircount*20, SEEK_SET);
375 "Error fetching directory link");
376 return (0);
377 }
379 TIFFSwabLong8(&nextnextdir);
381 {
383 m=0;
385 nextdir+8+dircount*20, SEEK_SET);
388 "Error writing directory link");
389 return (0);
390 }
391 tif->tif_diroff=0;
392 break;
393 }
394 nextdir=nextnextdir;
395 }
396 }
397 }
398
399 /*
400 * Now use TIFFWriteDirectory() normally.
401 */
402
404}
Referenced by TIFFFlush().
◆ TIFFWriteCustomDirectory()
Definition at line 249 of file tif_dirwrite.c.
◆ TIFFWriteDirectory()
Definition at line 180 of file tif_dirwrite.c.
Referenced by TIFFRewriteDirectory().
◆ TIFFWriteDirectorySec()
|
static |
Definition at line 407 of file tif_dirwrite.c.
408{
410 uint32 ndir;
412 uint32 dirsize;
413 void* dirmem;
416 return (1);
417
418 _TIFFFillStriles( tif );
419
420 /*
421 * Clear write state so that subsequent images with
422 * different characteristics get the right buffers
423 * setup for them.
424 */
425 if (imagedone)
426 {
428 {
429 tif->tif_flags &= ~TIFF_POSTENCODE;
431 {
433 "Error post-encoding before directory write");
434 return (0);
435 }
436 }
438 /*
439 * Flush any data that might have been written
440 * by the compression close+cleanup routines. But
441 * be careful not to write stuff if we didn't add data
442 * in the previous steps as the "rawcc" data may well be
443 * a previously read tile/strip in mixed read/write mode.
444 */
447 {
449 {
451 "Error flushing data before directory write");
452 return (0);
453 }
454 }
456 {
459 tif->tif_rawcc = 0;
460 tif->tif_rawdatasize = 0;
461 tif->tif_rawdataoff = 0;
462 tif->tif_rawdataloaded = 0;
463 }
465 }
467 dirmem=NULL;
468 dirsize=0;
469 while (1)
470 {
471 ndir=0;
472 if (isimage)
473 {
475 {
476 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH,tif->tif_dir.td_imagewidth))
477 goto bad;
478 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH,tif->tif_dir.td_imagelength))
479 goto bad;
480 }
482 {
484 goto bad;
485 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH,tif->tif_dir.td_tilelength))
486 goto bad;
487 }
489 {
490 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION,tif->tif_dir.td_xresolution))
491 goto bad;
492 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION,tif->tif_dir.td_yresolution))
493 goto bad;
494 }
496 {
498 goto bad;
500 goto bad;
501 }
503 {
505 goto bad;
506 }
508 {
509 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE,tif->tif_dir.td_bitspersample))
510 goto bad;
511 }
513 {
515 goto bad;
516 }
518 {
520 goto bad;
521 }
523 {
524 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING,tif->tif_dir.td_threshholding))
525 goto bad;
526 }
528 {
530 goto bad;
531 }
533 {
535 goto bad;
536 }
538 {
539 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL,tif->tif_dir.td_samplesperpixel))
540 goto bad;
541 }
543 {
544 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP,tif->tif_dir.td_rowsperstrip))
545 goto bad;
546 }
548 {
549 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE,tif->tif_dir.td_minsamplevalue))
550 goto bad;
551 }
553 {
554 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE,tif->tif_dir.td_maxsamplevalue))
555 goto bad;
556 }
558 {
559 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG,tif->tif_dir.td_planarconfig))
560 goto bad;
561 }
563 {
564 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT,tif->tif_dir.td_resolutionunit))
565 goto bad;
566 }
568 {
569 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER,2,&tif->tif_dir.td_pagenumber[0]))
570 goto bad;
571 }
573 {
575 {
576 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount_p))
577 goto bad;
578 }
579 else
580 {
581 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount_p))
582 goto bad;
583 }
584 }
586 {
588 {
589 /* td_stripoffset_p might be NULL in an odd OJPEG case. See
590 * tif_dirread.c around line 3634.
591 * XXX: OJPEG hack.
592 * If a) compression is OJPEG, b) it's not a tiled TIFF,
593 * and c) the number of strips is 1,
594 * then we tolerate the absence of stripoffsets tag,
595 * because, presumably, all required data is in the
596 * JpegInterchangeFormat stream.
597 * We can get here when using tiffset on such a file.
598 * See http://bugzilla.maptools.org/show_bug.cgi?id=2500
599 */
601 !TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset_p))
602 goto bad;
603 }
604 else
605 {
606 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset_p))
607 goto bad;
608 }
609 }
611 {
613 goto bad;
614 }
616 {
618 {
619 uint16 na;
620 uint16* nb;
623 goto bad;
624 }
625 }
627 {
628 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT,tif->tif_dir.td_sampleformat))
629 goto bad;
630 }
632 {
633 if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue))
634 goto bad;
635 }
637 {
638 if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue))
639 goto bad;
640 }
642 {
644 goto bad;
645 }
647 {
649 goto bad;
650 }
652 {
653 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS,2,&tif->tif_dir.td_halftonehints[0]))
654 goto bad;
655 }
657 {
658 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING,2,&tif->tif_dir.td_ycbcrsubsampling[0]))
659 goto bad;
660 }
662 {
663 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING,tif->tif_dir.td_ycbcrpositioning))
664 goto bad;
665 }
667 {
668 if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE,6,tif->tif_dir.td_refblackwhite))
669 goto bad;
670 }
672 {
674 goto bad;
675 }
677 {
678 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames))
679 goto bad;
680 }
682 {
684 goto bad;
685 }
686 {
692 {
694 {
696 {
698 char* pb;
705 goto bad;
706 }
707 break;
709 {
716 goto bad;
717 }
718 break;
720 {
727 goto bad;
728 }
729 break;
731 {
733 void* pb;
739 goto bad;
740 }
741 break;
742 default:
744 "Cannot write tag %d (%s)",
745 TIFFFieldTag(o),
747 goto bad;
748 }
749 }
750 }
751 }
752 }
754 {
758 {
761 goto bad;
762 break;
764 if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
765 goto bad;
766 break;
768 if (!TIFFWriteDirectoryTagByteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
769 goto bad;
770 break;
772 if (!TIFFWriteDirectoryTagSbyteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
773 goto bad;
774 break;
776 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
777 goto bad;
778 break;
780 if (!TIFFWriteDirectoryTagSshortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
781 goto bad;
782 break;
784 if (!TIFFWriteDirectoryTagLongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
785 goto bad;
786 break;
788 if (!TIFFWriteDirectoryTagSlongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
789 goto bad;
790 break;
792 if (!TIFFWriteDirectoryTagLong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
793 goto bad;
794 break;
796 if (!TIFFWriteDirectoryTagSlong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
797 goto bad;
798 break;
800 if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
801 goto bad;
802 break;
804 if (!TIFFWriteDirectoryTagSrationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
805 goto bad;
806 break;
808 if (!TIFFWriteDirectoryTagFloatArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
809 goto bad;
810 break;
812 if (!TIFFWriteDirectoryTagDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
813 goto bad;
814 break;
816 if (!TIFFWriteDirectoryTagIfdArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
817 goto bad;
818 break;
820 if (!TIFFWriteDirectoryTagIfdIfd8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
821 goto bad;
822 break;
823 default:
825 break;
826 }
827 }
829 break;
832 {
834 goto bad;
835 }
836 if (isimage)
837 {
839 goto bad;
840 }
841 else
844 *pdiroff=tif->tif_diroff;
846 dirsize=2+ndir*12+4;
847 else
848 dirsize=8+ndir*20+8;
853 {
855 goto bad;
856 }
858 tif->tif_dataoff++;
859 if (isimage)
860 tif->tif_curdir++;
861 }
862 if (isimage)
863 {
865 {
866 uint32 na;
867 TIFFDirEntry* nb;
869 {
870 if( na == ndir )
871 {
873 "Cannot find SubIFD tag");
874 goto bad;
875 }
877 break;
878 }
881 else
883 }
884 }
885 dirmem=_TIFFmalloc(dirsize);
887 {
889 goto bad;
890 }
892 {
894 uint32 nTmp;
895 TIFFDirEntry* o;
896 n=dirmem;
900 n+=2;
901 o=dir;
903 {
907 n+=2;
911 n+=2;
916 n+=4;
917 /* This is correct. The data has been */
918 /* swabbed previously in TIFFWriteDirectoryTagData */
920 n+=4;
921 o++;
922 }
925 TIFFSwabLong(&nTmp);
927 }
928 else
929 {
931 TIFFDirEntry* o;
932 n=dirmem;
936 n+=8;
937 o=dir;
939 {
943 n+=2;
947 n+=2;
951 n+=8;
953 n+=8;
954 o++;
955 }
959 }
963 {
965 goto bad;
966 }
968 {
970 goto bad;
971 }
972 _TIFFfree(dirmem);
973 if (imagedone)
974 {
975 TIFFFreeDirectory(tif);
976 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
977 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
978 (*tif->tif_cleanup)(tif);
979 /*
980 * Reset directory-related state for subsequent
981 * directories.
982 */
983 TIFFCreateDirectory(tif);
984 }
985 return(1);
986bad:
990 _TIFFfree(dirmem);
991 return(0);
992}
Definition: tif_dir.h:52
Definition: tif_dir.h:282
static int TIFFWriteDirectoryTagSshortArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int16 *value)
Definition: tif_dirwrite.c:1343
static int TIFFWriteDirectoryTagLong(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 value)
Definition: tif_dirwrite.c:1382
static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint64 *value)
Definition: tif_dirwrite.c:1864
static int TIFFWriteDirectoryTagSampleformatArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, double *value)
Definition: tif_dirwrite.c:1049
static int TIFFWriteDirectoryTagShortArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint16 *value)
Definition: tif_dirwrite.c:1293
static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint64 *value)
Definition: tif_dirwrite.c:1497
static int TIFFWriteDirectoryTagSrationalArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, float *value)
Definition: tif_dirwrite.c:1554
static int TIFFWriteDirectoryTagFloatArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, float *value)
Definition: tif_dirwrite.c:1576
static int TIFFWriteDirectoryTagRational(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, double value)
Definition: tif_dirwrite.c:1532
static int TIFFWriteDirectoryTagAscii(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, char *value)
Definition: tif_dirwrite.c:1156
static int TIFFWriteDirectoryTagSlongArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int32 *value)
Definition: tif_dirwrite.c:1445
static int TIFFWriteDirectoryTagIfdArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint32 *value)
Definition: tif_dirwrite.c:1663
static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2006
static int TIFFWriteDirectoryTagShortLong(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 value)
Definition: tif_dirwrite.c:1687
static int TIFFWriteDirectoryTagSbyteArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int8 *value)
Definition: tif_dirwrite.c:1243
static int TIFFWriteDirectoryTagRationalArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, float *value)
Definition: tif_dirwrite.c:1543
static int TIFFWriteDirectoryTagSubifd(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:2059
static int TIFFWriteDirectoryTagLongArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint32 *value)
Definition: tif_dirwrite.c:1393
static int TIFFWriteDirectoryTagByteArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint8 *value)
Definition: tif_dirwrite.c:1191
static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int64 *value)
Definition: tif_dirwrite.c:1521
static int TIFFWriteDirectoryTagColormap(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir)
Definition: tif_dirwrite.c:1979
static int TIFFWriteDirectoryTagDoubleArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, double *value)
Definition: tif_dirwrite.c:1625
static int TIFFWriteDirectoryTagUndefinedArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint8 *value)
Definition: tif_dirwrite.c:1167
static int TIFFWriteDirectoryTagShort(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint16 value)
Definition: tif_dirwrite.c:1282
static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint64 *value)
Definition: tif_dirwrite.c:1741
static int TIFFWriteDirectoryTagShortPerSample(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint16 value)
Definition: tif_dirwrite.c:1304
Referenced by TIFFCheckpointDirectory(), TIFFWriteCustomDirectory(), and TIFFWriteDirectory().
◆ TIFFWriteDirectoryTagAscii()
|
static |
Definition at line 1156 of file tif_dirwrite.c.
1157{
1159 {
1160 (*ndir)++;
1161 return(1);
1162 }
1164}
static int TIFFWriteDirectoryTagCheckedAscii(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, char *value)
Definition: tif_dirwrite.c:2124
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagByteArray()
|
static |
Definition at line 1191 of file tif_dirwrite.c.
1192{
1194 {
1195 (*ndir)++;
1196 return(1);
1197 }
1199}
static int TIFFWriteDirectoryTagCheckedByteArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint8 *value)
Definition: tif_dirwrite.c:2147
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagCheckedAscii()
|
static |
Definition at line 2124 of file tif_dirwrite.c.
2125{
2128}
static int TIFFWriteDirectoryTagData(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void *data)
Definition: tif_dirwrite.c:2544
Referenced by TIFFWriteDirectoryTagAscii().
◆ TIFFWriteDirectoryTagCheckedByteArray()
|
static |
Definition at line 2147 of file tif_dirwrite.c.
2148{
2151}
Referenced by TIFFWriteDirectoryTagByteArray().
◆ TIFFWriteDirectoryTagCheckedDoubleArray()
|
static |
Definition at line 2512 of file tif_dirwrite.c.
2513{
2520}
void TIFFCvtNativeToIEEEDouble(TIFF *tif, uint32 n, double *dp)
Referenced by TIFFWriteDirectoryTagDoubleArray().
◆ TIFFWriteDirectoryTagCheckedFloatArray()
|
static |
Definition at line 2487 of file tif_dirwrite.c.
2488{
2495}
void TIFFCvtNativeToIEEEFloat(TIFF *tif, uint32 n, float *fp)
void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
Definition: tif_swab.c:151
Referenced by TIFFWriteDirectoryTagFloatArray().
◆ TIFFWriteDirectoryTagCheckedIfd8Array()
|
static |
Definition at line 2533 of file tif_dirwrite.c.
2534{
2541}
Referenced by TIFFWriteDirectoryTagIfdIfd8Array(), and TIFFWriteDirectoryTagSubifd().
◆ TIFFWriteDirectoryTagCheckedIfdArray()
|
static |
Definition at line 2523 of file tif_dirwrite.c.
2524{
2530}
Referenced by TIFFWriteDirectoryTagIfdArray(), TIFFWriteDirectoryTagIfdIfd8Array(), and TIFFWriteDirectoryTagSubifd().
◆ TIFFWriteDirectoryTagCheckedLong()
|
static |
Definition at line 2214 of file tif_dirwrite.c.
2215{
2222}
Referenced by TIFFWriteDirectoryTagLong(), and TIFFWriteDirectoryTagShortLong().
◆ TIFFWriteDirectoryTagCheckedLong8Array()
|
static |
Definition at line 2275 of file tif_dirwrite.c.
2276{
2280 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedLong8Array","LONG8 not allowed for ClassicTIFF");
2281 return(0);
2282 }
2286}
Referenced by TIFFWriteDirectoryTagLong8Array(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFWriteDirectoryTagCheckedLongArray()
|
static |
Definition at line 2225 of file tif_dirwrite.c.
2226{
2232}
Referenced by TIFFWriteDirectoryTagLongArray(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFWriteDirectoryTagCheckedRational()
|
static |
Definition at line 2320 of file tif_dirwrite.c.
2321{
2326 {
2328 return 0;
2329 }
2331 {
2333 return 0;
2334 }
2336 {
2337 m[0]=0;
2338 m[1]=1;
2339 }
2341 {
2343 m[1]=1;
2344 }
2346 {
2348 m[1]=0xFFFFFFFF;
2349 }
2350 else
2351 {
2352 m[0]=0xFFFFFFFF;
2354 }
2356 {
2359 }
2361}
Referenced by TIFFWriteDirectoryTagRational().
◆ TIFFWriteDirectoryTagCheckedRationalArray()
|
static |
Definition at line 2364 of file tif_dirwrite.c.
2365{
2368 float* na;
2369 uint32* nb;
2370 uint32 nc;
2371 int o;
2375 {
2377 return(0);
2378 }
2380 {
2381 if (*na<=0.0 || *na != *na)
2382 {
2383 nb[0]=0;
2384 nb[1]=1;
2385 }
2386 else if (*na >= 0 && *na <= (float)0xFFFFFFFFU &&
2388 {
2389 nb[0]=(uint32)(*na);
2390 nb[1]=1;
2391 }
2392 else if (*na<1.0)
2393 {
2395 nb[1]=0xFFFFFFFF;
2396 }
2397 else
2398 {
2399 nb[0]=0xFFFFFFFF;
2401 }
2402 }
2407 return(o);
2408}
Referenced by TIFFWriteDirectoryTagRationalArray().
◆ TIFFWriteDirectoryTagCheckedSbyteArray()
|
static |
Definition at line 2163 of file tif_dirwrite.c.
2164{
2167}
Referenced by TIFFWriteDirectoryTagSbyteArray().
◆ TIFFWriteDirectoryTagCheckedShort()
|
static |
Definition at line 2170 of file tif_dirwrite.c.
2171{
2178}
Referenced by TIFFWriteDirectoryTagShort(), and TIFFWriteDirectoryTagShortLong().
◆ TIFFWriteDirectoryTagCheckedShortArray()
|
static |
Definition at line 2181 of file tif_dirwrite.c.
2182{
2188}
Referenced by TIFFWriteDirectoryTagColormap(), TIFFWriteDirectoryTagLongLong8Array(), TIFFWriteDirectoryTagShortArray(), TIFFWriteDirectoryTagShortPerSample(), and TIFFWriteDirectoryTagTransferfunction().
◆ TIFFWriteDirectoryTagCheckedSlong8Array()
|
static |
Definition at line 2306 of file tif_dirwrite.c.
2307{
2311 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedSlong8Array","SLONG8 not allowed for ClassicTIFF");
2312 return(0);
2313 }
2317}
Referenced by TIFFWriteDirectoryTagSlong8Array().
◆ TIFFWriteDirectoryTagCheckedSlongArray()
|
static |
Definition at line 2248 of file tif_dirwrite.c.
2249{
2255}
Referenced by TIFFWriteDirectoryTagSlongArray().
◆ TIFFWriteDirectoryTagCheckedSrationalArray()
|
static |
Definition at line 2411 of file tif_dirwrite.c.
2412{
2415 float* na;
2416 int32* nb;
2417 uint32 nc;
2418 int o;
2422 {
2424 return(0);
2425 }
2427 {
2428 if (*na<0.0)
2429 {
2431 {
2432 nb[0]=(int32)(*na);
2433 nb[1]=1;
2434 }
2435 else if (*na>-1.0)
2436 {
2438 nb[1]=0x7FFFFFFF;
2439 }
2440 else
2441 {
2442 nb[0]=-0x7FFFFFFF;
2444 }
2445 }
2446 else
2447 {
2449 {
2450 nb[0]=(int32)(*na);
2451 nb[1]=1;
2452 }
2453 else if (*na<1.0)
2454 {
2456 nb[1]=0x7FFFFFFF;
2457 }
2458 else
2459 {
2460 nb[0]=0x7FFFFFFF;
2462 }
2463 }
2464 }
2469 return(o);
2470}
Referenced by TIFFWriteDirectoryTagSrationalArray().
◆ TIFFWriteDirectoryTagCheckedSshortArray()
|
static |
Definition at line 2204 of file tif_dirwrite.c.
2205{
2211}
Referenced by TIFFWriteDirectoryTagSshortArray().
◆ TIFFWriteDirectoryTagCheckedUndefinedArray()
|
static |
Definition at line 2131 of file tif_dirwrite.c.
2132{
2135}
Referenced by TIFFWriteDirectoryTagUndefinedArray().
◆ TIFFWriteDirectoryTagColormap()
|
static |
Definition at line 1979 of file tif_dirwrite.c.
1980{
1984 int o;
1986 {
1987 (*ndir)++;
1988 return(1);
1989 }
1993 {
1995 return(0);
1996 }
2002 return(o);
2003}
static int TIFFWriteDirectoryTagCheckedShortArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint16 *value)
Definition: tif_dirwrite.c:2181
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagData()
|
static |
Definition at line 2544 of file tif_dirwrite.c.
2545{
2548 m=0;
2550 {
2553 break;
2554 m++;
2555 }
2557 {
2561 }
2567 {
2569 {
2571 }
2572 }
2573 else
2574 {
2575 uint64 na,nb;
2576 na=tif->tif_dataoff;
2577 nb=na+datalength;
2579 nb=(uint32)nb;
2580 if ((nb<na)||(nb<datalength))
2581 {
2583 return(0);
2584 }
2586 {
2588 return(0);
2589 }
2590 assert(datalength<0x80000000UL);
2592 {
2594 return(0);
2595 }
2596 tif->tif_dataoff=nb;
2598 tif->tif_dataoff++;
2600 {
2601 uint32 o;
2602 o=(uint32)na;
2604 TIFFSwabLong(&o);
2606 }
2607 else
2608 {
2612 }
2613 }
2614 (*ndir)++;
2615 return(1);
2616}
Referenced by TIFFWriteDirectoryTagCheckedAscii(), TIFFWriteDirectoryTagCheckedByteArray(), TIFFWriteDirectoryTagCheckedDoubleArray(), TIFFWriteDirectoryTagCheckedFloatArray(), TIFFWriteDirectoryTagCheckedIfd8Array(), TIFFWriteDirectoryTagCheckedIfdArray(), TIFFWriteDirectoryTagCheckedLong(), TIFFWriteDirectoryTagCheckedLong8Array(), TIFFWriteDirectoryTagCheckedLongArray(), TIFFWriteDirectoryTagCheckedRational(), TIFFWriteDirectoryTagCheckedRationalArray(), TIFFWriteDirectoryTagCheckedSbyteArray(), TIFFWriteDirectoryTagCheckedShort(), TIFFWriteDirectoryTagCheckedShortArray(), TIFFWriteDirectoryTagCheckedSlong8Array(), TIFFWriteDirectoryTagCheckedSlongArray(), TIFFWriteDirectoryTagCheckedSrationalArray(), TIFFWriteDirectoryTagCheckedSshortArray(), TIFFWriteDirectoryTagCheckedUndefinedArray(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFWriteDirectoryTagDoubleArray()
|
static |
Definition at line 1625 of file tif_dirwrite.c.
1626{
1628 {
1629 (*ndir)++;
1630 return(1);
1631 }
1633}
static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, double *value)
Definition: tif_dirwrite.c:2512
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagFloatArray()
|
static |
Definition at line 1576 of file tif_dirwrite.c.
1577{
1579 {
1580 (*ndir)++;
1581 return(1);
1582 }
1584}
static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, float *value)
Definition: tif_dirwrite.c:2487
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagIfdArray()
|
static |
Definition at line 1663 of file tif_dirwrite.c.
1664{
1666 {
1667 (*ndir)++;
1668 return(1);
1669 }
1671}
static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint32 *value)
Definition: tif_dirwrite.c:2523
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagIfdIfd8Array()
|
static |
Definition at line 1864 of file tif_dirwrite.c.
1865{
1867 uint64* ma;
1868 uint32 mb;
1871 int o;
1872
1873 /* is this just a counting pass? */
1875 {
1876 (*ndir)++;
1877 return(1);
1878 }
1879
1880 /* We always write IFD8 for BigTIFF, no checking needed. */
1884
1885 /*
1886 ** For classic tiff we want to verify everything is in range for IFD
1887 ** and convert to long format.
1888 */
1889
1892 {
1894 return(0);
1895 }
1896
1898 {
1899 if (*ma>0xFFFFFFFF)
1900 {
1902 "Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file.");
1904 return(0);
1905 }
1907 }
1908
1911
1912 return(o);
1913}
static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint64 *value)
Definition: tif_dirwrite.c:2533
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagLong()
|
static |
Definition at line 1382 of file tif_dirwrite.c.
1383{
1385 {
1386 (*ndir)++;
1387 return(1);
1388 }
1390}
static int TIFFWriteDirectoryTagCheckedLong(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 value)
Definition: tif_dirwrite.c:2214
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagLong8Array()
|
static |
Definition at line 1497 of file tif_dirwrite.c.
1498{
1500 {
1501 (*ndir)++;
1502 return(1);
1503 }
1505}
static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint64 *value)
Definition: tif_dirwrite.c:2275
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagLongArray()
|
static |
Definition at line 1393 of file tif_dirwrite.c.
1394{
1396 {
1397 (*ndir)++;
1398 return(1);
1399 }
1401}
static int TIFFWriteDirectoryTagCheckedLongArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint32 *value)
Definition: tif_dirwrite.c:2225
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagLongLong8Array()
|
static |
Definition at line 1741 of file tif_dirwrite.c.
1742{
1744 int o;
1745 int write_aslong4;
1746
1747 /* is this just a counting pass? */
1749 {
1750 (*ndir)++;
1751 return(1);
1752 }
1753
1755 {
1757 }
1758
1760 {
1761 int write_aslong8 = 1;
1762 /* In the case of ByteCounts array, we may be able to write them on */
1763 /* LONG if the strip/tilesize is not too big. */
1764 /* Also do that for count > 1 in the case someone would want to create */
1765 /* a single-strip file with a growing height, in which case using */
1766 /* LONG8 will be safer. */
1768 {
1770 }
1772 {
1774 }
1775 if( write_aslong8 )
1776 {
1779 }
1780 }
1781
1782 write_aslong4 = 1;
1784 {
1786 }
1788 {
1790 }
1791 if( write_aslong4 )
1792 {
1793 /*
1794 ** For classic tiff we want to verify everything is in range for LONG
1795 ** and convert to long format.
1796 */
1797
1800 uint64* ma;
1801 uint32 mb;
1802
1804 {
1806 return(0);
1807 }
1808
1810 {
1811 if (*ma>0xFFFFFFFF)
1812 {
1814 "Attempt to write value larger than 0xFFFFFFFF in LONG array.");
1816 return(0);
1817 }
1819 }
1820
1823 }
1824 else
1825 {
1828 uint64* ma;
1829 uint32 mb;
1830
1832 {
1834 return(0);
1835 }
1836
1838 {
1839 if (*ma>0xFFFF)
1840 {
1841 /* Should not happen normally given the check we did before */
1843 "Attempt to write value larger than 0xFFFF in SHORT array.");
1845 return(0);
1846 }
1848 }
1849
1852 }
1853
1854 return(o);
1855}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagRational()
|
static |
Definition at line 1532 of file tif_dirwrite.c.
1533{
1535 {
1536 (*ndir)++;
1537 return(1);
1538 }
1540}
static int TIFFWriteDirectoryTagCheckedRational(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, double value)
Definition: tif_dirwrite.c:2320
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagRationalArray()
|
static |
Definition at line 1543 of file tif_dirwrite.c.
1544{
1546 {
1547 (*ndir)++;
1548 return(1);
1549 }
1551}
static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, float *value)
Definition: tif_dirwrite.c:2364
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSampleformatArray()
|
static |
Definition at line 1049 of file tif_dirwrite.c.
1050{
1052 void* conv;
1057 {
1059 return (0);
1060 }
1061
1063 {
1066 {
1070 }
1071 else
1072 {
1074 }
1075 break;
1078 {
1082 }
1084 {
1088 }
1089 else
1090 {
1094 }
1095 break;
1098 {
1102 }
1104 {
1108 }
1109 else
1110 {
1114 }
1115 break;
1116 default:
1117 ok = 0;
1118 }
1119
1120 _TIFFfree(conv);
1122}
static uint32 TIFFClampDoubleToUInt32(double val)
Definition: tif_dirwrite.c:1039
static int32 TIFFClampDoubleToInt32(double val)
Definition: tif_dirwrite.c:1012
static uint8 TIFFClampDoubleToUInt8(double val)
Definition: tif_dirwrite.c:1021
static uint16 TIFFClampDoubleToUInt16(double val)
Definition: tif_dirwrite.c:1030
static int16 TIFFClampDoubleToInt16(double val)
Definition: tif_dirwrite.c:1003
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSbyteArray()
|
static |
Definition at line 1243 of file tif_dirwrite.c.
1244{
1246 {
1247 (*ndir)++;
1248 return(1);
1249 }
1251}
static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int8 *value)
Definition: tif_dirwrite.c:2163
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagShort()
|
static |
Definition at line 1282 of file tif_dirwrite.c.
1283{
1285 {
1286 (*ndir)++;
1287 return(1);
1288 }
1290}
static int TIFFWriteDirectoryTagCheckedShort(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint16 value)
Definition: tif_dirwrite.c:2170
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagShortArray()
|
static |
Definition at line 1293 of file tif_dirwrite.c.
1294{
1296 {
1297 (*ndir)++;
1298 return(1);
1299 }
1301}
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagShortLong()
|
static |
Definition at line 1687 of file tif_dirwrite.c.
1688{
1690 {
1691 (*ndir)++;
1692 return(1);
1693 }
1696 else
1698}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagShortPerSample()
|
static |
Definition at line 1304 of file tif_dirwrite.c.
1305{
1308 uint16* na;
1309 uint16 nb;
1310 int o;
1312 {
1313 (*ndir)++;
1314 return(1);
1315 }
1318 {
1320 return(0);
1321 }
1323 *na=value;
1326 return(o);
1327}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSlong8Array()
|
static |
Definition at line 1521 of file tif_dirwrite.c.
1522{
1524 {
1525 (*ndir)++;
1526 return(1);
1527 }
1529}
static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int64 *value)
Definition: tif_dirwrite.c:2306
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSlongArray()
|
static |
Definition at line 1445 of file tif_dirwrite.c.
1446{
1448 {
1449 (*ndir)++;
1450 return(1);
1451 }
1453}
static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int32 *value)
Definition: tif_dirwrite.c:2248
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagSrationalArray()
|
static |
Definition at line 1554 of file tif_dirwrite.c.
1555{
1557 {
1558 (*ndir)++;
1559 return(1);
1560 }
1562}
static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, float *value)
Definition: tif_dirwrite.c:2411
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagSshortArray()
|
static |
Definition at line 1343 of file tif_dirwrite.c.
1344{
1346 {
1347 (*ndir)++;
1348 return(1);
1349 }
1351}
static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, int16 *value)
Definition: tif_dirwrite.c:2204
Referenced by TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagSampleformatArray().
◆ TIFFWriteDirectoryTagSubifd()
|
static |
Definition at line 2059 of file tif_dirwrite.c.
2060{
2065 return(1);
2067 {
2068 (*ndir)++;
2069 return(1);
2070 }
2073 {
2074 uint32* o;
2076 uint32* pb;
2080 {
2082 return(0);
2083 }
2085 pb=o;
2087 {
2089
2090 /* Could happen if an classicTIFF has a SubIFD of type LONG8 (which is illegal) */
2092 {
2094 _TIFFfree(o);
2095 return(0);
2096 }
2098 }
2100 _TIFFfree(o);
2101 }
2102 else
2103 n=TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,tif->tif_dir.td_subifd);
2105 return(0);
2106 /*
2107 * Total hack: if this directory includes a SubIFD
2108 * tag then force the next <n> directories to be
2109 * written as ``sub directories'' of this one. This
2110 * is used to write things like thumbnails and
2111 * image masks that one wants to keep out of the
2112 * normal directory linkage access mechanism.
2113 */
2117 tif->tif_subifdoff=0;
2118 else
2120 return(1);
2121}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagTransferfunction()
|
static |
Definition at line 2006 of file tif_dirwrite.c.
2007{
2011 uint16* o;
2014 {
2015 (*ndir)++;
2016 return(1);
2017 }
2020 /*
2021 * Check if the table can be written as a single column,
2022 * or if it must be written as 3 columns. Note that we
2023 * write a 3-column tag if there are 2 samples/pixel and
2024 * a single column of data won't suffice--hmm.
2025 */
2027 n=3;
2029 {
2031 !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)))
2032 n=2;
2033 }
2035 {
2037 !_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)))
2038 n=1;
2039 }
2041 n=1;
2044 {
2046 return(0);
2047 }
2054 _TIFFfree(o);
2056}
Referenced by TIFFWriteDirectorySec().
◆ TIFFWriteDirectoryTagUndefinedArray()
|
static |
Definition at line 1167 of file tif_dirwrite.c.
1168{
1170 {
1171 (*ndir)++;
1172 return(1);
1173 }
1175}
static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF *tif, uint32 *ndir, TIFFDirEntry *dir, uint16 tag, uint32 count, uint8 *value)
Definition: tif_dirwrite.c:2131
Referenced by TIFFWriteDirectorySec().
◆ WriteAsLong4()
Definition at line 1728 of file tif_dirwrite.c.
1729{
1731}
static int _WriteAsType(TIFF *tif, uint64 strile_size, uint64 uncompressed_threshold)
Definition: tif_dirwrite.c:1700
Referenced by _TIFFRewriteField(), and TIFFWriteDirectoryTagLongLong8Array().
◆ WriteAsLong8()
Definition at line 1723 of file tif_dirwrite.c.
Referenced by _TIFFRewriteField(), and TIFFWriteDirectoryTagLongLong8Array().
