Include dependency graph for tiffio.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | TIFFDisplay |
| struct | TIFFYCbCrToRGB |
| struct | TIFFCIELabToRGB |
| struct | _TIFFRGBAImage |
| struct | TIFFCodec |
| struct | TIFFRational_t |
| struct | TIFFTagMethods |
| struct | TIFFFieldInfo |
Macro Definition Documentation
◆ CIELABTORGB_TABLE_RANGE
◆ D50_X0
◆ D50_Y0
◆ D50_Z0
◆ D65_X0
◆ D65_Y0
◆ D65_Z0
◆ FIELD_CUSTOM
◆ LOGLUV_PUBLIC
◆ TIFF_ANY
| #define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */ |
◆ TIFF_ATTRIBUTE
◆ TIFF_SPP
◆ TIFF_TMSIZE_T_MAX
◆ TIFF_VARIABLE
◆ TIFF_VARIABLE2
◆ TIFFGetA
◆ TIFFGetB
◆ TIFFGetG
◆ TIFFGetR
◆ TIFFPRINT_COLORMAP
◆ TIFFPRINT_CURVES
◆ TIFFPRINT_JPEGACTABLES
◆ TIFFPRINT_JPEGDCTABLES
◆ TIFFPRINT_JPEGQTABLES
◆ TIFFPRINT_NONE
◆ TIFFPRINT_STRIPS
◆ U_NEU
◆ UVSCALE
◆ V_NEU
Typedef Documentation
◆ tdata_t
◆ tdir_t
◆ thandle_t
◆ TIFF
◆ TIFFCloseProc
◆ TIFFErrorHandler
◆ TIFFErrorHandlerExt
◆ TIFFErrorHandlerExtR
◆ TIFFExtendProc
◆ TIFFField
| typedef struct _TIFFField TIFFField |
◆ TIFFFieldArray
| typedef struct _TIFFFieldArray TIFFFieldArray |
◆ TIFFInitMethod
◆ TIFFMapFileProc
◆ TIFFOpenOptions
| typedef typedefvoid void struct TIFFOpenOptions TIFFOpenOptions |
◆ TIFFPrintMethod
◆ TIFFReadWriteProc
◆ TIFFRGBAImage
| typedef struct _TIFFRGBAImage TIFFRGBAImage |
◆ TIFFRGBValue
| typedef unsigned char TIFFRGBValue |
◆ TIFFSeekProc
◆ TIFFSizeProc
◆ TIFFUnmapFileProc
◆ TIFFVGetMethod
◆ TIFFVSetMethod
◆ tileContigRoutine
◆ tileSeparateRoutine
◆ tmsize_t
| typedef TIFF_SSIZE_T tmsize_t |
◆ toff_t
◆ tsample_t
◆ tsize_t
◆ tstrile_t
◆ tstrip_t
◆ ttag_t
◆ ttile_t
Function Documentation
◆ _TIFFcalloc()
Definition at line 341 of file tif_unix.c.
342{
343 if (nmemb == 0 || siz == 0)
345
347}
Referenced by _TIFFcallocExt(), and TIFFOpenOptionsAlloc().
◆ _TIFFfree()
Definition at line 349 of file tif_unix.c.
Referenced by _TIFFfreeExt(), TIFFOpenOptionsFree(), and TIFFOpenWExt().
◆ _TIFFmalloc()
Definition at line 333 of file tif_unix.c.
334{
337
339}
Referenced by _TIFFmallocExt(), and TIFFOpenWExt().
◆ _TIFFmemcmp()
Definition at line 360 of file tif_unix.c.
361{
363}
Referenced by TIFFWriteDirectoryTagTransferfunction().
◆ _TIFFmemcpy()
Definition at line 355 of file tif_unix.c.
356{
358}
Referenced by _TIFFVSetField(), DumpModeDecode(), DumpModeEncode(), fpAcc(), fpDiff(), setByteArray(), TIFFAdvanceDirectory(), TIFFCIELabToRGBInit(), TIFFClientOpenExt(), TIFFDefaultTransferFunction(), TIFFFetchDirectory(), TIFFFetchNormalTag(), TIFFFetchStripThing(), TIFFGetConfiguredCODECs(), TIFFReadDirectory(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryData(), TIFFReadRawStrip1(), TIFFReadRawTile1(), TIFFRGBAImageBegin(), TIFFWriteDirectorySec(), TIFFWriteDirectoryTagColormap(), TIFFWriteDirectoryTagData(), and TIFFWriteDirectoryTagTransferfunction().
◆ _TIFFmemset()
Definition at line 353 of file tif_unix.c.
Referenced by _TIFFCreateAnonField(), _TIFFFillStrilesInternal(), _TIFFReadEncodedStripAndAllocBuffer(), _TIFFReadEncodedTileAndAllocBuffer(), _TIFFVSetField(), TIFFClientOpenExt(), TIFFDefaultDirectory(), TIFFFetchStripThing(), TIFFFreeDirectory(), TIFFGetConfiguredCODECs(), TIFFGrowStrips(), TIFFReadRGBATileExt(), TIFFSetupStrips(), and TIFFYCbCrToRGBInit().
◆ _TIFFrealloc()
◆ LogL10fromY()
◆ LogL10toY()
◆ LogL16fromY()
◆ LogL16toY()
◆ LogLuv24fromXYZ()
◆ LogLuv24toXYZ()
◆ LogLuv32fromXYZ()
◆ LogLuv32toXYZ()
◆ TIFFAccessTagMethods()
| TIFFTagMethods * TIFFAccessTagMethods | ( | TIFF * | tif | ) |
Definition at line 58 of file tif_extension.c.
60{
62}
◆ 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
◆ TIFFCheckTile()
Definition at line 71 of file tif_tile.c.
72{
74
76 {
79 return (0);
80 }
82 {
86 return (0);
87 }
89 {
92 return (0);
93 }
96 {
100 return (0);
101 }
102 return (1);
103}
Definition: tif_dir.h:78
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_error.c:107
Referenced by _TIFFReadTileAndAllocBuffer(), TIFFReadTile(), and TIFFWriteTile().
◆ TIFFCIELabToRGBInit()
| int TIFFCIELabToRGBInit | ( | TIFFCIELabToRGB * | cielab, |
| const TIFFDisplay * | display, | ||
| float * | refWhite | ||
| ) |
Definition at line 135 of file tif_color.c.
137{
139 double dfGamma;
140
142
144
145 /* Red */
147 cielab->rstep =
150 {
153 }
154
155 /* Green */
157 cielab->gstep =
160 {
163 }
164
165 /* Blue */
167 cielab->bstep =
170 {
173 }
174
175 /* Init reference white point */
176 cielab->X0 = refWhite[0];
177 cielab->Y0 = refWhite[1];
178 cielab->Z0 = refWhite[2];
179
180 return 0;
181}
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
static float(__cdecl *square_half_float)(float x
Definition: tiffio.h:141
Referenced by initCIELabConversion().
◆ TIFFCIELabToXYZ()
| void TIFFCIELabToXYZ | ( | TIFFCIELabToRGB * | cielab, |
| uint32_t | l, | ||
| int32_t | a, | ||
| int32_t | b, | ||
| float * | X, | ||
| float * | Y, | ||
| float * | Z | ||
| ) |
Definition at line 43 of file tif_color.c.
45{
47}
Definition: rawriter_test.cpp:12
#define Z(I)
#define Y(I)
void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b, float *X, float *Y, float *Z)
Definition: tif_color.c:55
Referenced by DECLAREContigPutFunc().
◆ TIFFCleanup()
Auxiliary function to free the TIFF structure. Given structure will be completely freed, so you should save opened file handle and pointer to the close procedure in external variables before calling _TIFFCleanup(), if you will need these ones to close the file.
- Parameters
-
tif A TIFF pointer.
Definition at line 44 of file tif_close.c.
45{
46 /*
47 * Flush buffered data and directory (if dirty).
48 */
50 TIFFFlush(tif);
51 TIFFFreeDirectory(tif);
52
53 _TIFFCleanupIFDOffsetAndNumberMaps(tif);
54
55 /*
56 * Clean up client info links.
57 */
59 {
61
64 _TIFFfreeExt(tif, psLink);
65 }
66
71
72 /*
73 * Clean up custom fields.
74 */
76 {
78
80 {
83 {
85 /* caution: tif_fields[i] must not be the beginning of a
86 * fields-array. Otherwise the following tags are also freed
87 * with the first free().
88 */
89 TIFFFieldIsAnonymous(fld))
90 {
92 _TIFFfreeExt(tif, fld);
93 }
94 }
95 }
96
98 }
99
101 {
103
105 {
108 }
110 }
111
113 {
116 "should be 0",
118 }
119
121}
Definition: tif_dir.h:331
Definition: tiffiop.h:75
void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif)
Definition: tif_close.c:127
Referenced by TIFFClientOpenExt(), and TIFFClose().
◆ TIFFClientdata()
Definition at line 828 of file tif_open.c.
◆ TIFFClientOpen()
| TIFF * TIFFClientOpen | ( | const char * | name, |
| const char * | mode, | ||
| thandle_t | clientdata, | ||
| TIFFReadWriteProc | readproc, | ||
| TIFFReadWriteProc | writeproc, | ||
| TIFFSeekProc | seekproc, | ||
| TIFFCloseProc | closeproc, | ||
| TIFFSizeProc | sizeproc, | ||
| TIFFMapFileProc | mapproc, | ||
| TIFFUnmapFileProc | unmapproc | ||
| ) |
Definition at line 289 of file tif_open.c.
294{
296 seekproc, closeproc, sizeproc, mapproc, unmapproc,
297 NULL);
298}
static BOOL readproc(HANDLE proc, LPVOID address, PVOID target, DWORD size)
Definition: env.c:217
TIFF * TIFFClientOpenExt(const char *name, const char *mode, thandle_t clientdata, TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc, TIFFSeekProc seekproc, TIFFCloseProc closeproc, TIFFSizeProc sizeproc, TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc, TIFFOpenOptions *opts)
Definition: tif_open.c:300
Referenced by _tiffStreamOpen(), and tiff_open_stream().
◆ TIFFClientOpenExt()
| TIFF * TIFFClientOpenExt | ( | const char * | name, |
| const char * | mode, | ||
| thandle_t | clientdata, | ||
| TIFFReadWriteProc | readproc, | ||
| TIFFReadWriteProc | writeproc, | ||
| TIFFSeekProc | seekproc, | ||
| TIFFCloseProc | closeproc, | ||
| TIFFSizeProc | sizeproc, | ||
| TIFFMapFileProc | mapproc, | ||
| TIFFUnmapFileProc | unmapproc, | ||
| TIFFOpenOptions * | opts | ||
| ) |
Definition at line 300 of file tif_open.c.
306{
308 TIFF *tif;
311
312 /* The following are configuration checks. They should be redundant, but
313 * should not compile to any actual code in an optimised release build
314 * anyway. If any of them fail, (makefile-based or other) configuration is
315 * not correct */
324 {
325 union
326 {
327 uint8_t a8[2];
328 uint16_t a16;
329 } n;
330 n.a8[0] = 1;
331 n.a8[1] = 0;
333#ifdef WORDS_BIGENDIAN
335#else
337#endif
338 }
339
342 goto bad2;
345 size_to_alloc > opts->max_single_mem_alloc)
346 {
350 " byte limit defined in open options",
353 goto bad2;
354 }
356 size_to_alloc > opts->max_cumulated_mem_alloc)
357 {
361 " cumulated byte limit defined in open options",
364 goto bad2;
365 }
368 {
371 goto bad2;
372 }
379 tif->tif_curoff = 0;
382 tif->tif_clientdata = clientdata;
384 tif->tif_writeproc = writeproc;
385 tif->tif_seekproc = seekproc;
386 tif->tif_closeproc = closeproc;
387 tif->tif_sizeproc = sizeproc;
390 if (opts)
391 {
399 }
400
402 {
404 "One of the client procedures is NULL pointer.");
406 goto bad2;
407 }
408
410 /*
411 * Default is to return data MSB2LSB and enable the
412 * use of memory-mapped files and strip chopping when
413 * a file is opened read-only.
414 */
418
419#ifdef STRIPCHOP_DEFAULT
422#endif
423
424 /*
425 * Process library-specific flags in the open mode string.
426 * The following flags may be used to control intrinsic library
427 * behavior that may or may not be desirable (usually for
428 * compatibility with some application that claims to support
429 * TIFF but only supports some brain dead idea of what the
430 * vendor thinks TIFF is):
431 *
432 * 'l' use little-endian byte order for creating a file
433 * 'b' use big-endian byte order for creating a file
434 * 'L' read/write information using LSB2MSB bit order
435 * 'B' read/write information using MSB2LSB bit order
436 * 'H' read/write information using host bit order
437 * 'M' enable use of memory-mapped files when supported
438 * 'm' disable use of memory-mapped files
439 * 'C' enable strip chopping support when reading
440 * 'c' disable strip chopping support
441 * 'h' read TIFF header only, do not load the first IFD
442 * '4' ClassicTIFF for creating a file (default)
443 * '8' BigTIFF for creating a file
444 * 'D' enable use of deferred strip/tile offset/bytecount array loading.
445 * 'O' on-demand loading of values instead of whole array loading (implies
446 * D)
447 *
448 * The use of the 'l' and 'b' flags is strongly discouraged.
449 * These flags are provided solely because numerous vendors,
450 * typically on the PC, do not correctly support TIFF; they
451 * only support the Intel little-endian byte order. This
452 * support is not configured by default because it supports
453 * the violation of the TIFF spec that says that readers *MUST*
454 * support both byte orders. It is strongly recommended that
455 * you not use this feature except to deal with busted apps
456 * that write invalid TIFF. And even in those cases you should
457 * bang on the vendors to fix their software.
458 *
459 * The 'L', 'B', and 'H' flags are intended for applications
460 * that can optimize operations on data by using a particular
461 * bit order. By default the library returns data in MSB2LSB
462 * bit order for compatibility with older versions of this
463 * library. Returning data in the bit order of the native CPU
464 * makes the most sense but also requires applications to check
465 * the value of the FillOrder tag; something they probably do
466 * not do right now.
467 *
468 * The 'M' and 'm' flags are provided because some virtual memory
469 * systems exhibit poor behavior when large images are mapped.
470 * These options permit clients to control the use of memory-mapped
471 * files on a per-file basis.
472 *
473 * The 'C' and 'c' flags are provided because the library support
474 * for chopping up large strips into multiple smaller strips is not
475 * application-transparent and as such can cause problems. The 'c'
476 * option permits applications that only want to look at the tags,
477 * for example, to get the unadulterated TIFF tag information.
478 */
481 {
482 case 'b':
483#ifndef WORDS_BIGENDIAN
486#endif
487 break;
488 case 'l':
489#ifdef WORDS_BIGENDIAN
492#endif
493 break;
494 case 'B':
495 tif->tif_flags =
497 break;
498 case 'L':
499 tif->tif_flags =
501 break;
502 case 'H':
504 "H(ost) mode is deprecated. Since "
505 "libtiff 4.5.1, it is an alias of 'B' / "
506 "FILLORDER_MSB2LSB.");
507 tif->tif_flags =
509 break;
510 case 'M':
513 break;
514 case 'm':
516 tif->tif_flags &= ~TIFF_MAPPED;
517 break;
518 case 'C':
521 break;
522 case 'c':
524 tif->tif_flags &= ~TIFF_STRIPCHOP;
525 break;
526 case 'h':
528 break;
529 case '8':
532 break;
533 case 'D':
535 break;
536 case 'O':
538 tif->tif_flags |=
540 break;
541 }
542
543#ifdef DEFER_STRILE_LOAD
544 /* Compatibility with old DEFER_STRILE_LOAD compilation flag */
545 /* Probably unneeded, since to the best of my knowledge (E. Rouault) */
546 /* GDAL was the only user of this, and will now use the new 'D' flag */
548#endif
549
550 /*
551 * Read in TIFF header.
552 */
555 {
557 {
559 goto bad;
560 }
561 /*
562 * Setup header and write.
563 */
564#ifdef WORDS_BIGENDIAN
567#else
570#endif
571 TIFFHeaderUnion tif_header_swapped;
573 {
577 /* Swapped copy for writing */
582 }
583 else
584 {
590 /* Swapped copy for writing */
594 {
597 }
598 }
599 /*
600 * The doc for "fopen" for some STD_C_LIBs says that if you
601 * open a file for modify ("+"), then you must fseek (or
602 * fflush?) between any freads and fwrites. This is not
603 * necessary on most systems, but has been shown to be needed
604 * on Solaris.
605 */
609 {
611 goto bad;
612 }
613 /*
614 * Setup default directory.
615 */
617 goto bad;
618 tif->tif_diroff = 0;
619 tif->tif_lastdiroff = 0;
621 /* tif_curdircount = 0 means 'empty file opened for writing, but no IFD
622 * written yet' */
623 tif->tif_curdircount = 0;
624 return (tif);
625 }
626
627 /*
628 * Setup the byte order handling according to the opened file for reading.
629 */
633 &&
636#else
638#endif
639 )
640 {
644#else
645 )
646 {
650#endif
653 goto bad;
654 }
656 {
657#ifndef WORDS_BIGENDIAN
659#endif
660 }
661 else
662 {
663#ifdef WORDS_BIGENDIAN
665#endif
666 }
671 {
677 goto bad;
678 }
680 {
684 }
685 else
686 {
690 {
692 goto bad;
693 }
695 {
698 }
700 {
706 goto bad;
707 }
709 {
715 goto bad;
716 }
719 }
722 tif->tif_rawdatasize = 0;
723 tif->tif_rawdataoff = 0;
724 tif->tif_rawdataloaded = 0;
725
727 {
728 case 'r':
731 else
733 /*
734 * Try to use a memory-mapped file if the client
735 * has not explicitly suppressed usage with the
736 * 'm' flag in the open mode (see above).
737 */
739 {
742 {
745 }
746 else
747 tif->tif_flags &= ~TIFF_MAPPED;
748 }
749 /*
750 * Sometimes we do not want to read the first directory (for
751 * example, it may be broken) and want to proceed to other
752 * directories. I this case we use the TIFF_HEADERONLY flag to open
753 * file and return immediately after reading TIFF header.
754 * However, the pointer to TIFFSetField() and TIFFGetField()
755 * (i.e. tif->tif_tagmethods.vsetfield and
756 * tif->tif_tagmethods.vgetfield) need to be initialized, which is
757 * done in TIFFDefaultDirectory().
758 */
760 {
762 goto bad;
763 return (tif);
764 }
765
766 /*
767 * Setup initial directory.
768 */
770 {
771 return (tif);
772 }
773 break;
774 case 'a':
775 /*
776 * New directories are automatically append
777 * to the end of the directory chain when they
778 * are written out (see TIFFWriteDirectory).
779 */
781 goto bad;
782 return (tif);
783 }
784bad:
786 TIFFCleanup(tif);
787bad2:
789}
Definition: tiff.h:117
Definition: tiff.h:111
Definition: dbghelp_private.h:377
Definition: tiffiop.h:113
void _TIFFSetDefaultCompressionState(TIFF *tif)
Definition: tif_compress.c:142
void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata, const char *module, const char *fmt,...)
Definition: tif_error.c:80
int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
Definition: tif_open.c:40
int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata, const char *mode, const char *module)
Definition: tif_open.c:55
void _tiffDummyUnmapProc(thandle_t fd, void *base, toff_t size)
Definition: tif_open.c:48
void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_warning.c:80
Definition: tiffiop.h:106
Referenced by TIFFClientOpen(), and TIFFFdOpenExt().
◆ TIFFClose()
Close a previously opened TIFF file.
TIFFClose closes a file that was previously opened with TIFFOpen(). Any buffered data are flushed to the file, including the contents of the current directory (if modified); and all resources are reclaimed.
- Parameters
-
tif A TIFF pointer.
Definition at line 155 of file tif_close.c.
Referenced by tiff_decoder_destroy(), tiff_decoder_initialize(), tiff_encoder_commit_file(), and tiff_encoder_destroy().
◆ TIFFComputeStrip()
Definition at line 35 of file tif_strip.c.
36{
39 uint32_t strip;
40
42 {
44 "Cannot compute strip: RowsPerStrip is zero");
45 return 0;
46 }
49 {
51 {
53 (unsigned long)sample,
55 return (0);
56 }
58 }
59 return (strip);
60}
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
Referenced by gtStripContig(), and gtStripSeparate().
◆ TIFFComputeTile()
Definition at line 35 of file tif_tile.c.
37{
42 uint32_t tile = 1;
43
45 z = 0;
51 dz = td->td_imagedepth;
53 {
57
61 else
63 }
64 return (tile);
65}
Referenced by _TIFFReadTileAndAllocBuffer(), TIFFReadTile(), and TIFFWriteTile().
◆ TIFFCreateCustomDirectory()
| int TIFFCreateCustomDirectory | ( | TIFF * | tif, |
| const TIFFFieldArray * | infoarray | ||
| ) |
Definition at line 1704 of file tif_dir.c.
1705{
1706 /* Free previously allocated memory and setup default values. */
1707 TIFFFreeDirectory(tif);
1708 TIFFDefaultDirectory(tif);
1709
1710 /*
1711 * Reset the field definitions to match the application provided list.
1712 * Hopefully TIFFDefaultDirectory() won't have done anything irreversible
1713 * based on it's assumption this is an image directory.
1714 */
1715 _TIFFSetupFields(tif, infoarray);
1716
1717 tif->tif_diroff = 0;
1718 tif->tif_nextdiroff = 0;
1719 tif->tif_curoff = 0;
1722 /* invalidate directory index */
1724 /* invalidate IFD loop lists */
1725 _TIFFCleanupIFDOffsetAndNumberMaps(tif);
1726 /* To be able to return from SubIFD or custom-IFD to main-IFD */
1728
1729 return 0;
1730}
void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *fieldarray)
Definition: tif_dirinfo.c:513
Referenced by TIFFCreateEXIFDirectory(), and TIFFCreateGPSDirectory().
◆ TIFFCreateDirectory()
Definition at line 1689 of file tif_dir.c.
1690{
1691 /* Free previously allocated memory and setup default values. */
1692 TIFFFreeDirectory(tif);
1693 TIFFDefaultDirectory(tif);
1694 tif->tif_diroff = 0;
1695 tif->tif_nextdiroff = 0;
1696 tif->tif_curoff = 0;
1700
1701 return 0;
1702}
Referenced by TIFFWriteDirectorySec().
◆ TIFFCreateEXIFDirectory()
Definition at line 1732 of file tif_dir.c.
1733{
1737}
Definition: tif_dir.h:321
int TIFFCreateCustomDirectory(TIFF *tif, const TIFFFieldArray *infoarray)
Definition: tif_dir.c:1704
◆ TIFFCreateGPSDirectory()
◆ TIFFCurrentDirectory()
Definition at line 869 of file tif_open.c.
◆ TIFFCurrentDirOffset()
◆ TIFFCurrentRow()
Definition at line 864 of file tif_open.c.
◆ TIFFCurrentStrip()
Definition at line 874 of file tif_open.c.
◆ TIFFCurrentTile()
Definition at line 879 of file tif_open.c.
◆ TIFFDataWidth()
| int TIFFDataWidth | ( | TIFFDataType | type | ) |
Definition at line 637 of file tif_dirinfo.c.
638{
640 {
641 case 0: /* nothing */
646 return 1;
649 return 2;
654 return 4;
661 return 8;
662 default:
663 return 0; /* will return 0 for unknown types */
664 }
665}
Referenced by _TIFFRewriteField(), EstimateStripByteCounts(), EvaluateIFDdatasizeReading(), and TIFFReadDirEntryArrayWithLimit().
◆ TIFFDefaultStripSize()
Definition at line 218 of file tif_strip.c.
◆ TIFFDefaultTileSize()
Definition at line 267 of file tif_tile.c.
◆ 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
◆ TIFFError()
◆ TIFFErrorExt()
◆ TIFFErrorExtR()
◆ TIFFFdOpen()
Definition at line 209 of file tif_unix.c.
210{
212}
TIFF * TIFFFdOpenExt(int fd, const char *name, const char *mode, TIFFOpenOptions *opts)
Definition: tif_unix.c:214
◆ TIFFFdOpenExt()
Definition at line 214 of file tif_unix.c.
216{
217 TIFF *tif;
218
219 fd_as_handle_union_t fdh;
224 if (tif)
226 return (tif);
227}
static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
Definition: tif_unix.c:68
static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
Definition: tif_unix.c:198
static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
Definition: tif_unix.c:99
static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
Definition: tif_unix.c:131
static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
Definition: tif_unix.c:190
Definition: tif_unix.c:63
Referenced by TIFFFdOpen(), TIFFOpenExt(), and TIFFOpenWExt().
◆ TIFFFieldDataType()
| TIFFDataType TIFFFieldDataType | ( | const TIFFField * | fip | ) |
Definition at line 871 of file tif_dirinfo.c.
◆ TIFFFieldIsAnonymous()
Definition at line 879 of file tif_dirinfo.c.
Referenced by _TIFFPrettyPrintField(), _TIFFPrintField(), _TIFFSetupFields(), TIFFCleanup(), and TIFFReadCustomDirectory().
◆ TIFFFieldName()
Definition at line 869 of file tif_dirinfo.c.
◆ TIFFFieldPassCount()
Definition at line 873 of file tif_dirinfo.c.
◆ TIFFFieldReadCount()
Definition at line 875 of file tif_dirinfo.c.
◆ TIFFFieldSetGetCountSize()
Definition at line 757 of file tif_dirinfo.c.
758{
760 return 0;
761
763 {
776 return 2;
789 return 4;
790 default:
791 return 0;
792 }
793} /*-- TIFFFieldSetGetCountSize() --- */
◆ TIFFFieldSetGetSize()
Definition at line 673 of file tif_dirinfo.c.
674{
675 /*
676 * TIFFSetField() and TIFFGetField() must provide the parameter accordingly
677 * to the definition of "set_get_field_type" of the tag definition in
678 * dir_info.c. This function returns the data size for that purpose.
679 *
680 * Furthermore, this data size is also used for the internal storage,
681 * even for TIFF_RATIONAL values for FIELD_CUSTOM, which are stored
682 * internally as 4-byte float, but some of them should be stored internally
683 * as 8-byte double, depending on the "set_get_field_type" _FLOAT_ or
684 * _DOUBLE_.
685 */
687 return 0;
688
690 {
697 return 1;
706 return 1;
715 return 2;
730 return 4;
747 return 8;
748 default:
749 return 0;
750 }
751} /*-- TIFFFieldSetGetSize() --- */
Referenced by _TIFFPrintField(), _TIFFVGetField(), _TIFFVSetField(), TIFFPrintDirectory(), and TIFFWriteDirectorySec().
◆ TIFFFieldTag()
◆ TIFFFieldWithName()
Definition at line 856 of file tif_dirinfo.c.
857{
859 if (!fip)
860 {
862 field_name);
863 }
864 return (fip);
865}
static const TIFFField * _TIFFFindFieldByName(TIFF *tif, const char *field_name, TIFFDataType dt)
Definition: tif_dirinfo.c:818
◆ TIFFFieldWithTag()
Definition at line 845 of file tif_dirinfo.c.
846{
848 if (!fip)
849 {
852 }
853 return (fip);
854}
Definition: ecma_167.h:138
const TIFFField * TIFFFindField(TIFF *tif, uint32_t tag, TIFFDataType dt)
Definition: tif_dirinfo.c:795
Referenced by _TIFFVSetField(), CheckDirCount(), TIFFFetchStripThing(), TIFFPrintDirectory(), TIFFReadDirectory(), and TIFFUnsetField().
◆ TIFFFieldWriteCount()
Definition at line 877 of file tif_dirinfo.c.
◆ TIFFFileName()
Definition at line 798 of file tif_open.c.
Referenced by _TIFFReadEncodedStripAndAllocBuffer(), _TIFFReadEncodedTileAndAllocBuffer(), buildMap(), gtStripContig(), gtStripSeparate(), gtTileContig(), gtTileSeparate(), makebwmap(), makecmap(), setupMap(), TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), and TIFFRGBAImageGet().
◆ TIFFFileno()
Definition at line 813 of file tif_open.c.
◆ TIFFFindCODEC()
Definition at line 192 of file tif_compress.c.
Referenced by _notConfigured(), TIFFIsCODECConfigured(), TIFFNoDecode(), TIFFNoEncode(), TIFFPrintDirectory(), and TIFFSetCompressionScheme().
◆ TIFFFindField()
| const TIFFField * TIFFFindField | ( | TIFF * | tif, |
| uint32_t | tag, | ||
| TIFFDataType | dt | ||
| ) |
Definition at line 795 of file tif_dirinfo.c.
796{
803
804 /* If we are invoked with no field information, then just return. */
807
808 /* NB: use sorted search (e.g. binary search) */
809
811 key.field_type = dt;
812
816}
Referenced by _TIFFFindOrRegisterField(), _TIFFMergeFields(), _TIFFRewriteField(), _TIFFVGetField(), _TIFFVSetField(), OkToChangeTag(), TIFFFieldWithTag(), and TIFFVGetField().
◆ TIFFFlush()
Definition at line 30 of file tif_flush.c.
31{
33 return 1;
34
36 return (0);
37
38 /* In update (r+) mode we try to detect the case where
39 only the strip/tile map has been altered, and we try to
40 rewrite only that portion of the directory without
41 making any other changes */
42
45 {
47 return 1;
48 }
49
51 !TIFFRewriteDirectory(tif))
52 return (0);
53
54 return (1);
55}
Referenced by TIFFCleanup().
◆ TIFFFlushData()
Definition at line 146 of file tif_flush.c.
Referenced by TIFFFlush(), and TIFFWriteScanline().
◆ TIFFForceStrileArrayWriting()
Definition at line 76 of file tif_flush.c.
77{
80
82 {
84 return 0;
85 }
87 {
89 return 0;
90 }
92 {
94 "Directory has changes other than the strile arrays. "
95 "TIFFRewriteDirectory() should be called instead");
96 return 0;
97 }
98
100 {
109 {
111 "Function not called together with "
112 "TIFFDeferStrileArrayWriting()");
113 return 0;
114 }
115
117 return 0;
118 }
119
124 _TIFFRewriteField(
128 {
129 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
130 tif->tif_flags &= ~TIFF_BEENWRITING;
131 return 1;
132 }
133
134 return 0;
135}
union TIFFDirEntry::@3701 tdir_offset
int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype, tmsize_t count, void *data)
Definition: tif_dirwrite.c:3377
Referenced by TIFFFlush(), and TIFFWriteCheck().
◆ TIFFFreeDirectory()
Definition at line 1619 of file tif_dir.c.
1620{
1623
1624 (*tif->tif_cleanup)(tif);
1626 CleanupField(td_sminsamplevalue);
1627 CleanupField(td_smaxsamplevalue);
1628 CleanupField(td_colormap[0]);
1629 CleanupField(td_colormap[1]);
1630 CleanupField(td_colormap[2]);
1631 CleanupField(td_sampleinfo);
1632 CleanupField(td_subifd);
1633 CleanupField(td_inknames);
1634 CleanupField(td_refblackwhite);
1635 CleanupField(td_transferfunction[0]);
1636 CleanupField(td_transferfunction[1]);
1637 CleanupField(td_transferfunction[2]);
1638 CleanupField(td_stripoffset_p);
1639 CleanupField(td_stripbytecount_p);
1640 td->td_stripoffsetbyteallocsize = 0;
1643
1644 /* Cleanup custom tag values */
1646 {
1649 }
1650
1651 td->td_customValueCount = 0;
1652 CleanupField(td_customValues);
1653
1656
1657 /* Reset some internal parameters for IFD data size checking. */
1661 {
1665 }
1667}
Definition: tif_dir.h:54
uint32_t td_stripoffsetbyteallocsize
Definition: tif_dir.h:117
TIFFEntryOffsetAndLength * td_dirdatasize_offsets
Definition: tif_dir.h:162
Referenced by TIFFCleanup(), TIFFCreateCustomDirectory(), TIFFCreateDirectory(), TIFFReadCustomDirectory(), TIFFReadDirectory(), TIFFUnlinkDirectory(), and TIFFWriteDirectorySec().
◆ TIFFGetBitRevTable()
Definition at line 305 of file tif_swab.c.
306{
308}
◆ TIFFGetClientInfo()
Definition at line 64 of file tif_extension.c.
◆ TIFFGetCloseProc()
| TIFFCloseProc TIFFGetCloseProc | ( | TIFF * | tif | ) |
Definition at line 927 of file tif_open.c.
◆ TIFFGetConfiguredCODECs()
Get list of configured codecs, both built-in and registered by user. Caller is responsible to free this structure.
- Returns
- returns array of TIFFCodec records (the last record should be NULL) or NULL if function failed.
Definition at line 261 of file tif_compress.c.
262{
267 TIFFCodec *new_codecs;
268
270 {
271 new_codecs =
273 if (!new_codecs)
274 {
277 }
278 codecs = new_codecs;
280 i++;
281 }
283 {
285 {
288 if (!new_codecs)
289 {
292 }
293 codecs = new_codecs;
295 i++;
296 }
297 }
298
299 new_codecs =
301 if (!new_codecs)
302 {
305 }
306 codecs = new_codecs;
308
310}
◆ TIFFGetField()
Definition at line 1582 of file tif_dir.c.
1583{
1586
1591}
Referenced by gtTileContig(), gtTileSeparate(), isCCITTCompression(), tiff_decoder_get_color_context(), tiff_get_decode_info(), TIFFPrintDirectory(), TIFFRGBAImageBegin(), TIFFRGBAImageOK(), and TIFFWriteDirectorySec().
◆ TIFFGetFieldDefaulted()
Definition at line 380 of file tif_aux.c.
381{
384
389}
int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
Definition: tif_aux.c:217
Referenced by gtStripContig(), gtStripSeparate(), initCIELabConversion(), initYCbCrConversion(), PickContigCase(), PickSeparateCase(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), TIFFRGBAImageBegin(), TIFFRGBAImageOK(), TIFFScanlineSize64(), TIFFVStripSize64(), TIFFVTileSize64(), and TIFFWriteDirectorySec().
◆ TIFFGetMapFileProc()
| TIFFMapFileProc TIFFGetMapFileProc | ( | TIFF * | tif | ) |
Definition at line 937 of file tif_open.c.
◆ TIFFGetMode()
Definition at line 843 of file tif_open.c.
◆ TIFFGetReadProc()
| TIFFReadWriteProc TIFFGetReadProc | ( | TIFF * | tif | ) |
Definition at line 912 of file tif_open.c.
◆ TIFFGetSeekProc()
| TIFFSeekProc TIFFGetSeekProc | ( | TIFF * | tif | ) |
Definition at line 922 of file tif_open.c.
◆ TIFFGetSizeProc()
| TIFFSizeProc TIFFGetSizeProc | ( | TIFF * | tif | ) |
Definition at line 932 of file tif_open.c.
◆ TIFFGetStrileByteCount()
Definition at line 8366 of file tif_dirread.c.
8367{
8369}
uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile, int *pbErr)
Definition: tif_dirread.c:8373
Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), ChopUpSingleUncompressedStrip(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFRawStripSize64(), TIFFReadDirectory(), TIFFReadRawStrip(), TIFFReadRawTile(), TIFFSeek(), TIFFStartStrip(), TIFFStartTile(), and TryChopUpUncompressedBigTiff().
◆ TIFFGetStrileByteCountWithErr()
Definition at line 8373 of file tif_dirread.c.
8374{
8378 pbErr);
8379}
static uint64_t _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32_t strile, TIFFDirEntry *dirent, uint64_t **parray, int *pbErr)
Definition: tif_dirread.c:8303
Referenced by TIFFGetStrileByteCount().
◆ TIFFGetStrileOffset()
Definition at line 8349 of file tif_dirread.c.
8350{
8352}
uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile, int *pbErr)
Definition: tif_dirread.c:8356
Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFReadDirectory(), TIFFReadRawStrip1(), TIFFReadRawStripOrTile2(), TIFFReadRawTile1(), and TryChopUpUncompressedBigTiff().
◆ TIFFGetStrileOffsetWithErr()
Definition at line 8356 of file tif_dirread.c.
Referenced by TIFFGetStrileOffset().
◆ TIFFGetTagListCount()
Definition at line 34 of file tif_extension.c.
Referenced by TIFFPrintDirectory().
◆ TIFFGetTagListEntry()
Definition at line 42 of file tif_extension.c.
44{
46
49 else
51}
Referenced by TIFFPrintDirectory().
◆ TIFFGetUnmapFileProc()
| TIFFUnmapFileProc TIFFGetUnmapFileProc | ( | TIFF * | tif | ) |
Definition at line 942 of file tif_open.c.
◆ TIFFGetVersion()
Definition at line 28 of file tif_version.c.
◆ TIFFGetWriteProc()
| TIFFReadWriteProc TIFFGetWriteProc | ( | TIFF * | tif | ) |
Definition at line 917 of file tif_open.c.
◆ TIFFIsBigEndian()
Definition at line 899 of file tif_open.c.
◆ TIFFIsBigTIFF()
Definition at line 907 of file tif_open.c.
◆ TIFFIsByteSwapped()
Definition at line 884 of file tif_open.c.
Referenced by tiff_decoder_get_metadata_blocks(), and tiff_decoder_read_tile().
◆ TIFFIsCODECConfigured()
Check whether we have working codec for the specific coding scheme.
- Returns
- returns 1 if the codec is configured and working. Otherwise 0 will be returned.
Definition at line 146 of file tif_codec.c.
147{
149
151 {
152 return 0;
153 }
155 {
156 return 0;
157 }
159 {
160 return 1;
161 }
162 return 0;
163}
Referenced by _TIFFCheckFieldIsValidForCodec(), and TIFFGetConfiguredCODECs().
◆ TIFFIsMSB2LSB()
Definition at line 894 of file tif_open.c.
◆ TIFFIsTiled()
Definition at line 859 of file tif_open.c.
Referenced by PickContigCase(), PickSeparateCase(), TIFFForceStrileArrayWriting(), TIFFReadFromUserBuffer(), TIFFReadRGBAStripExt(), and TIFFReadRGBATileExt().
◆ TIFFIsUpSampled()
Definition at line 889 of file tif_open.c.
◆ TIFFLastDirectory()
◆ TIFFMergeFieldInfo()
Definition at line 1147 of file tif_dirinfo.c.
1148{
1152 size_t nfields;
1154
1156 {
1160 }
1161 else
1162 {
1165 }
1167 {
1169 return -1;
1170 }
1171 nfields = tif->tif_nfieldscompat++;
1172
1179 {
1181 return -1;
1182 }
1183
1186 {
1190 {
1191 /* The fields (field_readcount) and (field_writecount) may use the
1192 * values TIFF_VARIABLE (-1), TIFF_SPP (-2), TIFF_VARIABLE2 (-3). */
1193 TIFFErrorExtR(
1194 tif, module,
1195 "The value of field_readcount %d and field_writecount %d "
1196 "must be greater than or equal to -3.",
1198 return -1;
1199 }
1202 {
1203 /* The fields (field_readcount) and (field_writecount) may only
1204 be zero for pseudo_tags or ignored tags. */
1205 TIFFErrorExtR(
1206 tif, module,
1207 "The value of field_readcount %d and field_writecount %d "
1208 "may only be zero for field_bit = 0 (i.e. ignored tags).",
1210 return -1;
1211 }
1215 tp->field_anonymous = 0;
1216 tp->set_get_field_type =
1222 /* Define an empty static string to be passed as field_name where a NULL
1223 * pointer is passed in. Otherwise, this will lead to buffer overflow
1224 * furtheron. */
1226 {
1227 static const char *string_static_empty = "";
1229 }
1230 else
1231 {
1233 }
1235 tp++;
1236 }
1237
1239 {
1241 return -1;
1242 }
1243
1244 return 0;
1245}
Definition: notification.c:70
void * _TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:97
void * _TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:122
int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32_t n)
Definition: tif_dirinfo.c:573
static TIFFSetGetFieldType _TIFFSetGetType(TIFFDataType type, short count, unsigned char passcount)
Definition: tif_dirinfo.c:990
◆ TIFFNumberOfDirectories()
Definition at line 2032 of file tif_dir.c.
2033{
2034 uint64_t nextdiroff;
2035 tdir_t nextdirnum;
2039 else
2041 nextdirnum = 0;
2042 n = 0;
2043 while (nextdiroff != 0 &&
2045 {
2046 ++n;
2047 }
2048 /* Update number of main-IFDs in file. */
2051}
static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off, tdir_t *nextdirnum)
Definition: tif_dir.c:1838
Referenced by _TIFFGetDirNumberFromOffset(), tiff_decoder_initialize(), and TIFFWriteDirectorySec().
◆ TIFFNumberOfStrips()
Definition at line 65 of file tif_strip.c.
66{
68 uint32_t nstrips;
69
71 {
73 return 0;
74 }
76 ? 1
79 nstrips =
81 "TIFFNumberOfStrips");
82 return (nstrips);
83}
uint32_t _TIFFMultiply32(TIFF *tif, uint32_t first, uint32_t second, const char *where)
Definition: tif_aux.c:35
Referenced by TIFFReadDirectory(), and TIFFSetupStrips().
◆ TIFFNumberOfTiles()
Definition at line 108 of file tif_tile.c.
109{
114 uint32_t ntiles;
115
121 dz = td->td_imagedepth;
122 ntiles =
124 ? 0
125 : _TIFFMultiply32(
126 tif,
129 "TIFFNumberOfTiles"),
133 "TIFFNumberOfTiles");
134 return (ntiles);
135}
Referenced by TIFFReadDirectory(), and TIFFSetupStrips().
◆ TIFFOpen()
Definition at line 232 of file tif_unix.c.
233{
235}
TIFF * TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
Definition: tif_unix.c:237
◆ TIFFOpenExt()
Definition at line 237 of file tif_unix.c.
238{
241 TIFF *tif;
242
246
247/* for cygwin and mingw */
248#ifdef O_BINARY
250#endif
251
254 {
256 {
259 }
260 else
261 {
263 }
265 }
266
268 if (!tif)
270 return tif;
271}
Referenced by TIFFOpen().
◆ TIFFOpenOptionsAlloc()
| TIFFOpenOptions * TIFFOpenOptionsAlloc | ( | void | ) |
Definition at line 80 of file tif_open.c.
◆ TIFFOpenOptionsFree()
| void TIFFOpenOptionsFree | ( | TIFFOpenOptions * | opts | ) |
Definition at line 87 of file tif_open.c.
87{ _TIFFfree(opts); }
◆ TIFFOpenOptionsSetErrorHandlerExtR()
| void TIFFOpenOptionsSetErrorHandlerExtR | ( | TIFFOpenOptions * | opts, |
| TIFFErrorHandlerExtR | handler, | ||
| void * | errorhandler_user_data | ||
| ) |
Definition at line 121 of file tif_open.c.
◆ TIFFOpenOptionsSetMaxCumulatedMemAlloc()
| void TIFFOpenOptionsSetMaxCumulatedMemAlloc | ( | TIFFOpenOptions * | opts, |
| tmsize_t | max_cumulated_mem_alloc | ||
| ) |
Define a limit in bytes for the cumulated memory allocations done by libtiff on a given TIFF handle. If max_cumulated_mem_alloc is set to 0, which is the default, no other limit that the underlying _TIFFmalloc() or TIFFOpenOptionsSetMaxSingleMemAlloc() will be applied.
Definition at line 106 of file tif_open.c.
◆ TIFFOpenOptionsSetMaxSingleMemAlloc()
| void TIFFOpenOptionsSetMaxSingleMemAlloc | ( | TIFFOpenOptions * | opts, |
| tmsize_t | max_single_mem_alloc | ||
| ) |
Define a limit in bytes for a single memory allocation done by libtiff. If max_single_mem_alloc is set to 0, which is the default, no other limit that the underlying _TIFFmalloc() or TIFFOpenOptionsSetMaxCumulatedMemAlloc() will be applied.
Definition at line 94 of file tif_open.c.
◆ TIFFOpenOptionsSetWarnAboutUnknownTags()
| void TIFFOpenOptionsSetWarnAboutUnknownTags | ( | TIFFOpenOptions * | opts, |
| int | warn_about_unknown_tags | ||
| ) |
Whether a warning should be emitted when encountering a unknown tag. Default is FALSE since libtiff 4.7.1
Definition at line 115 of file tif_open.c.
◆ TIFFOpenOptionsSetWarningHandlerExtR()
| void TIFFOpenOptionsSetWarningHandlerExtR | ( | TIFFOpenOptions * | opts, |
| TIFFErrorHandlerExtR | handler, | ||
| void * | warnhandler_user_data | ||
| ) |
Definition at line 129 of file tif_open.c.
◆ TIFFPrintDirectory()
Definition at line 244 of file tif_print.c.
245{
247 char *sep;
249
253 {
255 sep = " ";
257 {
259 sep = "/";
260 }
262 {
264 sep = "/";
265 }
269 td->td_subfiletype);
270 }
272 {
278 }
280 {
286 }
288 {
290 td->td_yresolution);
292 {
294 {
297 break;
300 break;
303 break;
304 default:
307 break;
308 }
309 }
311 }
317 {
320 {
323 break;
326 break;
329 break;
332 break;
335 break;
338 break;
339 default:
342 break;
343 }
344 }
346 {
351 else
353 td->td_compression);
354 }
356 {
360 else
361 {
363 {
366 break;
369 break;
370 default:
373 break;
374 }
375 }
376 }
378 {
381 sep = "";
383 {
385 {
388 break;
391 break;
394 break;
395 default:
398 break;
399 }
400 sep = ", ";
401 }
403 }
405 {
410 sep = "";
414 {
418 sep = ", ";
419 }
421 }
423 {
425 }
427 {
430 {
433 break;
436 break;
439 break;
440 default:
443 break;
444 }
445 }
447 {
450 {
453 break;
456 break;
457 default:
459 td->td_fillorder);
460 break;
461 }
462 }
464 {
467 }
469 {
472 {
475 break;
478 break;
479 default:
482 break;
483 }
484 }
489 {
493 else
495 td->td_orientation);
496 }
500 {
504 else
506 }
512 {
520 }
522 {
530 }
532 {
535 {
538 break;
541 break;
542 default:
545 break;
546 }
547 }
552 {
555 {
562 }
563 else
565 }
567 {
574 }
576 {
579 {
583 {
589 i++)
592 }
593 }
594 else
596 }
598 {
604 }
605
606 /*
607 ** Custom tag support.
608 */
609 {
612
615 {
618 uint32_t value_count;
622 the below TIFFTAG_DOTRANGE specific case */
623
626 continue;
627
629 {
631 {
633 continue;
634 }
636 {
637 uint16_t small_value_count;
639 1)
640 continue;
641 value_count = small_value_count;
642 }
643 else
644 {
647 continue;
648 }
649 }
650 else
651 {
654 value_count = 1;
656 value_count = td->td_samplesperpixel;
657 else
658 value_count = fip->field_readcount;
661 {
662 /* TODO: This is an evil exception and should not have been
663 handled this way ... likely best if we move it into
664 the directory structure with an explicit field in
665 libtiff 4.1 and assign it a FIELD_ value */
666 raw_data = dotrange;
668 }
673 {
675 continue;
676 }
677 else
678 {
679 /*--: Rational2Double: For Rationals evaluate
680 * "set_get_field_type" to determine internal storage size.
681 */
683 raw_data = _TIFFmallocExt(tif, tv_size * value_count);
684 mem_alloc = 1;
686 {
687 _TIFFfreeExt(tif, raw_data);
688 continue;
689 }
690 }
691 }
692
693 /*
694 * Catch the tags which needs to be specially handled
695 * and pretty print them. If tag not handled in
696 * _TIFFPrettyPrintField() fall down and print it as
697 * any other tag.
698 */
701 raw_data))
703
705 _TIFFfreeExt(tif, raw_data);
706 }
707 }
708
711
713 {
715
722 }
723}
const TIFFField * TIFFFieldWithTag(TIFF *tif, uint32_t tag)
Definition: tif_dirinfo.c:845
uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile)
Definition: tif_dirread.c:8349
uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile)
Definition: tif_dirread.c:8366
uint32_t TIFFGetTagListEntry(TIFF *tif, int tag_index)
Definition: tif_extension.c:42
static int _TIFFPrettyPrintField(TIFF *tif, const TIFFField *fip, FILE *fd, uint32_t tag, uint32_t value_count, void *raw_data)
Definition: tif_print.c:151
static void _TIFFPrintField(FILE *fd, const TIFFField *fip, uint32_t value_count, void *raw_data)
Definition: tif_print.c:75
static void _TIFFprintAsciiBounded(FILE *fd, const char *cp, size_t max_chars)
Definition: tif_print.c:730
◆ TIFFRasterScanlineSize()
Definition at line 375 of file tif_strip.c.
376{
381}
tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
Definition: tif_aux.c:84
◆ TIFFRasterScanlineSize64()
Definition at line 357 of file tif_strip.c.
358{
361 uint64_t scanline;
362
363 scanline =
366 {
367 scanline =
370 }
371 else
374}
uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second, const char *where)
Definition: tif_aux.c:47
Referenced by TIFFRasterScanlineSize().
◆ TIFFRawStripSize()
Definition at line 168 of file tif_strip.c.
◆ TIFFRawStripSize64()
Definition at line 153 of file tif_strip.c.
154{
157
158 if (bytecount == 0)
159 {
163 bytecount = (uint64_t)-1;
164 }
165
166 return bytecount;
167}
Referenced by TIFFRawStripSize().
◆ TIFFReadBufferSetup()
Definition at line 1375 of file tif_read.c.
1376{
1378
1380 tif->tif_flags &= ~TIFF_BUFFERMMAP;
1381
1383 {
1387 tif->tif_rawdatasize = 0;
1388 }
1389 if (bp)
1390 {
1393 tif->tif_flags &= ~TIFF_MYBUFFER;
1394 }
1395 else
1396 {
1399 {
1401 return (0);
1402 }
1403 /* Initialize to zero to avoid uninitialized buffers in case of */
1404 /* short reads (http://bugzilla.maptools.org/show_bug.cgi?id=2651) */
1405 tif->tif_rawdata =
1408 }
1410 {
1413 tif->tif_row);
1414 tif->tif_rawdatasize = 0;
1415 return (0);
1416 }
1417 return (1);
1418}
void * _TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz)
Definition: tif_open.c:201
Referenced by TIFFFillStrip(), and TIFFFillTile().
◆ TIFFReadCustomDirectory()
| int TIFFReadCustomDirectory | ( | TIFF * | tif, |
| toff_t | diroff, | ||
| const TIFFFieldArray * | infoarray | ||
| ) |
Definition at line 5278 of file tif_dirread.c.
5280{
5283 uint16_t dircount;
5284 TIFFDirEntry *dp;
5285 uint16_t di;
5287 uint32_t fii;
5288
5291 if (!dircount)
5292 {
5295 diroff);
5296 return 0;
5297 }
5299
5300 /*
5301 * Mark duplicates of any tag to be ignored (bugzilla 1994)
5302 * to avoid certain pathological problems.
5303 */
5304 {
5305 TIFFDirEntry *ma;
5306 uint16_t mb;
5308 {
5309 TIFFDirEntry *na;
5310 uint16_t nb;
5311 for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
5312 {
5314 {
5316 }
5317 }
5318 }
5319 }
5320
5321 /* Free any old stuff and reinit. */
5322 TIFFFreeDirectory(tif);
5323 /* Even if custom directories do not need the default settings of a standard
5324 * IFD, the pointer to the TIFFSetField() and TIFFGetField() (i.e.
5325 * tif->tif_tagmethods.vsetfield and tif->tif_tagmethods.vgetfield) need to
5326 * be initialized, which is done in TIFFDefaultDirectory().
5327 * After that, the field array for the custom tags needs to be setup again.
5328 */
5329 TIFFDefaultDirectory(tif);
5330 _TIFFSetupFields(tif, infoarray);
5331
5332 /* Allocate arrays for offset values outside IFD entry for IFD data size
5333 * checking. Note: Counter are reset within TIFFFreeDirectory(). */
5338 {
5339 TIFFErrorExtR(
5340 tif, module,
5341 "Failed to allocate memory for counting IFD data size at reading");
5344 return 0;
5345 }
5346
5348 {
5351 {
5353 {
5356 ") encountered",
5358 }
5362 {
5364 {
5365 TIFFWarningExtR(
5366 tif, module,
5370 }
5372 }
5373 else
5374 {
5377 }
5378 }
5380 {
5381 fip = tif->tif_fields[fii];
5384 else
5385 {
5386 /* check data type */
5389 {
5390 fii++;
5394 {
5395 fii = 0xFFFF;
5396 break;
5397 }
5398 fip = tif->tif_fields[fii];
5399 }
5400 if (fii == 0xFFFF)
5401 {
5404 " for \"%s\"; tag ignored",
5407 }
5408 else
5409 {
5410 /* check count if known in advance */
5413 {
5416 expected =
5418 else
5422 }
5423 }
5424 }
5426 {
5428 {
5431 {
5432 /* should only be called on a Exif directory */
5433 /* when exifFields[] is active */
5435 }
5436 else
5437 {
5439 }
5440 break;
5441 default:
5443 break;
5444 }
5445 } /*-- if (!dp->tdir_ignore) */
5446 }
5447 }
5448 /* Evaluate final IFD data size. */
5449 CalcFinalIFDdatasizeReading(tif, dircount);
5450
5451 /* To be able to return from SubIFD or custom-IFD to main-IFD */
5455 return 1;
5456}
Definition: tif_dir.h:69
TIFFField * _TIFFCreateAnonField(TIFF *tif, uint32_t tag, TIFFDataType field_type)
Definition: tif_dirinfo.c:898
static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16_t tagid, uint32_t *fii)
Definition: tif_dirread.c:5242
static int CheckDirCount(TIFF *, TIFFDirEntry *, uint32_t)
Definition: tif_dirread.c:5947
static void CalcFinalIFDdatasizeReading(TIFF *tif, uint16_t dircount)
Definition: tif_dirread.c:4160
static void TIFFReadDirectoryCheckOrder(TIFF *tif, TIFFDirEntry *dir, uint16_t dircount)
Definition: tif_dirread.c:5206
static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff, TIFFDirEntry **pdir, uint64_t *nextdiroff)
Definition: tif_dirread.c:5978
static int TIFFFetchSubjectDistance(TIFF *, TIFFDirEntry *)
Definition: tif_dirread.c:7716
static int TIFFFetchNormalTag(TIFF *, TIFFDirEntry *, int recover)
Definition: tif_dirread.c:6273
Referenced by TIFFReadEXIFDirectory(), and TIFFReadGPSDirectory().
◆ TIFFReadDirectory()
Definition at line 4236 of file tif_dirread.c.
4237{
4240 uint16_t dircount;
4241 TIFFDirEntry *dp;
4242 uint16_t di;
4245 toff_t nextdiroff;
4247 int color_channels;
4248
4250 {
4251 /* In this special case, tif_diroff needs also to be set to 0.
4252 * This is behind the last IFD, thus no checking or reading necessary.
4253 */
4255 return 0;
4256 }
4257
4258 nextdiroff = tif->tif_nextdiroff;
4259 /* tif_curdir++ and tif_nextdiroff should only be updated after SUCCESSFUL
4260 * reading of the directory. Otherwise, invalid IFD offsets could corrupt
4261 * the IFD list. */
4263 tif->tif_curdir ==
4265 ? 0
4266 : tif->tif_curdir + 1,
4267 nextdiroff))
4268 {
4269 return 0; /* bad offset (IFD looping or more than TIFF_MAX_DIR_COUNT
4270 IFDs) */
4271 }
4273 if (!dircount)
4274 {
4277 nextdiroff);
4278 return 0;
4279 }
4280 /* Set global values after a valid directory has been fetched.
4281 * tif_diroff is already set to nextdiroff in TIFFFetchDirectory() in the
4282 * beginning. */
4284 tif->tif_curdir = 0;
4285 else
4286 tif->tif_curdir++;
4287
4289
4290 /*
4291 * Mark duplicates of any tag to be ignored (bugzilla 1994)
4292 * to avoid certain pathological problems.
4293 */
4294 {
4295 TIFFDirEntry *ma;
4296 uint16_t mb;
4298 {
4299 TIFFDirEntry *na;
4300 uint16_t nb;
4301 for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
4302 {
4304 {
4306 }
4307 }
4308 }
4309 }
4310
4313 tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
4314
4315 /* free any old stuff and reinit */
4316 TIFFFreeDirectory(tif);
4317 TIFFDefaultDirectory(tif);
4318
4319 /* After setup a fresh directory indicate that now active IFD is also
4320 * present on file, even if its entries could not be read successfully
4321 * below. */
4323
4324 /* Allocate arrays for offset values outside IFD entry for IFD data size
4325 * checking. Note: Counter are reset within TIFFFreeDirectory(). */
4330 {
4331 TIFFErrorExtR(
4332 tif, module,
4333 "Failed to allocate memory for counting IFD data size at reading");
4334 goto bad;
4335 }
4336 /*
4337 * Electronic Arts writes gray-scale TIFF files
4338 * without a PlanarConfiguration directory entry.
4339 * Thus we setup a default value here, even though
4340 * the TIFF spec says there is no default value.
4341 * After PlanarConfiguration is preset in TIFFDefaultDirectory()
4342 * the following setting is not needed, but does not harm either.
4343 */
4345 /*
4346 * Setup default value and then make a pass over
4347 * the fields to check type and tag information,
4348 * and to extract info required to size data
4349 * structures. A second pass is made afterwards
4350 * to read in everything not taken in the first pass.
4351 * But we must process the Compression tag first
4352 * in order to merge in codec-private tag definitions (otherwise
4353 * we may get complaints about unknown tags). However, the
4354 * Compression tag may be dependent on the SamplesPerPixel
4355 * tag value because older TIFF specs permitted Compression
4356 * to be written as a SamplesPerPixel-count tag entry.
4357 * Thus if we don't first figure out the correct SamplesPerPixel
4358 * tag value then we may end up ignoring the Compression tag
4359 * value because it has an incorrect count value (if the
4360 * true value of SamplesPerPixel is not 1).
4361 */
4362 dp =
4364 if (dp)
4365 {
4367 goto bad;
4369 }
4371 if (dp)
4372 {
4373 /*
4374 * The 5.0 spec says the Compression tag has one value, while
4375 * earlier specs say it has one value per sample. Because of
4376 * this, we accept the tag if one value is supplied with either
4377 * count.
4378 */
4385 {
4387 goto bad;
4388 }
4390 goto bad;
4392 }
4393 else
4394 {
4396 goto bad;
4397 }
4398 /*
4399 * First real pass over the directory.
4400 */
4402 {
4404 {
4407 {
4409 {
4414 }
4415 /* the following knowingly leaks the
4416 anonymous field structure */
4420 {
4421 TIFFWarningExtR(
4422 tif, module,
4427 }
4428 else
4429 {
4432 }
4433 }
4434 }
4436 {
4437 fip = tif->tif_fields[fii];
4440 else
4441 {
4443 {
4449 break;
4460 goto bad;
4462 break;
4463 default:
4466 break;
4467 }
4468 }
4469 }
4470 }
4471 /*
4472 * XXX: OJPEG hack.
4473 * If a) compression is OJPEG, b) planarconfig tag says it's separate,
4474 * c) strip offsets/bytecounts tag are both present and
4475 * d) both contain exactly one value, then we consistently find
4476 * that the buggy implementation of the buggy compression scheme
4477 * matches contig planarconfig best. So we 'fix-up' the tag here
4478 */
4481 {
4483 goto bad;
4485 TIFFTAG_STRIPOFFSETS);
4487 {
4489 TIFFTAG_STRIPBYTECOUNTS);
4491 {
4494 "Planarconfig tag value assumed incorrect, "
4495 "assuming data is contig instead of chunky");
4496 }
4497 }
4498 }
4499 /*
4500 * Allocate directory structure and setup defaults.
4501 */
4503 {
4505 goto bad;
4506 }
4507
4508 /*
4509 * Second pass: extract other information.
4510 */
4512 {
4514 {
4516 {
4522 /*
4523 * The MinSampleValue, MaxSampleValue, BitsPerSample
4524 * DataType and SampleFormat tags are supposed to be
4525 * written as one value/sample, but some vendors
4526 * incorrectly write one value only -- so we accept
4527 * that as well (yuck). Other vendors write correct
4528 * value for NumberOfSamples, but incorrect one for
4529 * BitsPerSample and friends, and we will read this
4530 * too.
4531 */
4532 {
4537 goto bad;
4539 err =
4542 {
4547 goto bad;
4548 }
4550 goto bad;
4552 bitspersample_read = TRUE;
4553 }
4554 break;
4557 {
4558
4561 uint32_t saved_flags;
4566 else
4569 goto bad;
4571 {
4576 goto bad;
4577 }
4578 saved_flags = tif->tif_flags;
4581 tif->tif_flags = saved_flags;
4584 goto bad;
4585 }
4586 break;
4589 {
4591 {
4595 break;
4596 default:
4597 /* Warn except if directory typically created with
4598 * TIFFDeferStrileArrayWriting() */
4602 {
4604 TIFFWarningExtR(
4607 }
4608 break;
4609 }
4613 goto bad;
4614 }
4615 break;
4618 {
4620 {
4624 break;
4625 default:
4626 /* Warn except if directory typically created with
4627 * TIFFDeferStrileArrayWriting() */
4631 {
4633 TIFFWarningExtR(
4636 }
4637 break;
4638 }
4642 goto bad;
4643 }
4644 break;
4647 {
4649 uint32_t countpersample;
4650 uint32_t countrequired;
4651 uint32_t incrementpersample;
4653 /* It would be dangerous to instantiate those tag values */
4654 /* since if td_bitspersample has not yet been read (due to
4655 */
4656 /* unordered tags), it could be read afterwards with a */
4657 /* values greater than the default one (1), which may cause
4658 */
4659 /* crashes in user code */
4660 if (!bitspersample_read)
4661 {
4663 TIFFWarningExtR(
4664 tif, module,
4665 "Ignoring %s since BitsPerSample tag not found",
4667 continue;
4668 }
4669 /* ColorMap or TransferFunction for high bit */
4670 /* depths do not make much sense and could be */
4671 /* used as a denial of service vector */
4673 {
4675 TIFFWarningExtR(
4676 tif, module,
4680 continue;
4681 }
4685 {
4686 countrequired = countpersample;
4687 incrementpersample = 0;
4688 }
4689 else
4690 {
4691 countrequired = 3 * countpersample;
4692 incrementpersample = countpersample;
4693 }
4696 else
4699 goto bad;
4701 {
4706 }
4707 else
4708 {
4710 value + incrementpersample,
4711 value + 2 * incrementpersample);
4713 }
4714 }
4715 break;
4716 /* BEGIN REV 4.0 COMPATIBILITY */
4718 {
4719 uint16_t valueo;
4722 TIFFReadDirEntryErrOk)
4723 {
4724 switch (valueo)
4725 {
4728 break;
4731 break;
4732 default:
4733 value = 0;
4734 break;
4735 }
4738 }
4739 }
4740 break;
4741 /* END REV 4.0 COMPATIBILITY */
4742#if 0
4744 /* TIFFTAG_EP_BATTERYLEVEL can be RATIONAL or ASCII.
4745 * LibTiff defines it as ASCII and converts RATIONAL to an
4746 * ASCII string. */
4748 {
4750 {
4751 /* Read rational and convert to ASCII*/
4753 TIFFRational_t rValue;
4754 err = TIFFReadDirEntryCheckedRationalDirect(
4755 tif, dp, &rValue);
4757 {
4762 1);
4763 }
4764 else
4765 {
4766 char szAux[32];
4770 }
4771 }
4772 break;
4775 break;
4776 default:
4779 "Invalid data type for tag %s. "
4780 "ASCII or RATIONAL expected",
4781 fip ? fip->field_name
4782 : "unknown tagname");
4783 break;
4784 }
4785 break;
4786#endif
4787 default:
4789 break;
4790 } /* -- switch (dp->tdir_tag) -- */
4791 } /* -- if (!dp->tdir_ignore) */
4792 } /* -- for-loop -- */
4793
4794 /* Evaluate final IFD data size. */
4795 CalcFinalIFDdatasizeReading(tif, dircount);
4796
4797 /*
4798 * OJPEG hack:
4799 * - If a) compression is OJPEG, and b) photometric tag is missing,
4800 * then we consistently find that photometric should be YCbCr
4801 * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
4802 * then we consistently find that the buggy implementation of the
4803 * buggy compression scheme matches photometric YCbCr instead.
4804 * - If a) compression is OJPEG, and b) bitspersample tag is missing,
4805 * then we consistently find bitspersample should be 8.
4806 * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4807 * and c) photometric is RGB or YCbCr, then we consistently find
4808 * samplesperpixel should be 3
4809 * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4810 * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
4811 * find samplesperpixel should be 3
4812 */
4814 {
4816 {
4817 TIFFWarningExtR(
4818 tif, module,
4819 "Photometric tag is missing, assuming data is YCbCr");
4821 goto bad;
4822 }
4824 {
4827 "Photometric tag value assumed incorrect, "
4828 "assuming data is YCbCr instead of RGB");
4829 }
4831 {
4832 TIFFWarningExtR(
4833 tif, module,
4834 "BitsPerSample tag is missing, assuming 8 bits per sample");
4836 goto bad;
4837 }
4839 {
4841 {
4843 "SamplesPerPixel tag is missing, "
4844 "assuming correct SamplesPerPixel value is 3");
4846 goto bad;
4847 }
4849 {
4851 "SamplesPerPixel tag is missing, "
4852 "applying correct SamplesPerPixel value of 3");
4854 goto bad;
4855 }
4858 {
4859 /*
4860 * SamplesPerPixel tag is missing, but is not required
4861 * by spec. Assume correct SamplesPerPixel value of 1.
4862 */
4864 goto bad;
4865 }
4866 }
4867 }
4868
4869 /*
4870 * Setup appropriate structures (by strip or by tile)
4871 * We do that only after the above OJPEG hack which alters SamplesPerPixel
4872 * and thus influences the number of strips in the separate planarconfig.
4873 */
4875 {
4880 tif->tif_flags &= ~TIFF_ISTILED;
4881 }
4882 else
4883 {
4886 }
4888 {
4891 goto bad;
4892 }
4897 {
4898#ifdef OJPEG_SUPPORT
4901 {
4902 /*
4903 * XXX: OJPEG hack.
4904 * If a) compression is OJPEG, b) it's not a tiled TIFF,
4905 * and c) the number of strips is 1,
4906 * then we tolerate the absence of stripoffsets tag,
4907 * because, presumably, all required data is in the
4908 * JpegInterchangeFormat stream.
4909 */
4911 }
4912 else
4913#endif
4914 {
4916 goto bad;
4917 }
4918 }
4919
4929 {
4930 /* Directory typically created with TIFFDeferStrileArrayWriting() */
4931 TIFFSetupStrips(tif);
4932 }
4934 {
4936 {
4940 {
4941 goto bad;
4942 }
4943 }
4945 {
4949 {
4950 goto bad;
4951 }
4952 }
4953 }
4954
4955 /*
4956 * Make sure all non-color channels are extrasamples.
4957 * If it's not the case, define them as such.
4958 */
4960 if (color_channels &&
4962 color_channels)
4963 {
4964 uint16_t old_extrasamples;
4965 uint16_t *new_sampleinfo;
4966
4967 TIFFWarningExtR(
4968 tif, module,
4969 "Sum of Photometric type-related "
4970 "color channels and ExtraSamples doesn't match SamplesPerPixel. "
4971 "Defining non-color channels as ExtraSamples.");
4972
4976
4977 // sampleinfo should contain information relative to these new extra
4978 // samples
4981 if (!new_sampleinfo)
4982 {
4984 "Failed to allocate memory for "
4985 "temporary new sampleinfo array "
4988 goto bad;
4989 }
4990
4991 if (old_extrasamples > 0)
4996 _TIFFfreeExt(tif, new_sampleinfo);
4997 }
4998
4999 /*
5000 * Verify Palette image has a Colormap.
5001 */
5004 {
5010 else
5011 {
5013 goto bad;
5014 }
5015 }
5016 /*
5017 * OJPEG hack:
5018 * We do no further messing with strip/tile offsets/bytecounts in OJPEG
5019 * TIFFs
5020 */
5022 {
5023 /*
5024 * Attempt to deal with a missing StripByteCounts tag.
5025 */
5027 {
5028 /*
5029 * Some manufacturers violate the spec by not giving
5030 * the size of the strips. In this case, assume there
5031 * is one uncompressed strip of data.
5032 */
5038 {
5040 goto bad;
5041 }
5042 TIFFWarningExtR(
5043 tif, module,
5044 "TIFF directory is missing required "
5045 "\"StripByteCounts\" field, calculating from imagelength");
5047 goto bad;
5048 }
5051 {
5052 /*
5053 * XXX: Plexus (and others) sometimes give a value of
5054 * zero for a tag when they don't know what the
5055 * correct value is! Try and handle the simple case
5056 * of estimating the size of a one strip image.
5057 */
5059 "Bogus \"StripByteCounts\" field, ignoring and "
5060 "calculating from imagelength");
5062 goto bad;
5063 }
5068 TIFFGetStrileByteCount(tif, 0) !=
5069 TIFFGetStrileByteCount(tif, 1) &&
5070 TIFFGetStrileByteCount(tif, 0) != 0 &&
5071 TIFFGetStrileByteCount(tif, 1) != 0)
5072 {
5073 /*
5074 * XXX: Some vendors fill StripByteCount array with
5075 * absolutely wrong values (it can be equal to
5076 * StripOffset array, for example). Catch this case
5077 * here.
5078 *
5079 * We avoid this check if deferring strile loading
5080 * as it would always force us to load the strip/tile
5081 * information.
5082 */
5084 "Wrong \"StripByteCounts\" field, ignoring and "
5085 "calculating from imagelength");
5087 goto bad;
5088 }
5089 }
5091 {
5094 }
5096 {
5099 else
5102 }
5103
5104#ifdef STRIPBYTECOUNTSORTED_UNUSED
5105 /*
5106 * XXX: We can optimize checking for the strip bounds using the sorted
5107 * bytecounts array. See also comments for TIFFAppendToStrip()
5108 * function in tif_write.c.
5109 */
5111 {
5112 uint32_t strip;
5113
5114 tif->tif_dir.td_stripbytecountsorted = 1;
5116 {
5118 TIFFGetStrileOffset(tif, strip))
5119 {
5120 tif->tif_dir.td_stripbytecountsorted = 0;
5121 break;
5122 }
5123 }
5124 }
5125#endif
5126
5127 /*
5128 * An opportunity for compression mode dependent tag fixup
5129 */
5130 (*tif->tif_fixuptags)(tif);
5131
5132 /*
5133 * Some manufacturers make life difficult by writing
5134 * large amounts of uncompressed data as a single strip.
5135 * This is contrary to the recommendations of the spec.
5136 * The following makes an attempt at breaking such images
5137 * into strips closer to the recommended 8k bytes. A
5138 * side effect, however, is that the RowsPerStrip tag
5139 * value may be changed.
5140 */
5145 {
5146 ChopUpSingleUncompressedStrip(tif);
5147 }
5148
5149 /* There are also uncompressed striped files with strips larger than */
5150 /* 2 GB, which make them unfriendly with a lot of code. If possible, */
5151 /* try to expose smaller "virtual" strips. */
5155 TIFFStripSize64(tif) > 0x7FFFFFFFUL)
5156 {
5157 TryChopUpUncompressedBigTiff(tif);
5158 }
5159
5160 /*
5161 * Clear the dirty directory flag.
5162 */
5163 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
5164 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
5165
5166 /*
5167 * Reinitialize i/o since we are starting on a new directory.
5168 */
5174
5177 {
5179 return (0);
5180 }
5181
5183 {
5186 {
5188 return (0);
5189 }
5190 }
5191 else
5192 {
5194 {
5196 return (0);
5197 }
5198 }
5199 return (1);
5200bad:
5203 return (0);
5204} /*-- TIFFReadDirectory() --*/
Definition: tiffio.h:278
void _TIFFsetShortArrayExt(TIFF *tif, uint16_t **wpp, const uint16_t *wp, uint32_t n)
Definition: tif_dir.c:78
int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag)
Definition: tif_dirinfo.c:1247
int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
Definition: tif_dirread.c:5665
static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
Definition: tif_dirread.c:485
static void TryChopUpUncompressedBigTiff(TIFF *)
Definition: tif_dirread.c:7937
static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
Definition: tif_dirread.c:2988
static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err, const char *module, const char *tagname, int recover)
Definition: tif_dirread.c:3919
static TIFFDirEntry * TIFFReadDirectoryFindEntry(TIFF *tif, TIFFDirEntry *dir, uint16_t dircount, uint16_t tagid)
Definition: tif_dirread.c:5227
static void ChopUpSingleUncompressedStrip(TIFF *)
Definition: tif_dirread.c:7867
static bool EvaluateIFDdatasizeReading(TIFF *tif, TIFFDirEntry *dp)
Definition: tif_dirread.c:4087
static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16_t **value)
Definition: tif_dirread.c:1752
static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir, uint16_t dircount)
Definition: tif_dirread.c:5475
static int _TIFFGetMaxColorChannels(uint16_t photometric)
Definition: tif_dirread.c:4016
static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32_t nstrips, uint64_t **lpp)
Definition: tif_dirread.c:7643
static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
Definition: tif_dirread.c:3279
Definition: pdh_main.c:96
Referenced by TIFFClientOpenExt(), TIFFSetDirectory(), and TIFFSetSubDirectory().
◆ TIFFReadEncodedStrip()
Definition at line 534 of file tif_read.c.
536{
539 tmsize_t stripsize;
541
545
546 /* shortcut to avoid an extra memcpy() */
550 {
553
557
559 return (stripsize);
560 }
561
563 stripsize = size;
565 {
566 /* The output buf may be NULL, in particular if TIFFTAG_FAXFILLFUNC
567 is being used. Thus, memset must be conditional on buf not NULL. */
571 }
575 return (stripsize);
576}
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 GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum plane
Definition: glfuncs.h:270
static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32_t strip, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:620
static tmsize_t TIFFReadEncodedStripGetStripSize(TIFF *tif, uint32_t strip, uint16_t *pplane)
Definition: tif_read.c:488
Referenced by _TIFFReadEncodedStripAndAllocBuffer(), gtStripSeparate(), and tiff_decoder_read_tile().
◆ TIFFReadEncodedTile()
Definition at line 953 of file tif_read.c.
954{
958
962 {
965 td->td_nstrips);
967 }
968
969 /* shortcut to avoid an extra memcpy() */
973 {
976
980
982 return (tilesize);
983 }
984
986 size = tilesize;
988 size = tilesize;
990 {
991 /* See TIFFReadEncodedStrip comment regarding TIFFTAG_FAXFILLFUNC. */
995 }
998 {
1001 }
1002 else
1004}
static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32_t tile, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:1119
Referenced by _TIFFReadEncodedTileAndAllocBuffer(), tiff_decoder_read_tile(), and TIFFReadTile().
◆ TIFFReadEXIFDirectory()
Definition at line 5462 of file tif_dirread.c.
5463{
5465}
int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff, const TIFFFieldArray *infoarray)
Definition: tif_dirread.c:5278
◆ TIFFReadFromUserBuffer()
| int TIFFReadFromUserBuffer | ( | TIFF * | tif, |
| uint32_t | strile, | ||
| void * | inbuf, | ||
| tmsize_t | insize, | ||
| void * | outbuf, | ||
| tmsize_t | outsize | ||
| ) |
Definition at line 1545 of file tif_read.c.
1547{
1554
1556 {
1558 return 0;
1559 }
1561 {
1563 "Compression scheme does not support access to raw "
1564 "uncompressed data");
1565 return 0;
1566 }
1567
1568 tif->tif_flags &= ~TIFF_MYBUFFER;
1572 tif->tif_rawdataoff = 0;
1574
1577 {
1579 }
1580
1582 {
1584 {
1585 ret = 0;
1586 /* See related TIFFReadEncodedStrip comment. */
1587 if (outbuf)
1589 }
1593 {
1594 ret = 0;
1595 }
1596 }
1597 else
1598 {
1600 uint32_t stripsperplane;
1602 rowsperstrip = td->td_imagelength;
1603 if (rowsperstrip == 0)
1604 {
1606 ret = 0;
1607 }
1608 else
1609 {
1610 stripsperplane =
1613 {
1614 ret = 0;
1615 /* See related TIFFReadEncodedStrip comment. */
1616 if (outbuf)
1618 }
1621 (uint16_t)(strile / stripsperplane)))
1622 {
1623 ret = 0;
1624 }
1625 }
1626 }
1628 {
1630 }
1631
1634 {
1636 }
1637
1640 tif->tif_rawdatasize = old_rawdatasize;
1641 tif->tif_rawdata = old_rawdata;
1642 tif->tif_rawdataoff = 0;
1643 tif->tif_rawdataloaded = 0;
1644
1646}
◆ TIFFReadGPSDirectory()
Definition at line 5470 of file tif_dirread.c.
◆ TIFFReadRawStrip()
Definition at line 717 of file tif_read.c.
718{
721 uint64_t bytecount64;
722 tmsize_t bytecountm;
723
727 {
730 td->td_nstrips);
732 }
734 {
736 "Compression scheme does not support access to raw "
737 "uncompressed data");
739 }
740 bytecount64 = TIFFGetStrileByteCount(tif, strip);
742 bytecountm = size;
743 else
745 if (bytecountm == 0)
746 {
748 }
750}
◆ TIFFReadRawTile()
Definition at line 1176 of file tif_read.c.
1177{
1180 uint64_t bytecount64;
1181 tmsize_t bytecountm;
1182
1186 {
1189 td->td_nstrips);
1191 }
1193 {
1195 "Compression scheme does not support access to raw "
1196 "uncompressed data");
1198 }
1199 bytecount64 = TIFFGetStrileByteCount(tif, tile);
1201 bytecountm = size;
1202 else
1204 if (bytecountm == 0)
1205 {
1207 }
1209}
◆ TIFFReadRGBAImage()
| int TIFFReadRGBAImage | ( | TIFF * | tif, |
| uint32_t | rwidth, | ||
| uint32_t | rheight, | ||
| uint32_t * | raster, | ||
| int | stop | ||
| ) |
Definition at line 656 of file tif_getimage.c.
658{
660 ORIENTATION_BOTLEFT, stop);
661}
int TIFFReadRGBAImageOriented(TIFF *tif, uint32_t rwidth, uint32_t rheight, uint32_t *raster, int orientation, int stop)
Definition: tif_getimage.c:631
◆ TIFFReadRGBAImageOriented()
| int TIFFReadRGBAImageOriented | ( | TIFF * | tif, |
| uint32_t | rwidth, | ||
| uint32_t | rheight, | ||
| uint32_t * | raster, | ||
| int | orientation, | ||
| int | stop | ||
| ) |
Definition at line 631 of file tif_getimage.c.
633{
637
639 {
643 }
644 else
645 {
647 ok = 0;
648 }
650}
Definition: tiffio.h:216
int TIFFRGBAImageGet(TIFFRGBAImage *img, uint32_t *raster, uint32_t w, uint32_t h)
Definition: tif_getimage.c:587
int TIFFRGBAImageBegin(TIFFRGBAImage *img, TIFF *tif, int stop, char emsg[EMSG_BUF_SIZE])
Definition: tif_getimage.c:310
Referenced by TIFFReadRGBAImage().
◆ TIFFReadRGBAStrip()
Definition at line 3341 of file tif_getimage.c.
3343{
3345}
int TIFFReadRGBAStripExt(TIFF *tif, uint32_t row, uint32_t *raster, int stop_on_error)
Definition: tif_getimage.c:3347
◆ TIFFReadRGBAStripExt()
Definition at line 3347 of file tif_getimage.c.
3350{
3354 uint32_t rowsperstrip, rows_to_read;
3355
3357 {
3359 "Can't use TIFFReadRGBAStrip() with tiled file.");
3360 return (0);
3361 }
3362
3364
3365 if (rowsperstrip == 0)
3366 {
3368 return (0);
3369 }
3370
3372 {
3373 TIFFErrorExtR(
3374 tif, TIFFFileName(tif),
3375 "Row passed to TIFFReadRGBAStrip() must be first in a strip.");
3376 return (0);
3377 }
3378
3380 {
3382 {
3384 "Invalid row passed to TIFFReadRGBAStrip().");
3386 return (0);
3387 }
3388
3390 img.col_offset = 0;
3391
3394 else
3395 rows_to_read = rowsperstrip;
3396
3398
3400 }
3401 else
3402 {
3404 ok = 0;
3405 }
3406
3408}
int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag,...)
Definition: tif_aux.c:380
Referenced by TIFFReadRGBAStrip().
◆ TIFFReadRGBATile()
Definition at line 3416 of file tif_getimage.c.
3418{
3420}
int TIFFReadRGBATileExt(TIFF *tif, uint32_t col, uint32_t row, uint32_t *raster, int stop_on_error)
Definition: tif_getimage.c:3422
◆ TIFFReadRGBATileExt()
| int TIFFReadRGBATileExt | ( | TIFF * | tif, |
| uint32_t | col, | ||
| uint32_t | row, | ||
| uint32_t * | raster, | ||
| int | stop_on_error | ||
| ) |
Definition at line 3422 of file tif_getimage.c.
3424{
3428 uint32_t tile_xsize, tile_ysize;
3429 uint32_t read_xsize, read_ysize;
3430 uint32_t i_row;
3431
3432 /*
3433 * Verify that our request is legal - on a tile file, and on a
3434 * tile boundary.
3435 */
3436
3438 {
3440 "Can't use TIFFReadRGBATile() with striped file.");
3441 return (0);
3442 }
3443
3446 if (tile_xsize == 0 || tile_ysize == 0)
3447 {
3449 "tile_xsize or tile_ysize is zero");
3450 return (0);
3451 }
3452
3454 {
3456 "Row/col passed to TIFFReadRGBATile() must be top"
3457 "left corner of a tile.");
3458 return (0);
3459 }
3460
3461 /*
3462 * Setup the RGBA reader.
3463 */
3464
3466 {
3468 return (0);
3469 }
3470
3472 {
3474 "Invalid row/col passed to TIFFReadRGBATile().");
3476 return (0);
3477 }
3478
3479 /*
3480 * The TIFFRGBAImageGet() function doesn't allow us to get off the
3481 * edge of the image, even to fill an otherwise valid tile. So we
3482 * figure out how much we can read, and fix up the tile buffer to
3483 * a full tile configuration afterwards.
3484 */
3485
3488 else
3489 read_ysize = tile_ysize;
3490
3492 read_xsize = img.width - col;
3493 else
3494 read_xsize = tile_xsize;
3495
3496 /*
3497 * Read the chunk of imagery.
3498 */
3499
3501 img.col_offset = col;
3502
3504
3506
3507 /*
3508 * If our read was incomplete we will need to fix up the tile by
3509 * shifting the data around as if a full tile of data is being returned.
3510 *
3511 * This is all the more complicated because the image is organized in
3512 * bottom to top format.
3513 */
3514
3515 if (read_xsize == tile_xsize && read_ysize == tile_ysize)
3517
3518 for (i_row = 0; i_row < read_ysize; i_row++)
3519 {
3521 raster + (size_t)(read_ysize - i_row - 1) * read_xsize,
3524 read_xsize,
3526 }
3527
3528 for (i_row = read_ysize; i_row < tile_ysize; i_row++)
3529 {
3532 }
3533
3535}
Referenced by TIFFReadRGBATile().
◆ TIFFReadScanline()
Definition at line 454 of file tif_read.c.
455{
457
459 return (-1);
461 {
462 /*
463 * Decompress desired row into user buffer.
464 */
466 sample);
467
468 /* we are now poised at the beginning of the next row */
470
473 }
474 else
475 {
476 /* See TIFFReadEncodedStrip comment regarding TIFFTAG_FAXFILLFUNC. */
479 }
481}
◆ TIFFReadTile()
Definition at line 940 of file tif_read.c.
942{
946 (tmsize_t)(-1)));
947}
tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32_t tile, void *buf, tmsize_t size)
Definition: tif_read.c:953
uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
Definition: tif_tile.c:35
int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
Definition: tif_tile.c:71
Referenced by gtTileSeparate().
◆ TIFFRegisterCODEC()
| TIFFCodec * TIFFRegisterCODEC | ( | uint16_t | scheme, |
| const char * | name, | ||
| TIFFInitMethod | init | ||
| ) |
Definition at line 206 of file tif_compress.c.
208{
210 NULL,
212
214 {
222 }
223 else
224 {
228 }
230}
struct _codec codec_t
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
◆ TIFFReverseBits()
Definition at line 310 of file tif_swab.c.
Referenced by TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFFlushData1(), TIFFReadEncodedStrip(), TIFFReadEncodedTile(), TIFFReadFromUserBuffer(), TIFFWriteEncodedStrip(), and TIFFWriteEncodedTile().
◆ 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().
◆ TIFFRGBAImageBegin()
| int TIFFRGBAImageBegin | ( | TIFFRGBAImage * | , |
| TIFF * | , | ||
| int | , | ||
| char | [1024] | ||
| ) |
◆ TIFFRGBAImageEnd()
| void TIFFRGBAImageEnd | ( | TIFFRGBAImage * | img | ) |
Definition at line 253 of file tif_getimage.c.
254{
256 {
259 }
261 {
264 }
266 {
269 }
271 {
274 }
276 {
279 }
281 {
284 }
286 {
289 }
290
292 {
297 }
298}
Referenced by TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), and TIFFRGBAImageBegin().
◆ TIFFRGBAImageGet()
| int TIFFRGBAImageGet | ( | TIFFRGBAImage * | img, |
| uint32_t * | raster, | ||
| uint32_t | w, | ||
| uint32_t | h | ||
| ) |
Definition at line 587 of file tif_getimage.c.
589{
591 {
593 "No \"get\" routine setup");
594 return (0);
595 }
597 {
598 TIFFErrorExtR(
600 "No \"put\" routine setupl; probably can not handle image format");
601 return (0);
602 }
603 /* Verify raster height against image height.
604 * Width is checked in img->get() function individually. */
606 {
609 {
610 /* Adapt parameters to read only available lines and put image
611 * at the bottom of the raster. */
613 h = hx;
614 }
615 }
616 else
617 {
619 "Error in TIFFRGBAImageGet: row offset %d exceeds "
620 "image height %d",
622 return 0;
623 }
625}
Referenced by TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), and TIFFReadRGBATileExt().
◆ TIFFRGBAImageOK()
◆ TIFFScanlineSize()
Definition at line 343 of file tif_strip.c.
344{
349}
Referenced by gtStripContig(), gtStripSeparate(), PredictorSetup(), TIFFReadDirectory(), and TIFFWriteCheck().
◆ TIFFScanlineSize64()
Definition at line 257 of file tif_strip.c.
258{
261 uint64_t scanline_size;
263 {
266 {
267 uint16_t ycbcrsubsampling[2];
268 uint16_t samplingblock_samples;
269 uint32_t samplingblocks_hor;
270 uint64_t samplingrow_samples;
271 uint64_t samplingrow_size;
273 {
275 return 0;
276 }
278 ycbcrsubsampling + 0, ycbcrsubsampling + 1);
279 if (((ycbcrsubsampling[0] != 1) && (ycbcrsubsampling[0] != 2) &&
280 (ycbcrsubsampling[0] != 4)) ||
281 ((ycbcrsubsampling[1] != 1) && (ycbcrsubsampling[1] != 2) &&
282 (ycbcrsubsampling[1] != 4)) ||
283 ((ycbcrsubsampling[0] == 0) || (ycbcrsubsampling[1] == 0)))
284 {
286 return 0;
287 }
288 samplingblock_samples =
289 ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
290 samplingblocks_hor =
292 samplingrow_samples = _TIFFMultiply64(
293 tif, samplingblocks_hor, samplingblock_samples, module);
294 samplingrow_size =
297 8);
298 scanline_size = (samplingrow_size / ycbcrsubsampling[1]);
299 }
300 else
301 {
302 uint64_t scanline_samples;
304
305#if 0
306 // Tries to fix https://gitlab.com/libtiff/libtiff/-/merge_requests/564
307 // but causes regression when decoding legit files with tiffcp -c none
308 // Cf https://gitlab.com/libtiff/libtiff/-/merge_requests/644
310 {
311 uint16_t subsampling_hor;
314 &subsampling_hor, &ignored);
315 if (subsampling_hor > 1) // roundup width for YCbCr
316 scanline_width =
317 TIFFroundup_32(scanline_width, subsampling_hor);
318 }
319#endif
320
321 scanline_samples = _TIFFMultiply64(tif, scanline_width,
323 scanline_size =
326 8);
327 }
328 }
329 else
330 {
331 scanline_size =
334 8);
335 }
336 if (scanline_size == 0)
337 {
339 return 0;
340 }
341 return (scanline_size);
342}
Referenced by _TIFFDefaultStripSize(), ByteCountLooksBad(), EstimateStripByteCounts(), TIFFScanlineSize(), and TIFFVStripSize64().
◆ TIFFSetClientdata()
Definition at line 833 of file tif_open.c.
◆ TIFFSetClientInfo()
Definition at line 78 of file tif_extension.c.
80{
82
83 /*
84 ** Do we have an existing link with this name? If so, just
85 ** set it.
86 */
88 psLink = psLink->next;
89
91 {
93 return;
94 }
95
96 /*
97 ** Create a new link.
98 */
99
100 psLink =
108
109 tif->tif_clientinfo = psLink;
110}
◆ TIFFSetDirectory()
Definition at line 2057 of file tif_dir.c.
2058{
2059 uint64_t nextdiroff;
2060 tdir_t nextdirnum = 0;
2062
2064 {
2065 /* tif_setdirectory_force_absolute=1 will force parsing the main IFD
2066 * chain from the beginning, thus IFD directory list needs to be cleared
2067 * from possible SubIFD offsets.
2068 */
2070 }
2071
2072 /* Even faster path, if offset is available within IFD loop hash list. */
2074 _TIFFGetOffsetFromDirNumber(tif, dirn, &nextdiroff))
2075 {
2076 /* Set parameters for following TIFFReadDirectory() below. */
2077 tif->tif_nextdiroff = nextdiroff;
2078 tif->tif_curdir = dirn;
2079 /* Reset to relative stepping */
2081 }
2082 else
2083 {
2084
2085 /* Fast path when we just advance relative to the current directory:
2086 * start at the current dir offset and continue to seek from there.
2087 * Check special cases when relative is not allowed:
2088 * - jump back from SubIFD or custom directory
2089 * - right after TIFFWriteDirectory() jump back to that directory
2090 * using TIFFSetDirectory() */
2092 (tif->tif_diroff != 0) &&
2093 !tif->tif_setdirectory_force_absolute;
2094
2095 if (relative)
2096 {
2097 nextdiroff = tif->tif_diroff;
2098 dirn -= tif->tif_curdir;
2099 nextdirnum = tif->tif_curdir;
2100 }
2103 else
2105
2106 /* Reset to relative stepping */
2108
2111 return (0);
2112 /* If the n-th directory could not be reached (does not exist),
2113 * return here without touching anything further. */
2115 return (0);
2116
2117 tif->tif_nextdiroff = nextdiroff;
2118
2119 /* Set curdir to the actual directory index. */
2120 if (relative)
2122 else
2124 }
2125
2126 /* The -1 decrement is because TIFFReadDirectory will increment
2127 * tif_curdir after successfully reading the directory. */
2130 else
2131 tif->tif_curdir--;
2132
2134
2136
2138 {
2139 /* If tif_curdir has not be incremented, TIFFFetchDirectory() in
2140 * TIFFReadDirectory() has failed and tif_curdir shall be set
2141 * specifically. */
2143 }
2145}
int _TIFFGetOffsetFromDirNumber(TIFF *tif, tdir_t dirn, uint64_t *diroff)
Definition: tif_dirread.c:5873
Referenced by tiff_decoder_select_frame().
◆ TIFFSetErrorHandler()
| void void void void TIFFErrorHandler TIFFSetErrorHandler | ( | TIFFErrorHandler | handler | ) |
Definition at line 32 of file tif_error.c.
33{
36 return (prev);
37}
void(* TIFFErrorHandler)(const char *, const char *, va_list)
Definition: tiffio.h:301
Referenced by tiff_decoder_create(), and tiff_encoder_create().
◆ TIFFSetErrorHandlerExt()
| TIFFErrorHandlerExt TIFFSetErrorHandlerExt | ( | TIFFErrorHandlerExt | handler | ) |
Definition at line 39 of file tif_error.c.
40{
43 return (prev);
44}
void(* TIFFErrorHandlerExt)(thandle_t, const char *, const char *, va_list)
Definition: tiffio.h:302
◆ TIFFSetField()
Definition at line 1146 of file tif_dir.c.
1147{
1150
1155}
Referenced by allocChoppedUpStripArrays(), tiff_encoder_create_frame(), TIFFDefaultDirectory(), TIFFFetchNormalTag(), TIFFFetchSubjectDistance(), TIFFReadDirectory(), and TIFFRGBAImageBegin().
◆ TIFFSetFileName()
Definition at line 803 of file tif_open.c.
◆ TIFFSetFileno()
Definition at line 818 of file tif_open.c.
◆ TIFFSetMode()
Definition at line 848 of file tif_open.c.
◆ TIFFSetSubDirectory()
Definition at line 2153 of file tif_dir.c.
2154{
2155 /* Match nextdiroff and curdir for consistent IFD-loop checking.
2156 * Only with TIFFSetSubDirectory() the IFD list can be corrupted with
2157 * invalid offsets within the main IFD tree. In the case of several subIFDs
2158 * of a main image, there are two possibilities that are not even mutually
2159 * exclusive. a.) The subIFD tag contains an array with all offsets of the
2160 * subIFDs. b.) The SubIFDs are concatenated with their NextIFD parameters.
2161 * (refer to
2162 * https://www.awaresystems.be/imaging/tiff/specification/TIFFPM6.pdf.)
2163 */
2165 uint32_t curdir = 0;
2166 int8_t probablySubIFD = 0;
2167 if (diroff == 0)
2168 {
2169 /* Special case to set tif_diroff=0, which is done in
2170 * TIFFReadDirectory() below to indicate that the currently read IFD is
2171 * treated as a new, fresh IFD. */
2174 }
2175 else
2176 {
2178 {
2179 /* Non-existing offsets might point to a SubIFD or invalid IFD.*/
2180 probablySubIFD = 1;
2181 }
2182 /* -1 because TIFFReadDirectory() will increment tif_curdir. */
2183 if (curdir >= 1)
2184 tif->tif_curdir = curdir - 1;
2185 else
2187 }
2188 curdir = tif->tif_curdir;
2189
2190 tif->tif_nextdiroff = diroff;
2192
2193 /* tif_curdir is incremented in TIFFReadDirectory(), but if it has not been
2194 * incremented, TIFFFetchDirectory() has failed there and tif_curdir shall
2195 * be set specifically. */
2197 {
2199 }
2200
2201 if (probablySubIFD)
2202 {
2204 {
2205 /* Reset IFD list to start new one for SubIFD chain and also start
2206 * SubIFD chain with tif_curdir=0 for IFD loop checking. */
2207 /* invalidate IFD loop lists */
2208 _TIFFCleanupIFDOffsetAndNumberMaps(tif);
2210 /* add this offset to new IFD list */
2212 }
2213 /* To be able to return from SubIFD or custom-IFD to main-IFD */
2215 }
2216
2218}
int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff, tdir_t *dirn)
Definition: tif_dirread.c:5828
◆ TIFFSetTagExtender()
| TIFFExtendProc TIFFSetTagExtender | ( | TIFFExtendProc | extender | ) |
◆ TIFFSetupStrips()
Definition at line 553 of file tif_write.c.
554{
556
559 ? td->td_samplesperpixel
560 : TIFFNumberOfTiles(tif);
561 else
563 ? td->td_samplesperpixel
564 : TIFFNumberOfStrips(tif);
566 /* TIFFWriteDirectoryTagData has a limitation to 0x80000000U bytes */
569 {
571 "Too large Strip/Tile Offsets/ByteCounts arrays");
572 return 0;
573 }
576
586 return (0);
587 /*
588 * Place data at the end-of-file
589 * (by setting offsets to zero).
590 */
595 return (1);
596}
Referenced by TIFFCheckpointDirectory(), TIFFForceStrileArrayWriting(), TIFFReadDirectory(), and TIFFWriteCheck().
◆ TIFFSetWarningHandler()
| TIFFErrorHandler TIFFSetWarningHandler | ( | TIFFErrorHandler | handler | ) |
Definition at line 32 of file tif_warning.c.
33{
36 return (prev);
37}
Referenced by tiff_decoder_create(), and tiff_encoder_create().
◆ TIFFSetWarningHandlerExt()
| TIFFErrorHandlerExt TIFFSetWarningHandlerExt | ( | TIFFErrorHandlerExt | handler | ) |
Definition at line 39 of file tif_warning.c.
40{
43 return (prev);
44}
◆ TIFFSetWriteOffset()
Definition at line 961 of file tif_write.c.
Referenced by TIFFCheckpointDirectory().
◆ TIFFStripSize()
Definition at line 204 of file tif_strip.c.
205{
210}
Referenced by gtStripContig(), gtStripSeparate(), TIFFFillStrip(), TIFFReadDirectory(), and TIFFWriteBufferSetup().
◆ TIFFStripSize64()
Definition at line 196 of file tif_strip.c.
Referenced by _TIFFRewriteField(), TIFFReadDirectory(), TIFFStripSize(), TIFFWriteDirectoryTagLongLong8Array(), and TryChopUpUncompressedBigTiff().
◆ TIFFSwabArrayOfDouble()
Definition at line 222 of file tif_swab.c.
223{
227 /* XXX unroll loop some */
229 {
243 dp++;
244 }
245}
Referenced by _TIFFSwab64BitData(), and TIFFWriteDirectoryTagCheckedDoubleArray().
◆ TIFFSwabArrayOfFloat()
◆ TIFFSwabArrayOfLong()
◆ TIFFSwabArrayOfLong8()
◆ TIFFSwabArrayOfShort()
◆ TIFFSwabArrayOfTriples()
◆ TIFFSwabDouble()
Definition at line 201 of file tif_swab.c.
202{
218}
◆ TIFFSwabFloat()
◆ TIFFSwabLong()
Definition at line 45 of file tif_swab.c.
46{
56}
Referenced by _TIFFPartialReadStripArray(), _TIFFRewriteField(), EvaluateIFDdatasizeReading(), TIFFAdvanceDirectory(), TIFFClientOpenExt(), TIFFFetchDirectory(), TIFFFetchSubjectDistance(), TIFFLinkDirectory(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryByteArray(), TIFFReadDirEntryCheckedDouble(), TIFFReadDirEntryCheckedFloat(), TIFFReadDirEntryCheckedLong(), TIFFReadDirEntryCheckedLong8(), TIFFReadDirEntryCheckedRational(), TIFFReadDirEntryCheckedSlong(), TIFFReadDirEntryCheckedSlong8(), TIFFReadDirEntryCheckedSrational(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryIfd8Array(), TIFFReadDirEntryLong8ArrayWithLimit(), TIFFReadDirEntryLongArray(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), TIFFReadDirEntrySshortArray(), TIFFRewriteDirectorySec(), TIFFUnlinkDirectory(), TIFFWriteDirectorySec(), TIFFWriteDirectoryTagCheckedLong(), TIFFWriteDirectoryTagCheckedRational(), and TIFFWriteDirectoryTagData().
◆ TIFFSwabLong8()
Definition at line 60 of file tif_swab.c.
61{
77}
Referenced by _TIFFPartialReadStripArray(), _TIFFRewriteField(), EvaluateIFDdatasizeReading(), TIFFAdvanceDirectory(), TIFFClientOpenExt(), TIFFFetchDirectory(), TIFFLinkDirectory(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryByteArray(), TIFFReadDirEntryCheckedDouble(), TIFFReadDirEntryCheckedLong8(), TIFFReadDirEntryCheckedSlong8(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryLong8ArrayWithLimit(), TIFFReadDirEntryLongArray(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), TIFFReadDirEntrySshortArray(), TIFFRewriteDirectorySec(), TIFFUnlinkDirectory(), TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagData().
◆ TIFFSwabShort()
Definition at line 33 of file tif_swab.c.
34{
41}
Referenced by _TIFFPartialReadStripArray(), _TIFFRewriteField(), TIFFAdvanceDirectory(), TIFFClientOpenExt(), TIFFFetchDirectory(), TIFFLinkDirectory(), TIFFReadDirEntryByteArray(), TIFFReadDirEntryCheckedShort(), TIFFReadDirEntryCheckedSshort(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryLong8ArrayWithLimit(), TIFFReadDirEntryLongArray(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), TIFFReadDirEntrySshortArray(), TIFFRewriteDirectorySec(), TIFFWriteDirectorySec(), and TIFFWriteDirectoryTagCheckedShort().
◆ TIFFTileRowSize()
Definition at line 177 of file tif_tile.c.
178{
183}
Referenced by gtTileContig(), gtTileSeparate(), and PredictorSetup().
◆ TIFFTileRowSize64()
Definition at line 140 of file tif_tile.c.
141{
144 uint64_t rowsize;
145 uint64_t tilerowsize;
146
148 {
150 return 0;
151 }
153 {
155 return (0);
156 }
158 "TIFFTileRowSize");
160 {
162 {
164 return 0;
165 }
167 "TIFFTileRowSize");
168 }
169 tilerowsize = TIFFhowmany8_64(rowsize);
170 if (tilerowsize == 0)
171 {
173 return 0;
174 }
175 return (tilerowsize);
176}
Referenced by TIFFTileRowSize(), and TIFFVTileSize64().
◆ TIFFTileSize()
Definition at line 253 of file tif_tile.c.
254{
259}
Referenced by gtTileContig(), gtTileSeparate(), TIFFFillTile(), TIFFReadDirectory(), and TIFFWriteCheck().
◆ TIFFTileSize64()
Definition at line 249 of file tif_tile.c.
250{
252}
Referenced by _TIFFRewriteField(), EstimateStripByteCounts(), TIFFTileSize(), and TIFFWriteDirectoryTagLongLong8Array().
◆ TIFFUnlinkDirectory()
Definition at line 2237 of file tif_dir.c.
2238{
2240 uint64_t nextdir;
2241 tdir_t nextdirnum;
2242 uint64_t off;
2244
2246 {
2248 "Can not unlink directory in read-only file");
2249 return (0);
2250 }
2251 if (dirn == 0)
2252 {
2254 "For TIFFUnlinkDirectory() first directory starts with "
2255 "number 1 and not 0");
2256 return (0);
2257 }
2258 /*
2259 * Go to the directory before the one we want
2260 * to unlink and nab the offset of the link
2261 * field we'll need to patch.
2262 */
2264 {
2266 off = 4;
2267 }
2268 else
2269 {
2271 off = 8;
2272 }
2273 nextdirnum = 0; /* First directory is dirn=0 */
2274
2276 {
2277 if (nextdir == 0)
2278 {
2280 return (0);
2281 }
2283 return (0);
2284 }
2285 /*
2286 * Advance to the directory to be unlinked and fetch
2287 * the offset of the directory that follows.
2288 */
2290 return (0);
2291 /*
2292 * Go back and patch the link field of the preceding
2293 * directory to point to the offset of the directory
2294 * that follows.
2295 */
2298 {
2299 uint32_t nextdir32;
2300 nextdir32 = (uint32_t)nextdir;
2303 TIFFSwabLong(&nextdir32);
2305 {
2307 return (0);
2308 }
2309 }
2310 else
2311 {
2312 /* Need local swap because nextdir has to be used unswapped below. */
2313 uint64_t nextdir64 = nextdir;
2315 TIFFSwabLong8(&nextdir64);
2317 {
2319 return (0);
2320 }
2321 }
2322
2323 /* For dirn=1 (first directory) also update the libtiff internal
2324 * base offset variables. */
2325 if (dirn == 1)
2326 {
2329 else
2331 }
2332
2333 /*
2334 * Leave directory state setup safely. We don't have
2335 * facilities for doing inserting and removing directories,
2336 * so it's safest to just invalidate everything. This
2337 * means that the caller can only append to the directory
2338 * chain.
2339 */
2341 {
2344 tif->tif_rawcc = 0;
2346 tif->tif_rawdataoff = 0;
2347 tif->tif_rawdataloaded = 0;
2348 }
2350 TIFF_BUF4WRITE);
2351 TIFFFreeDirectory(tif);
2352 TIFFDefaultDirectory(tif);
2356 tif->tif_curoff = 0;
2361 tif->tif_curdircount--;
2362 else
2365 return (1);
2366}
◆ TIFFUnRegisterCODEC()
Definition at line 232 of file tif_compress.c.
◆ TIFFUnsetField()
Definition at line 1160 of file tif_dir.c.
1161{
1164
1165 if (!fip)
1166 return 0;
1167
1170 else
1171 {
1174
1176 {
1177
1180 break;
1181 }
1182
1183 if (i < td->td_customValueCount)
1184 {
1187 {
1189 }
1190 td->td_customValueCount--;
1191 }
1192 }
1193
1195
1196 return (1);
1197}
Definition: tif_dir.h:36
◆ TIFFVGetField()
Definition at line 1599 of file tif_dir.c.
1600{
1604 : 0);
1605}
Referenced by TIFFGetField(), and TIFFVGetFieldDefaulted().
◆ TIFFVGetFieldDefaulted()
Definition at line 217 of file tif_aux.c.
218{
220
222 return (1);
224 {
227 return (1);
230 return (1);
233 return (1);
236 return (1);
239 return (1);
242 return (1);
245 return (1);
248 return (1);
250 {
251 uint16_t maxsamplevalue;
252 /* td_bitspersample=1 is always set in TIFFDefaultDirectory().
253 * Therefore, td_maxsamplevalue has to be re-calculated in
254 * TIFFGetFieldDefaulted(). */
256 {
257 /* This shift operation into a uint16_t limits the value to
258 * 65535 even if td_bitspersamle is > 16 */
260 {
261 maxsamplevalue = (1 << td->td_bitspersample) -
262 1; /* 2**(BitsPerSample) - 1 */
263 }
264 else
265 {
266 maxsamplevalue = 65535;
267 }
268 }
269 else
270 {
271 maxsamplevalue = 0;
272 }
274 return (1);
275 }
278 return (1);
281 return (1);
283 {
286 {
287 TIFFErrorExtR(
288 tif, tif->tif_name,
289 "Cannot get \"Predictor\" tag as plugin is not configured");
291 return 0;
292 }
294 return 1;
295 }
299 return (1);
302 return 1;
305 return (1);
309 return (1);
312 (td->td_extrasamples == 1 &&
314 return (1);
317 return (1);
320 return (1);
323 return (1);
326 return (1);
328 {
329 /* defaults are from CCIR Recommendation 601-1 */
330 static const float ycbcrcoeffs[] = {0.299f, 0.587f, 0.114f};
332 return 1;
333 }
337 return (1);
340 return (1);
342 {
343 /* TIFF 6.0 specification tells that it is no default
344 value for the WhitePoint, but AdobePhotoshop TIFF
345 Technical Note tells that it should be CIE D50. */
346 static const float whitepoint[] = {
350 return 1;
351 }
354 !TIFFDefaultTransferFunction(tif, td))
355 {
357 "No space for \"TransferFunction\" tag");
358 return (0);
359 }
362 {
365 }
366 return (1);
369 return (0);
371 return (1);
372 }
373 return 0;
374}
Definition: tif_predict.h:43
static int TIFFDefaultTransferFunction(TIFF *tif, TIFFDirectory *td)
Definition: tif_aux.c:128
static int TIFFDefaultRefBlackWhite(TIFF *tif, TIFFDirectory *td)
Definition: tif_aux.c:176
Referenced by TIFFGetFieldDefaulted().
◆ TIFFVSetField()
◆ TIFFVStripSize()
Definition at line 142 of file tif_strip.c.
143{
148}
Referenced by TIFFReadEncodedStripGetStripSize().
◆ TIFFVStripSize64()
Definition at line 88 of file tif_strip.c.
89{
93 nrows = td->td_imagelength;
96 {
97 /*
98 * Packed YCbCr data contain one Cb+Cr for every
99 * HorizontalSampling*VerticalSampling Y values.
100 * Must also roundup width and height when calculating
101 * since images that are not a multiple of the
102 * horizontal/vertical subsampling area include
103 * YCbCr data for the extended image.
104 */
105 uint16_t ycbcrsubsampling[2];
106 uint16_t samplingblock_samples;
107 uint32_t samplingblocks_hor;
108 uint32_t samplingblocks_ver;
109 uint64_t samplingrow_samples;
110 uint64_t samplingrow_size;
112 {
114 return 0;
115 }
117 ycbcrsubsampling + 0, ycbcrsubsampling + 1);
118 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
119 ycbcrsubsampling[0] != 4) ||
120 (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
121 ycbcrsubsampling[1] != 4) ||
122 (ycbcrsubsampling[0] == 0 || ycbcrsubsampling[1] == 0))
123 {
125 ycbcrsubsampling[0], ycbcrsubsampling[1]);
126 return 0;
127 }
128 samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
129 samplingblocks_hor =
131 samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
132 samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
133 samplingblock_samples, module);
136 return (
138 }
139 else
141}
Referenced by TIFFStripSize64(), TIFFVStripSize(), and TryChopUpUncompressedBigTiff().
◆ TIFFVTileSize()
Definition at line 238 of file tif_tile.c.
239{
244}
◆ TIFFVTileSize64()
Definition at line 188 of file tif_tile.c.
189{
193 td->td_tiledepth == 0)
194 return (0);
198 {
199 /*
200 * Packed YCbCr data contain one Cb+Cr for every
201 * HorizontalSampling*VerticalSampling Y values.
202 * Must also roundup width and height when calculating
203 * since images that are not a multiple of the
204 * horizontal/vertical subsampling area include
205 * YCbCr data for the extended image.
206 */
207 uint16_t ycbcrsubsampling[2];
208 uint16_t samplingblock_samples;
209 uint32_t samplingblocks_hor;
210 uint32_t samplingblocks_ver;
211 uint64_t samplingrow_samples;
212 uint64_t samplingrow_size;
214 ycbcrsubsampling + 0, ycbcrsubsampling + 1);
215 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
216 ycbcrsubsampling[0] != 4) ||
217 (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
218 ycbcrsubsampling[1] != 4))
219 {
221 ycbcrsubsampling[0], ycbcrsubsampling[1]);
222 return 0;
223 }
224 samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
225 samplingblocks_hor =
227 samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
228 samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
229 samplingblock_samples, module);
232 return (
234 }
235 else
237}
Referenced by ChopUpSingleUncompressedStrip(), TIFFTileSize64(), and TIFFVTileSize().
◆ TIFFWarning()
◆ TIFFWarningExt()
◆ TIFFWarningExtR()
◆ TIFFWriteBufferSetup()
Definition at line 677 of file tif_write.c.
678{
680
682 {
684 {
686 tif->tif_flags &= ~TIFF_MYBUFFER;
687 }
689 }
691 {
693
694 /* Adds 10% margin for cases where compression would expand a bit */
697 /*
698 * Make raw data buffer at least 8K
699 */
701 size = 8 * 1024;
703 }
705 {
708 {
710 return (0);
711 }
713 }
714 else
715 tif->tif_flags &= ~TIFF_MYBUFFER;
718 tif->tif_rawcc = 0;
721 return (1);
722}
Referenced by _TIFFReserveLargeEnoughWriteBuffer().
◆ TIFFWriteCheck()
Definition at line 605 of file tif_write.c.
606{
608 {
610 return (0);
611 }
613 {
615 tiles ? "Can not write tiles to a striped image"
616 : "Can not write scanlines to a tiled image");
617 return (0);
618 }
619
620 _TIFFFillStriles(tif);
621
622 /*
623 * On the first write verify all the required information
624 * has been setup and initialize any data structures that
625 * had to wait until directory information was set.
626 * Note that a lot of our work is assumed to remain valid
627 * because we disallow any of the important parameters
628 * from changing after we start writing (i.e. once
629 * TIFF_BEENWRITING is set, TIFFSetField will only allow
630 * the image's length to be changed).
631 */
633 {
635 "Must set \"ImageWidth\" before writing data");
636 return (0);
637 }
639 {
643 return (0);
644 }
646 {
649 return (0);
650 }
651 else
655 return (0);
657
667 {
668 TIFFForceStrileArrayWriting(tif);
669 }
670
671 return (1);
672}
◆ 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().
◆ TIFFWriteEncodedStrip()
Definition at line 215 of file tif_write.c.
217{
220 uint16_t sample;
221
224 /*
225 * Check strip array to make sure there's space.
226 * We don't support dynamically growing files that
227 * have data organized in separate bitplanes because
228 * it's too painful. In that case we require that
229 * the imagelength be set properly before the first
230 * write (so that the strips array will be fully
231 * allocated above).
232 */
234 {
236 {
237 TIFFErrorExtR(
238 tif, module,
239 "Can not grow image by strips when using separate planes");
241 }
244 td->td_stripsperimage =
246 }
247 /*
248 * Handle delayed allocation of data buffer. This
249 * permits it to be sized according to the directory
250 * info.
251 */
254
256
257 tif->tif_curstrip = strip;
258
259 /* this informs TIFFAppendToStrip() we have changed or reset strip */
260 tif->tif_curoff = 0;
261
263 {
265 }
266
267 tif->tif_rawcc = 0;
269
271 {
274 }
275
278 {
282 }
283
284 tif->tif_flags &= ~TIFF_POSTENCODE;
285
286 /* shortcut to avoid an extra memcpy() */
288 {
289 /* swab if needed - note that source buffer will be altered */
291
295
299 }
300
304
305 /* swab if needed - note that source buffer will be altered */
307
318 tif->tif_rawcc = 0;
321}
static int _TIFFReserveLargeEnoughWriteBuffer(TIFF *tif, uint32_t strip_or_tile)
Definition: tif_write.c:189
static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data, tmsize_t cc)
Definition: tif_write.c:764
static int TIFFGrowStrips(TIFF *tif, uint32_t delta, const char *module)
Definition: tif_write.c:727
◆ TIFFWriteEncodedTile()
Definition at line 414 of file tif_write.c.
415{
417 TIFFDirectory *td;
418 uint16_t sample;
419 uint32_t howmany32;
420
423 td = &tif->tif_dir;
425 {
429 }
430 /*
431 * Handle delayed allocation of data buffer. This
432 * permits it to be sized more intelligently (using
433 * directory information).
434 */
437
439
440 tif->tif_curtile = tile;
441
442 /* this informs TIFFAppendToStrip() we have changed or reset tile */
443 tif->tif_curoff = 0;
444
446 {
448 }
449
450 tif->tif_rawcc = 0;
452
453 /*
454 * Compute tiles per row & per column to compute
455 * current row and column
456 */
458 if (howmany32 == 0)
459 {
462 }
465 if (howmany32 == 0)
466 {
469 }
471
473 {
477 }
478 tif->tif_flags &= ~TIFF_POSTENCODE;
479
480 /*
481 * Clamp write amount to the tile size. This is mostly
482 * done so that callers can pass in some large number
483 * (e.g. -1) and have the tile size used instead.
484 */
487
488 /* shortcut to avoid an extra memcpy() */
490 {
491 /* swab if needed - note that source buffer will be altered */
493
497
501 }
502
506 /* swab if needed - note that source buffer will be altered */
508
519 tif->tif_rawcc = 0;
522}
Referenced by TIFFWriteTile().
◆ TIFFWriteRawStrip()
Definition at line 328 of file tif_write.c.
329{
332
335 /*
336 * Check strip array to make sure there's space.
337 * We don't support dynamically growing files that
338 * have data organized in separate bitplanes because
339 * it's too painful. In that case we require that
340 * the imagelength be set properly before the first
341 * write (so that the strips array will be fully
342 * allocated above).
343 */
345 {
347 {
348 TIFFErrorExtR(
349 tif, module,
350 "Can not grow image by strips when using separate planes");
352 }
353 /*
354 * Watch out for a growing image. The value of
355 * strips/image will initially be 1 (since it
356 * can't be deduced until the imagelength is known).
357 */
359 td->td_stripsperimage =
363 }
364
366 {
367 tif->tif_curstrip = strip;
368
369 /* this informs TIFFAppendToStrip() we have changed or reset strip */
370 tif->tif_curoff = 0;
371 }
372
374 {
377 }
380 : (tmsize_t)-1);
381}
◆ TIFFWriteRawTile()
Definition at line 533 of file tif_write.c.
◆ TIFFWriteScanline()
Definition at line 47 of file tif_write.c.
48{
52 uint32_t strip;
53
55 return (-1);
56 /*
57 * Handle delayed allocation of data buffer. This
58 * permits it to be sized more intelligently (using
59 * directory information).
60 */
62 return (-1);
64
65 td = &tif->tif_dir;
66 /*
67 * Extend image length if needed
68 * (but only for PlanarConfig=1).
69 */
71 { /* extend image */
73 {
74 TIFFErrorExtR(
75 tif, module,
76 "Can not change \"ImageLength\" when using separate planes");
77 return (-1);
78 }
80 imagegrew = 1;
81 }
82 /*
83 * Calculate strip and check for crossings.
84 */
86 {
88 {
90 (unsigned long)sample,
92 return (-1);
93 }
95 }
96 else
98 /*
99 * Check strip array to make sure there's space. We don't support
100 * dynamically growing files that have data organized in separate
101 * bitplanes because it's too painful. In that case we require that
102 * the imagelength be set properly before the first write (so that the
103 * strips array will be fully allocated above).
104 */
106 return (-1);
108 {
109 /*
110 * Changing strips -- flush any data present.
111 */
113 return (-1);
114 tif->tif_curstrip = strip;
115 /*
116 * Watch out for a growing image. The value of strips/image
117 * will initially be 1 (since it can't be deduced until the
118 * imagelength is known).
119 */
121 td->td_stripsperimage =
124 {
126 return (-1);
127 }
130 {
132 return (-1);
134 }
135
136 tif->tif_rawcc = 0;
138
139 /* this informs TIFFAppendToStrip() we have changed strip */
140 tif->tif_curoff = 0;
141
143 return (-1);
145 }
146 /*
147 * Ensure the write is either sequential or at the
148 * beginning of a strip (or that we can randomly
149 * access the data -- i.e. no encoding).
150 */
152 {
153 if (row < tif->tif_row)
154 {
155 /*
156 * Moving backwards within the same strip:
157 * backup to the start and then decode
158 * forward (below).
159 */
160 tif->tif_row =
163 }
164 /*
165 * Seek forward to the desired row.
166 */
168 return (-1);
170 }
171
172 /* swab if needed - note that source buffer will be altered */
174
176 sample);
177
178 /* we are now poised at the beginning of the next row */
181}
Referenced by tiff_encoder_write_lines().
◆ TIFFWriteTile()
Definition at line 387 of file tif_write.c.
389{
392 /*
393 * NB: A tile size of -1 is used instead of tif_tilesize knowing
394 * that TIFFWriteEncodedTile will clamp this to the tile size.
395 * This is done because the tile size may not be defined until
396 * after the output buffer is setup in TIFFWriteBufferSetup.
397 */
399 (tmsize_t)(-1)));
400}
tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data, tmsize_t cc)
Definition: tif_write.c:414
◆ TIFFXYZToRGB()
| void TIFFXYZToRGB | ( | TIFFCIELabToRGB * | cielab, |
| float | X, | ||
| float | Y, | ||
| float | Z, | ||
| uint32_t * | r, | ||
| uint32_t * | g, | ||
| uint32_t * | b | ||
| ) |
Definition at line 89 of file tif_color.c.
91{
95
96 /* Multiply through the matrix to get luminosity values. */
100
101 /* Clip input */
105
106 /* Avoid overflow in case of wrong input values */
110
111 /* Turn luminosity to colour value. */
115
119
123
124 /* Clip output. */
128}
Referenced by DECLAREContigPutFunc().
◆ TIFFYCbCrtoRGB()
| void TIFFYCbCrtoRGB | ( | TIFFYCbCrToRGB * | ycbcr, |
| uint32_t | Y, | ||
| int32_t | Cb, | ||
| int32_t | Cr, | ||
| uint32_t * | r, | ||
| uint32_t * | g, | ||
| uint32_t * | b | ||
| ) |
Definition at line 199 of file tif_color.c.
201{
203
204 /* XXX: Only 8-bit YCbCr input supported for now */
206 Cb = CLAMP(Cb, 0, 255);
207 Cr = CLAMP(Cr, 0, 255);
208
216}
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
Referenced by DECLARESepPutFunc().
◆ TIFFYCbCrToRGBInit()
| int TIFFYCbCrToRGBInit | ( | TIFFYCbCrToRGB * | ycbcr, |
| float * | luma, | ||
| float * | refBlackWhite | ||
| ) |
Definition at line 251 of file tif_color.c.
252{
253 TIFFRGBValue *clamptab;
255
256#define LumaRed luma[0]
257#define LumaGreen luma[1]
258#define LumaBlue luma[2]
259
260 clamptab =
264 ycbcr->clamptab = (clamptab += 256);
273
274 {
284
285#undef LumaBlue
286#undef LumaGreen
287#undef LumaRed
288
289 /*
290 * i is the actual input pixel value in the range 0..255
291 * Cb and Cr values are in the range -128..127 (actually
292 * they are in a range defined by the ReferenceBlackWhite
293 * tag) so there is some range shifting to do here when
294 * constructing tables indexed by the raw pixel data.
295 */
297 {
299 refBlackWhite[5] - 128.0F, 127),
300 -128.0F * 32, 128.0F * 32);
302 refBlackWhite[3] - 128.0F, 127),
303 -128.0F * 32, 128.0F * 32);
304
311 -128.0F * 32, 128.0F * 32);
312 }
313 }
314
315 return 0;
316}
Definition: tiffio.h:170
#define LumaRed
#define LumaBlue
#define LumaGreen
Referenced by initYCbCrConversion().
