tif_dirread.c File Reference
Include dependency graph for tif_dirread.c:
Go to the source code of this file.
Classes | |
| union | _UInt64Aligned_t |
Macros | |
| #define | FAILED_FII ((uint32) -1) |
| #define | TIFF_INT64_MAX ((int64)(TIFF_UINT64_MAX >> 1)) |
| #define | INITIAL_THRESHOLD (1024 * 1024) |
| #define | THRESHOLD_MULTIPLIER 10 |
| #define | MAX_THRESHOLD (THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * INITIAL_THRESHOLD) |
| #define | IO_CACHE_PAGE_SIZE 4096 |
| #define | TIFF_MAX(a, b) (((a)>(b)) ? (a) : (b)) |
| #define | TIFF_MIN(a, b) (((a)<(b)) ? (a) : (b)) |
Typedefs | |
| typedef union _UInt64Aligned_t | UInt64Aligned_t |
Enumerations | |
| enum | TIFFReadDirEntryErr { TIFFReadDirEntryErrOk = 0 , TIFFReadDirEntryErrCount = 1 , TIFFReadDirEntryErrType = 2 , TIFFReadDirEntryErrIo = 3 , TIFFReadDirEntryErrRange = 4 , TIFFReadDirEntryErrPsdif = 5 , TIFFReadDirEntryErrSizesan = 6 , TIFFReadDirEntryErrAlloc = 7 } |
Macro Definition Documentation
◆ FAILED_FII
Definition at line 41 of file tif_dirread.c.
◆ INITIAL_THRESHOLD
| #define INITIAL_THRESHOLD (1024 * 1024) |
Definition at line 774 of file tif_dirread.c.
◆ IO_CACHE_PAGE_SIZE
| #define IO_CACHE_PAGE_SIZE 4096 |
◆ MAX_THRESHOLD
| #define MAX_THRESHOLD (THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * INITIAL_THRESHOLD) |
Definition at line 776 of file tif_dirread.c.
◆ THRESHOLD_MULTIPLIER
| #define THRESHOLD_MULTIPLIER 10 |
Definition at line 775 of file tif_dirread.c.
◆ TIFF_INT64_MAX
| #define TIFF_INT64_MAX ((int64)(TIFF_UINT64_MAX >> 1)) |
Definition at line 46 of file tif_dirread.c.
◆ TIFF_MAX
◆ TIFF_MIN
Typedef Documentation
◆ UInt64Aligned_t
| typedef union _UInt64Aligned_t UInt64Aligned_t |
Enumeration Type Documentation
◆ TIFFReadDirEntryErr
Definition at line 56 of file tif_dirread.c.
56 {
57 TIFFReadDirEntryErrOk = 0,
58 TIFFReadDirEntryErrCount = 1,
59 TIFFReadDirEntryErrType = 2,
60 TIFFReadDirEntryErrIo = 3,
61 TIFFReadDirEntryErrRange = 4,
62 TIFFReadDirEntryErrPsdif = 5,
63 TIFFReadDirEntryErrSizesan = 6,
64 TIFFReadDirEntryErrAlloc = 7,
65};
Function Documentation
◆ _TIFFFetchStrileValue()
|
static |
Definition at line 6143 of file tif_dirread.c.
6147{
6151 {
6152 return 0;
6153 }
6155 {
6157 uint32 nStripArrayAllocNew;
6158 uint64 nArraySize64;
6159 size_t nArraySize;
6160 uint64* offsetArray;
6161 uint64* bytecountArray;
6162
6163 if( strile > 1000000 )
6164 {
6166 /* Avoid excessive memory allocation attempt */
6167 /* For such a big blockid we need at least a TIFF_LONG per strile */
6168 /* for the offset array. */
6170 {
6172 return 0;
6173 }
6174 }
6175
6177 td->td_nstrips < 1024 * 1024 )
6178 {
6179 nStripArrayAllocNew = td->td_nstrips;
6180 }
6181 else
6182 {
6183#define TIFF_MAX(a,b) (((a)>(b)) ? (a) : (b))
6184#define TIFF_MIN(a,b) (((a)<(b)) ? (a) : (b))
6185 nStripArrayAllocNew = TIFF_MAX(strile + 1, 1024U * 512U );
6186 if( nStripArrayAllocNew < 0xFFFFFFFFU / 2 )
6187 nStripArrayAllocNew *= 2;
6189 }
6190 assert( strile < nStripArrayAllocNew );
6192 nArraySize = (size_t)(nArraySize64);
6193#if SIZEOF_SIZE_T == 4
6194 if( nArraySize != nArraySize64 )
6195 {
6197 "Cannot allocate strip offset and bytecount arrays");
6198 return 0;
6199 }
6200#endif
6201 offsetArray = (uint64*)(
6203 bytecountArray = (uint64*)(
6205 if( offsetArray )
6206 td->td_stripoffset_p = offsetArray;
6207 if( bytecountArray )
6208 td->td_stripbytecount_p = bytecountArray;
6209 if( offsetArray && bytecountArray )
6210 {
6211 td->td_stripoffsetbyteallocsize = nStripArrayAllocNew;
6212 /* Initialize new entries to ~0 / -1 */
6214 0xFF,
6217 0xFF,
6219 }
6220 else
6221 {
6223 "Cannot allocate strip offset and bytecount arrays");
6228 td->td_stripoffsetbyteallocsize = 0;
6229 }
6230 }
6232 return 0;
6233
6234 if( ~((*parray)[strile]) == 0 )
6235 {
6237 {
6238 (*parray)[strile] = 0;
6239 return 0;
6240 }
6241 }
6242
6243 return 1;
6244}
Definition: tif_dir.h:67
uint32 td_stripoffsetbyteallocsize
Definition: tif_dir.h:103
Definition: fatfs.h:198
Definition: dbghelp_private.h:377
static int _TIFFPartialReadStripArray(TIFF *tif, TIFFDirEntry *dirent, int strile, uint64 *panVals)
Definition: tif_dirread.c:6002
#define TIFF_MIN(a, b)
#define TIFF_MAX(a, b)
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
Referenced by _TIFFGetStrileOffsetOrByteCountValue().
◆ _TIFFFillStriles()
Definition at line 6320 of file tif_dirread.c.
6321{
6323}
static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
Definition: tif_dirread.c:6325
Referenced by _TIFFGetStrileOffsetOrByteCountValue(), _TIFFVGetField(), TIFFReadDirectory(), TIFFWriteCheck(), and TIFFWriteDirectorySec().
◆ _TIFFFillStrilesInternal()
Definition at line 6325 of file tif_dirread.c.
6326{
6328 int return_value = 1;
6329
6330 /* Do not do anything if TIFF_DEFERSTRILELOAD is not set */
6332 return 1;
6333
6335 {
6336 /* In case of lazy loading, reload completely the arrays */
6341 td->td_stripoffsetbyteallocsize = 0;
6342 tif->tif_flags &= ~TIFF_LAZYSTRILELOAD;
6343 }
6344
6345 /* If stripoffset array is already loaded, exit with success */
6347 return 1;
6348
6349 /* If tdir_count was cancelled, then we already got there, but in error */
6351 return 0;
6352
6355 {
6356 return_value = 0;
6357 }
6358
6359 if (loadStripByteCount &&
6362 {
6363 return_value = 0;
6364 }
6365
6368
6369#ifdef STRIPBYTECOUNTSORTED_UNUSED
6371 uint32 strip;
6372
6373 tif->tif_dir.td_stripbytecountsorted = 1;
6377 tif->tif_dir.td_stripbytecountsorted = 0;
6378 break;
6379 }
6380 }
6381 }
6382#endif
6383
6384 return return_value;
6385}
Definition: tif_dir.h:52
static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32 nstrips, uint64 **lpp)
Definition: tif_dirread.c:5649
Referenced by _TIFFFillStriles(), and EstimateStripByteCounts().
◆ _TIFFGetMaxColorChannels()
Definition at line 3502 of file tif_dirread.c.
3503{
3504 switch (photometric) {
3508 return 1;
3515 return 3;
3518 return 4;
3521 default:
3522 return 0;
3523 }
3524}
Referenced by TIFFReadDirectory().
◆ _TIFFGetStrileOffsetOrByteCountValue()
|
static |
Definition at line 6246 of file tif_dirread.c.
6250{
6252 if( pbErr )
6253 *pbErr = 0;
6255 {
6257 /* If the values may fit in the toff_long/toff_long8 member */
6258 /* then use _TIFFFillStriles to simplify _TIFFFetchStrileValue */
6259 dirent->tdir_count <= 4 )
6260 {
6262 {
6263 if( pbErr )
6264 *pbErr = 1;
6265 /* Do not return, as we want this function to always */
6266 /* return the same value if called several times with */
6267 /* the same arguments */
6268 }
6269 }
6270 else
6271 {
6273 {
6274 if( pbErr )
6275 *pbErr = 1;
6276 return 0;
6277 }
6278 }
6279 }
6281 {
6282 if( pbErr )
6283 *pbErr = 1;
6284 return 0;
6285 }
6286 return (*parray)[strile];
6287}
static int _TIFFFetchStrileValue(TIFF *tif, uint32 strile, TIFFDirEntry *dirent, uint64 **parray)
Definition: tif_dirread.c:6143
Referenced by TIFFGetStrileByteCountWithErr(), and TIFFGetStrileOffsetWithErr().
◆ _TIFFPartialReadStripArray()
|
static |
Definition at line 6002 of file tif_dirread.c.
6004{
6006#define IO_CACHE_PAGE_SIZE 4096
6007
6008 size_t sizeofval;
6010 int sizeofvalint;
6011 uint64 nBaseOffset;
6012 uint64 nOffset;
6013 uint64 nOffsetStartPage;
6014 uint64 nOffsetEndPage;
6015 tmsize_t nToRead;
6016 tmsize_t nRead;
6017 uint64 nLastStripOffset;
6018 int iStartBefore;
6022
6024
6026 {
6028 }
6030 {
6032 }
6034 {
6036 }
6037 else
6038 {
6040 "Invalid type for [Strip|Tile][Offset/ByteCount] tag");
6041 panVals[strile] = 0;
6042 return 0;
6043 }
6044 sizeofvalint = (int)(sizeofval);
6045
6047 {
6049 if( bSwab )
6051 nBaseOffset = offset;
6052 }
6053 else
6054 {
6056 if( bSwab )
6058 nBaseOffset = offset;
6059 }
6060 /* To avoid later unsigned integer overflows */
6062 {
6064 "Cannot read offset/size for strile %d", strile);
6065 panVals[strile] = 0;
6066 return 0;
6067 }
6068 nOffset = nBaseOffset + sizeofval * strile;
6069 nOffsetStartPage =
6071 nOffsetEndPage = nOffsetStartPage + IO_CACHE_PAGE_SIZE;
6072
6073 if( nOffset + sizeofval > nOffsetEndPage )
6074 nOffsetEndPage += IO_CACHE_PAGE_SIZE;
6075#undef IO_CACHE_PAGE_SIZE
6076
6077 nLastStripOffset = nBaseOffset + arraySize * sizeofval;
6078 if( nLastStripOffset < nOffsetEndPage )
6079 nOffsetEndPage = nLastStripOffset;
6080 if( nOffsetStartPage >= nOffsetEndPage )
6081 {
6083 "Cannot read offset/size for strile %d", strile);
6084 panVals[strile] = 0;
6085 return 0;
6086 }
6088 {
6089 panVals[strile] = 0;
6090 return 0;
6091 }
6092
6093 nToRead = (tmsize_t)(nOffsetEndPage - nOffsetStartPage);
6095 if( nRead < nToRead )
6096 {
6098 "Cannot read offset/size for strile around ~%d", strile);
6099 return 0;
6100 }
6101 iStartBefore = -(int)((nOffset - nOffsetStartPage) / sizeofval);
6102 if( strile + iStartBefore < 0 )
6103 iStartBefore = -strile;
6107 ++i )
6108 {
6110 {
6115 if( bSwab )
6118 }
6120 {
6125 if( bSwab )
6128 }
6129 else
6130 {
6135 if( bSwab )
6138 }
6139 }
6140 return 1;
6141}
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
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
#define IO_CACHE_PAGE_SIZE
static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW uint64 _TIFFUnsanitizedAddUInt64AndInt(uint64 a, int b)
Definition: tif_dirread.c:5992
Referenced by _TIFFFetchStrileValue().
◆ _TIFFUnsanitizedAddUInt64AndInt()
|
static |
Definition at line 5992 of file tif_dirread.c.
5993{
5995}
Referenced by _TIFFPartialReadStripArray().
◆ allocChoppedUpStripArrays()
|
static |
Definition at line 5752 of file tif_dirread.c.
5754{
5756 uint64 bytecount;
5758 uint64 last_offset;
5759 uint64 last_bytecount;
5761 uint64 *newcounts;
5762 uint64 *newoffsets;
5763
5768 last_offset + last_bytecount < offset )
5769 {
5770 return;
5771 }
5772 bytecount = last_offset + last_bytecount - offset;
5773
5775 "for chopped \"StripByteCounts\" array");
5777 "for chopped \"StripOffsets\" array");
5779 /*
5780 * Unable to allocate new strip information, give up and use
5781 * the original one strip information.
5782 */
5784 _TIFFfree(newcounts);
5786 _TIFFfree(newoffsets);
5787 return;
5788 }
5789
5790 /*
5791 * Fill the strip information arrays with new bytecounts and offsets
5792 * that reflect the broken-up format.
5793 */
5795 {
5796 if (stripbytes > bytecount)
5797 stripbytes = bytecount;
5798 newcounts[i] = stripbytes;
5800 offset += stripbytes;
5801 bytecount -= stripbytes;
5802 }
5803
5804 /*
5805 * Replace old single strip info with multi-strip info.
5806 */
5809
5812 td->td_stripbytecount_p = newcounts;
5813 td->td_stripoffset_p = newoffsets;
5814#ifdef STRIPBYTECOUNTSORTED_UNUSED
5815 td->td_stripbytecountsorted = 1;
5816#endif
5818}
void * _TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:121
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
Referenced by ChopUpSingleUncompressedStrip(), and TryChopUpUncompressedBigTiff().
◆ ByteCountLooksBad()
Definition at line 3526 of file tif_dirread.c.
3527{
3528 /*
3529 * Assume we have wrong StripByteCount value (in case
3530 * of single strip) in following cases:
3531 * - it is equal to zero along with StripOffset;
3532 * - it is larger than file itself (in case of uncompressed
3533 * image);
3534 * - it is smaller than the size of the bytes per row
3535 * multiplied on the number of rows. The last case should
3536 * not be checked in the case of writing new image,
3537 * because we may do not know the exact strip size
3538 * until the whole image will be written and directory
3539 * dumped out.
3540 */
3543 uint64 filesize;
3544
3546 return 0;
3547 if (bytecount == 0)
3548 return 1;
3550 return 0;
3551 filesize = TIFFGetFileSize(tif);
3553 return 1;
3555 {
3559 {
3560 return 1;
3561 }
3562 if( bytecount < scanlinesize * tif->tif_dir.td_imagelength)
3563 return 1;
3564 }
3565 return 0;
3566}
Referenced by TIFFReadDirectory().
◆ CheckDirCount()
|
static |
Definition at line 4679 of file tif_dirread.c.
4680{
4687 return (0);
4695 return (1);
4696 }
4697 return (1);
4698}
Definition: tif_dir.h:282
const TIFFField * TIFFFieldWithTag(TIFF *tif, uint32 tag)
Definition: tif_dirinfo.c:558
void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_warning.c:65
Referenced by TIFFReadCustomDirectory().
◆ ChopUpSingleUncompressedStrip()
Definition at line 5828 of file tif_dirread.c.
5829{
5831 uint64 bytecount;
5833 uint32 rowblock;
5834 uint64 rowblockbytes;
5835 uint64 stripbytes;
5836 uint32 nstrips;
5837 uint32 rowsperstrip;
5838
5839 bytecount = TIFFGetStrileByteCount(tif, 0);
5840 /* On a newly created file, just re-opened to be filled, we */
5841 /* don't want strip chop to trigger as it is going to cause issues */
5842 /* later ( StripOffsets and StripByteCounts improperly filled) . */
5844 return;
5848 (!isUpSampled(tif)))
5849 rowblock = td->td_ycbcrsubsampling[1];
5850 else
5851 rowblock = 1;
5852 rowblockbytes = TIFFVTileSize64(tif, rowblock);
5853 /*
5854 * Make the rows hold at least one scanline, but fill specified amount
5855 * of data if possible.
5856 */
5858 stripbytes = rowblockbytes;
5859 rowsperstrip = rowblock;
5860 } else if (rowblockbytes > 0 ) {
5861 uint32 rowblocksperstrip;
5863 rowsperstrip = rowblocksperstrip * rowblock;
5864 stripbytes = rowblocksperstrip * rowblockbytes;
5865 }
5866 else
5867 return;
5868
5869 /*
5870 * never increase the number of rows per strip
5871 */
5873 return;
5875 if( nstrips == 0 )
5876 return;
5877
5878 /* If we are going to allocate a lot of memory, make sure that the */
5879 /* file is as big as needed */
5881 nstrips > 1000000 &&
5884 {
5885 return;
5886 }
5887
5888 allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
5889}
static void allocChoppedUpStripArrays(TIFF *tif, uint32 nstrips, uint64 stripbytes, uint32 rowsperstrip)
Definition: tif_dirread.c:5752
Referenced by TIFFReadDirectory().
◆ EstimateStripByteCounts()
|
static |
Definition at line 4509 of file tif_dirread.c.
4510{
4512
4513 TIFFDirEntry *dp;
4515 uint32 strip;
4516
4517 /* Do not try to load stripbytecount as we will compute it */
4519 return -1;
4520
4525 "for \"StripByteCounts\" array");
4527 return -1;
4528
4531 uint64 filesize;
4533 filesize = TIFFGetFileSize(tif);
4536 else
4538 /* calculate amount of space used by indirect values */
4540 {
4541 uint32 typewidth;
4544 if (typewidth == 0) {
4546 "Cannot determine size of unknown tag type %d",
4547 dp->tdir_type);
4548 return -1;
4549 }
4551 return -1;
4554 {
4556 datasize=0;
4557 }
4558 else
4559 {
4561 datasize=0;
4562 }
4564 return -1;
4566 }
4568 /* we should perhaps return in error ? */
4569 space = filesize;
4570 else
4576 /*
4577 * This gross hack handles the case were the offset to
4578 * the last strip is past the place where we think the strip
4579 * should begin. Since a strip of data must be contiguous,
4580 * it's safe to assume that we've overestimated the amount
4581 * of data in the strip and trim this number back accordingly.
4582 */
4583 strip--;
4585 return -1;
4588 /* Not sure what we should in that case... */
4589 td->td_stripbytecount_p[strip] = 0;
4590 } else {
4592 }
4593 }
4596
4598 td->td_stripbytecount_p[strip] = bytespertile;
4599 } else {
4603 {
4605 return -1;
4606 td->td_stripbytecount_p[strip] = rowbytes * rowsperstrip;
4607 }
4608 }
4612 return 1;
4613}
Definition: tiff.h:100
Definition: tiff.h:95
Definition: btrfs_drv.h:517
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
Referenced by TIFFReadDirectory().
◆ MissingRequired()
Definition at line 4616 of file tif_dirread.c.
Referenced by TIFFReadDirectory().
◆ TIFFCheckDirOffset()
Definition at line 4632 of file tif_dirread.c.
4633{
4635
4636 if (diroff == 0) /* no more directories */
4637 return 0;
4640 "Cannot handle more than 65535 TIFF directories");
4641 return 0;
4642 }
4643
4646 return 0;
4647 }
4648
4649 tif->tif_dirnumber++;
4650
4652 uint64* new_dirlist;
4653
4654 /*
4655 * XXX: Reduce memory allocation granularity of the dirlist
4656 * array.
4657 */
4660 if (!new_dirlist)
4661 return 0;
4663 tif->tif_dirlistsize = 65535;
4664 else
4666 tif->tif_dirlist = new_dirlist;
4667 }
4668
4670
4671 return 1;
4672}
void * _TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:97
Referenced by TIFFReadDirectory().
◆ TIFFCvtIEEEDoubleToNative()
Referenced by TIFFReadDirEntryDoubleArray(), and TIFFReadDirEntryFloatArray().
◆ TIFFCvtIEEEFloatToNative()
Referenced by TIFFReadDirEntryDoubleArray().
◆ TIFFFetchDirectory()
|
static |
Definition at line 4706 of file tif_dirread.c.
4708{
4710
4711 void* origdir;
4712 uint16 dircount16;
4713 uint32 dirsize;
4715 uint8* ma;
4716 TIFFDirEntry* mb;
4718
4719 assert(pdir);
4720
4721 tif->tif_diroff = diroff;
4722 if (nextdiroff)
4723 *nextdiroff = 0;
4727 "%s: Seek error accessing TIFF directory",
4728 tif->tif_name);
4729 return 0;
4730 }
4732 {
4735 "%s: Can not read TIFF directory count",
4736 tif->tif_name);
4737 return 0;
4738 }
4740 TIFFSwabShort(&dircount16);
4741 if (dircount16>4096)
4742 {
4744 "Sanity check on directory count failed, this is probably not a valid IFD offset");
4745 return 0;
4746 }
4747 dirsize = 12;
4748 } else {
4749 uint64 dircount64;
4752 "%s: Can not read TIFF directory count",
4753 tif->tif_name);
4754 return 0;
4755 }
4757 TIFFSwabLong8(&dircount64);
4758 if (dircount64>4096)
4759 {
4761 "Sanity check on directory count failed, this is probably not a valid IFD offset");
4762 return 0;
4763 }
4764 dircount16 = (uint16)dircount64;
4765 dirsize = 20;
4766 }
4767 origdir = _TIFFCheckMalloc(tif, dircount16,
4768 dirsize, "to read TIFF directory");
4770 return 0;
4773 "%.100s: Can not read TIFF directory",
4774 tif->tif_name);
4775 _TIFFfree(origdir);
4776 return 0;
4777 }
4778 /*
4779 * Read offset to next directory for sequential scans if
4780 * needed.
4781 */
4782 if (nextdiroff)
4783 {
4785 {
4786 uint32 nextdiroff32;
4788 nextdiroff32 = 0;
4790 TIFFSwabLong(&nextdiroff32);
4791 *nextdiroff=nextdiroff32;
4792 } else {
4794 *nextdiroff = 0;
4796 TIFFSwabLong8(nextdiroff);
4797 }
4798 }
4799 } else {
4801 tmsize_t off;
4803 {
4805 return(0);
4806 }
4808
4809 /*
4810 * Check for integer overflow when validating the dir_off,
4811 * otherwise a very high offset may cause an OOB read and
4812 * crash the client. Make two comparisons instead of
4813 *
4814 * off + sizeof(uint16) > tif->tif_size
4815 *
4816 * to avoid overflow.
4817 */
4819 {
4823 "Can not read TIFF directory count");
4824 return 0;
4825 } else {
4828 }
4831 TIFFSwabShort(&dircount16);
4832 if (dircount16>4096)
4833 {
4835 "Sanity check on directory count failed, this is probably not a valid IFD offset");
4836 return 0;
4837 }
4838 dirsize = 12;
4839 }
4840 else
4841 {
4842 uint64 dircount64;
4846 "Can not read TIFF directory count");
4847 return 0;
4848 } else {
4851 }
4854 TIFFSwabLong8(&dircount64);
4855 if (dircount64>4096)
4856 {
4858 "Sanity check on directory count failed, this is probably not a valid IFD offset");
4859 return 0;
4860 }
4861 dircount16 = (uint16)dircount64;
4862 dirsize = 20;
4863 }
4864 if (dircount16 == 0 )
4865 {
4867 "Sanity check on directory count failed, zero tag directories not supported");
4868 return 0;
4869 }
4870 origdir = _TIFFCheckMalloc(tif, dircount16,
4871 dirsize,
4872 "to read TIFF directory");
4874 return 0;
4875 m=off+dircount16*dirsize;
4878 "Can not read TIFF directory");
4879 _TIFFfree(origdir);
4880 return 0;
4881 } else {
4883 dircount16 * dirsize);
4884 }
4885 if (nextdiroff) {
4886 off += dircount16 * dirsize;
4888 {
4889 uint32 nextdiroff32;
4892 nextdiroff32 = 0;
4893 else
4897 TIFFSwabLong(&nextdiroff32);
4898 *nextdiroff = nextdiroff32;
4899 }
4900 else
4901 {
4904 *nextdiroff = 0;
4905 else
4909 TIFFSwabLong8(nextdiroff);
4910 }
4911 }
4912 }
4915 "to read TIFF directory");
4917 {
4918 _TIFFfree(origdir);
4919 return 0;
4920 }
4921 ma=(uint8*)origdir;
4922 mb=dir;
4924 {
4935 {
4943 }
4944 else
4945 {
4952 }
4953 mb++;
4954 }
4955 _TIFFfree(origdir);
4956 *pdir = dir;
4957 return dircount16;
4958}
union TIFFDirEntry::@3465 tdir_offset
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFFetchNormalTag()
|
static |
Definition at line 4964 of file tif_dirread.c.
4965{
4968 uint32 fii;
4972 {
4974 "No definition found for tag %d",
4975 dp->tdir_tag);
4976 return 0;
4977 }
4978 fip=tif->tif_fields[fii];
4980 assert(fip->set_field_type!=TIFF_SETGET_OTHER); /* if so, we shouldn't arrive here but deal with this in specialized code */
4981 assert(fip->set_field_type!=TIFF_SETGET_INT); /* if so, we shouldn't arrive here as this is only the case for pseudo-tags */
4984 {
4986 break;
4988 {
4993 {
4994 uint32 mb = 0;
4997 {
5000 {
5001 if (*ma==0)
5002 break;
5003 ma++;
5004 mb++;
5005 }
5006 }
5008 TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" contains null byte in value; value incorrectly truncated during reading due to implementation limitations",fip->field_name);
5010 {
5011 uint8* o;
5012 TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte",fip->field_name);
5014 o=NULL;
5015 else
5018 {
5021 return(0);
5022 }
5027 data=o;
5028 }
5033 return(0);
5034 }
5035 }
5036 break;
5037 case TIFF_SETGET_UINT8:
5038 {
5044 {
5046 return(0);
5047 }
5048 }
5049 break;
5051 {
5057 {
5059 return(0);
5060 }
5061 }
5062 break;
5064 {
5070 {
5072 return(0);
5073 }
5074 }
5075 break;
5077 {
5083 {
5085 return(0);
5086 }
5087 }
5088 break;
5090 {
5096 {
5098 return(0);
5099 }
5100 }
5101 break;
5103 {
5109 {
5111 return(0);
5112 }
5113 }
5114 break;
5116 {
5122 {
5124 return(0);
5125 }
5126 }
5127 break;
5129 {
5135 "incorrect count for field \"%s\", expected 2, got %d",
5137 return(0);
5138 }
5141 {
5146 return(0);
5147 }
5148 }
5149 break;
5151 {
5157 "incorrect count for field \"%s\", expected %d, got %d",
5159 return 0;
5160 }
5161 else
5162 {
5165 {
5171 return(0);
5172 }
5173 }
5174 }
5175 break;
5177 {
5182 /* corrupt file */;
5183 else
5184 {
5187 {
5193 return(0);
5194 }
5195 }
5196 }
5197 break;
5199 {
5204 /* corrupt file */;
5205 else
5206 {
5209 {
5215 return(0);
5216 }
5217 }
5218 }
5219 break;
5221 {
5226 /* corrupt file */;
5227 else
5228 {
5231 {
5237 return(0);
5238 }
5239 }
5240 }
5241 break;
5243 {
5249 else
5250 {
5253 {
5256 {
5257 TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte. Forcing it to be null",fip->field_name);
5259 }
5264 return(0);
5265 }
5266 }
5267 }
5268 break;
5270 {
5276 else
5277 {
5280 {
5286 return(0);
5287 }
5288 }
5289 }
5290 break;
5292 {
5298 else
5299 {
5302 {
5308 return(0);
5309 }
5310 }
5311 }
5312 break;
5314 {
5320 else
5321 {
5324 {
5330 return(0);
5331 }
5332 }
5333 }
5334 break;
5336 {
5342 else
5343 {
5346 {
5352 return(0);
5353 }
5354 }
5355 }
5356 break;
5358 {
5364 else
5365 {
5368 {
5374 return(0);
5375 }
5376 }
5377 }
5378 break;
5380 {
5386 else
5387 {
5390 {
5396 return(0);
5397 }
5398 }
5399 }
5400 break;
5402 {
5408 else
5409 {
5412 {
5418 return(0);
5419 }
5420 }
5421 }
5422 break;
5424 {
5430 {
5433 {
5434 TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte. Forcing it to be null",fip->field_name);
5436 }
5441 return(0);
5442 }
5443 }
5444 break;
5446 {
5452 {
5458 return(0);
5459 }
5460 }
5461 break;
5463 {
5469 {
5475 return(0);
5476 }
5477 }
5478 break;
5480 {
5486 {
5492 return(0);
5493 }
5494 }
5495 break;
5497 {
5503 {
5509 return(0);
5510 }
5511 }
5512 break;
5514 {
5520 {
5526 return(0);
5527 }
5528 }
5529 break;
5531 {
5537 {
5543 return(0);
5544 }
5545 }
5546 break;
5548 {
5554 {
5560 return(0);
5561 }
5562 }
5563 break;
5565 {
5571 {
5577 return(0);
5578 }
5579 }
5580 break;
5582 {
5588 {
5594 return(0);
5595 }
5596 }
5597 break;
5599 {
5605 {
5611 return(0);
5612 }
5613 }
5614 break;
5616 {
5622 {
5628 return(0);
5629 }
5630 }
5631 break;
5632 default:
5634 break;
5635 }
5637 {
5639 return(0);
5640 }
5641 return(1);
5642}
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF *tif, TIFFDirEntry *direntry, uint64 **value)
Definition: tif_dirread.c:2130
static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32 **value)
Definition: tif_dirread.c:1633
static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF *tif, TIFFDirEntry *direntry, int32 **value)
Definition: tif_dirread.c:1802
static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
Definition: tif_dirread.c:2530
static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16 tagid, uint32 *fii)
Definition: tif_dirread.c:4358
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32 *value)
Definition: tif_dirread.c:378
static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF *tif, TIFFDirEntry *direntry, int16 **value)
Definition: tif_dirread.c:1466
static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err, const char *module, const char *tagname, int recover)
Definition: tif_dirread.c:3410
static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF *tif, TIFFDirEntry *direntry, uint8 *value)
Definition: tif_dirread.c:202
static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF *tif, TIFFDirEntry *direntry, float *value)
Definition: tif_dirread.c:539
static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF *tif, TIFFDirEntry *direntry, uint64 *value)
Definition: tif_dirread.c:749
static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF *tif, TIFFDirEntry *direntry, uint16 *value)
Definition: tif_dirread.c:292
static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:652
static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF *tif, TIFFDirEntry *direntry, int64 **value)
Definition: tif_dirread.c:2135
static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16 **value)
Definition: tif_dirread.c:1294
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF *tif, TIFFDirEntry *direntry, uint64 *value)
Definition: tif_dirread.c:461
static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF *tif, TIFFDirEntry *direntry, uint8 **value)
Definition: tif_dirread.c:934
static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF *tif, TIFFDirEntry *direntry, float **value)
Definition: tif_dirread.c:2285
static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF *tif, TIFFDirEntry *direntry, uint64 **value)
Definition: tif_dirread.c:2767
static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF *tif, TIFFDirEntry *direntry, int8 **value)
Definition: tif_dirread.c:1115
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFFetchStripThing()
|
static |
Definition at line 5649 of file tif_dirread.c.
5650{
5656 {
5659 return(0);
5660 }
5662 {
5663 uint64* resizeddata;
5666 uint32 max_nstrips = 1000000;
5667 if( pszMax )
5670 module,
5672 ( nstrips <= max_nstrips ) );
5673
5674 if( nstrips > max_nstrips )
5675 {
5677 return(0);
5678 }
5679
5681 if (resizeddata==0) {
5683 return(0);
5684 }
5686 _TIFFmemset(resizeddata+(uint32)dir->tdir_count,0,(nstrips-(uint32)dir->tdir_count)*sizeof(uint64));
5688 data=resizeddata;
5689 }
5690 *lpp=data;
5691 return(1);
5692}
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry, uint64 **value, uint64 maxcount)
Definition: tif_dirread.c:1963
Referenced by _TIFFFillStrilesInternal(), and TIFFReadDirectory().
◆ TIFFFetchSubjectDistance()
|
static |
Definition at line 5698 of file tif_dirread.c.
5699{
5703 m.l=0;
5711 else
5712 {
5714 {
5720 }
5721 else
5722 {
5725 }
5726 }
5728 {
5733 n=0.0;
5735 /*
5736 * XXX: Numerator 0xFFFFFFFF means that we have infinite
5737 * distance. Indicate that with a negative floating point
5738 * SubjectDistance value.
5739 */
5740 n=-1.0;
5741 else
5744 }
5745 else
5746 {
5748 return(0);
5749 }
5750}
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF *tif, uint64 offset, tmsize_t size, void *dest)
Definition: tif_dirread.c:3386
void TIFFSwabArrayOfLong(register uint32 *lp, tmsize_t n)
Definition: tif_swab.c:103
Definition: tif_dirread.c:175
Referenced by TIFFReadCustomDirectory().
◆ TIFFGetStrileByteCount()
Definition at line 6305 of file tif_dirread.c.
6306{
6308}
uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 strile, int *pbErr)
Definition: tif_dirread.c:6311
Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), ChopUpSingleUncompressedStrip(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFRawStripSize64(), TIFFReadDirectory(), TIFFReadRawStrip(), TIFFReadRawTile(), TIFFSeek(), TIFFStartStrip(), TIFFStartTile(), and TryChopUpUncompressedBigTiff().
◆ TIFFGetStrileByteCountWithErr()
Definition at line 6311 of file tif_dirread.c.
6312{
6315 &(td->td_stripbytecount_entry),
6316 &(td->td_stripbytecount_p), pbErr);
6317}
static uint64 _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32 strile, TIFFDirEntry *dirent, uint64 **parray, int *pbErr)
Definition: tif_dirread.c:6246
Referenced by TIFFGetStrileByteCount().
◆ TIFFGetStrileOffset()
Definition at line 6290 of file tif_dirread.c.
6291{
6293}
uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr)
Definition: tif_dirread.c:6296
Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFReadDirectory(), TIFFReadRawStrip1(), TIFFReadRawStripOrTile2(), TIFFReadRawTile1(), and TryChopUpUncompressedBigTiff().
◆ TIFFGetStrileOffsetWithErr()
Definition at line 6296 of file tif_dirread.c.
Referenced by TIFFGetStrileOffset().
◆ TIFFReadCustomDirectory()
| int TIFFReadCustomDirectory | ( | TIFF * | tif, |
| toff_t | diroff, | ||
| const TIFFFieldArray * | infoarray | ||
| ) |
Definition at line 4394 of file tif_dirread.c.
4396{
4399 uint16 dircount;
4400 TIFFDirEntry* dp;
4401 uint16 di;
4403 uint32 fii;
4404 _TIFFSetupFields(tif, infoarray);
4406 if (!dircount)
4407 {
4410 return 0;
4411 }
4412 TIFFFreeDirectory(tif);
4416 {
4419 {
4421 "Unknown field with tag %d (0x%x) encountered",
4424 dp->tdir_tag,
4426 1)) {
4428 "Registering anonymous field with tag %d (0x%x) failed",
4431 } else {
4434 }
4435 }
4437 {
4438 fip=tif->tif_fields[fii];
4441 else
4442 {
4443 /* check data type */
4445 {
4446 fii++;
4449 {
4450 fii=0xFFFF;
4451 break;
4452 }
4453 fip=tif->tif_fields[fii];
4454 }
4455 if (fii==0xFFFF)
4456 {
4458 "Wrong data type %d for \"%s\"; tag ignored",
4461 }
4462 else
4463 {
4464 /* check count if known in advance */
4467 {
4471 else
4475 }
4476 }
4477 }
4480 {
4483 break;
4484 default:
4486 break;
4487 }
4488 } /*-- if (!dp->tdir_ignore) */
4489 }
4490 }
4493 return 1;
4494}
Definition: nsiface.idl:2307
TIFFField * _TIFFCreateAnonField(TIFF *tif, uint32 tag, TIFFDataType field_type)
Definition: tif_dirinfo.c:634
void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *fieldarray)
Definition: tif_dirinfo.c:317
int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32 n)
Definition: tif_dirinfo.c:369
static void TIFFReadDirectoryCheckOrder(TIFF *tif, TIFFDirEntry *dir, uint16 dircount)
Definition: tif_dirread.c:4324
static uint16 TIFFFetchDirectory(TIFF *tif, uint64 diroff, TIFFDirEntry **pdir, uint64 *nextdiroff)
Definition: tif_dirread.c:4706
static int TIFFFetchSubjectDistance(TIFF *, TIFFDirEntry *)
Definition: tif_dirread.c:5698
static int TIFFFetchNormalTag(TIFF *, TIFFDirEntry *, int recover)
Definition: tif_dirread.c:4964
Referenced by TIFFReadEXIFDirectory().
◆ TIFFReadDirectory()
Definition at line 3574 of file tif_dirread.c.
3575{
3578 uint16 dircount;
3579 TIFFDirEntry* dp;
3580 uint16 di;
3583 toff_t nextdiroff;
3585 int color_channels;
3586
3589 return 0; /* last offset or bad offset (IFD looping) */
3591 tif->tif_curdir++;
3592 nextdiroff = tif->tif_nextdiroff;
3594 if (!dircount)
3595 {
3598 return 0;
3599 }
3601
3602 /*
3603 * Mark duplicates of any tag to be ignored (bugzilla 1994)
3604 * to avoid certain pathological problems.
3605 */
3606 {
3607 TIFFDirEntry* ma;
3608 uint16 mb;
3610 {
3611 TIFFDirEntry* na;
3612 uint16 nb;
3613 for (na=ma+1, nb=mb+1; nb<dircount; na++, nb++)
3614 {
3617 }
3618 }
3619 }
3620 }
3621
3624 tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
3625
3626 /* free any old stuff and reinit */
3627 TIFFFreeDirectory(tif);
3628 TIFFDefaultDirectory(tif);
3629 /*
3630 * Electronic Arts writes gray-scale TIFF files
3631 * without a PlanarConfiguration directory entry.
3632 * Thus we setup a default value here, even though
3633 * the TIFF spec says there is no default value.
3634 */
3636 /*
3637 * Setup default value and then make a pass over
3638 * the fields to check type and tag information,
3639 * and to extract info required to size data
3640 * structures. A second pass is made afterwards
3641 * to read in everything not taken in the first pass.
3642 * But we must process the Compression tag first
3643 * in order to merge in codec-private tag definitions (otherwise
3644 * we may get complaints about unknown tags). However, the
3645 * Compression tag may be dependent on the SamplesPerPixel
3646 * tag value because older TIFF specs permitted Compression
3647 * to be written as a SamplesPerPixel-count tag entry.
3648 * Thus if we don't first figure out the correct SamplesPerPixel
3649 * tag value then we may end up ignoring the Compression tag
3650 * value because it has an incorrect count value (if the
3651 * true value of SamplesPerPixel is not 1).
3652 */
3654 if (dp)
3655 {
3657 goto bad;
3659 }
3661 if (dp)
3662 {
3663 /*
3664 * The 5.0 spec says the Compression tag has one value, while
3665 * earlier specs say it has one value per sample. Because of
3666 * this, we accept the tag if one value is supplied with either
3667 * count.
3668 */
3675 {
3677 goto bad;
3678 }
3680 goto bad;
3682 }
3683 else
3684 {
3686 goto bad;
3687 }
3688 /*
3689 * First real pass over the directory.
3690 */
3692 {
3694 {
3697 {
3699 "Unknown field with tag %d (0x%x) encountered",
3701 /* the following knowingly leaks the
3702 anonymous field structure */
3704 _TIFFCreateAnonField(tif,
3705 dp->tdir_tag,
3707 1)) {
3709 module,
3710 "Registering anonymous field with tag %d (0x%x) failed",
3711 dp->tdir_tag,
3712 dp->tdir_tag);
3714 } else {
3717 }
3718 }
3719 }
3721 {
3722 fip=tif->tif_fields[fii];
3725 else
3726 {
3728 {
3734 break;
3745 goto bad;
3747 break;
3748 default:
3751 break;
3752 }
3753 }
3754 }
3755 }
3756 /*
3757 * XXX: OJPEG hack.
3758 * If a) compression is OJPEG, b) planarconfig tag says it's separate,
3759 * c) strip offsets/bytecounts tag are both present and
3760 * d) both contain exactly one value, then we consistently find
3761 * that the buggy implementation of the buggy compression scheme
3762 * matches contig planarconfig best. So we 'fix-up' the tag here
3763 */
3766 {
3768 goto bad;
3771 {
3773 TIFFTAG_STRIPBYTECOUNTS);
3775 {
3778 "Planarconfig tag value assumed incorrect, "
3779 "assuming data is contig instead of chunky");
3780 }
3781 }
3782 }
3783 /*
3784 * Allocate directory structure and setup defaults.
3785 */
3787 {
3789 goto bad;
3790 }
3791 /*
3792 * Setup appropriate structures (by strip or by tile)
3793 */
3799 tif->tif_flags &= ~TIFF_ISTILED;
3800 } else {
3803 }
3806 "Cannot handle zero number of %s",
3808 goto bad;
3809 }
3814#ifdef OJPEG_SUPPORT
3816 (isTiled(tif)==0) &&
3818 /*
3819 * XXX: OJPEG hack.
3820 * If a) compression is OJPEG, b) it's not a tiled TIFF,
3821 * and c) the number of strips is 1,
3822 * then we tolerate the absence of stripoffsets tag,
3823 * because, presumably, all required data is in the
3824 * JpegInterchangeFormat stream.
3825 */
3827 } else
3828#endif
3829 {
3830 MissingRequired(tif,
3832 goto bad;
3833 }
3834 }
3835 /*
3836 * Second pass: extract other information.
3837 */
3839 {
3842 {
3848 /*
3849 * The MinSampleValue, MaxSampleValue, BitsPerSample
3850 * DataType and SampleFormat tags are supposed to be
3851 * written as one value/sample, but some vendors
3852 * incorrectly write one value only -- so we accept
3853 * that as well (yuck). Other vendors write correct
3854 * value for NumberOfSamples, but incorrect one for
3855 * BitsPerSample and friends, and we will read this
3856 * too.
3857 */
3858 {
3865 {
3868 goto bad;
3869 }
3871 goto bad;
3873 bitspersample_read = TRUE;
3874 }
3875 break;
3878 {
3879
3882 uint32 saved_flags;
3886 else
3889 {
3892 goto bad;
3893 }
3894 saved_flags = tif->tif_flags;
3897 tif->tif_flags = saved_flags;
3900 goto bad;
3901 }
3902 break;
3907 break;
3912 break;
3915 {
3917 uint32 countpersample;
3918 uint32 countrequired;
3919 uint32 incrementpersample;
3921 /* It would be dangerous to instantiate those tag values */
3922 /* since if td_bitspersample has not yet been read (due to */
3923 /* unordered tags), it could be read afterwards with a */
3924 /* values greater than the default one (1), which may cause */
3925 /* crashes in user code */
3926 if( !bitspersample_read )
3927 {
3930 "Ignoring %s since BitsPerSample tag not found",
3932 continue;
3933 }
3934 /* ColorMap or TransferFunction for high bit */
3935 /* depths do not make much sense and could be */
3936 /* used as a denial of service vector */
3938 {
3941 "Ignoring %s because BitsPerSample=%d>24",
3944 continue;
3945 }
3948 {
3949 countrequired=countpersample;
3950 incrementpersample=0;
3951 }
3952 else
3953 {
3954 countrequired=3*countpersample;
3955 incrementpersample=countpersample;
3956 }
3959 else
3962 {
3965 }
3966 else
3967 {
3970 }
3971 }
3972 break;
3973/* BEGIN REV 4.0 COMPATIBILITY */
3975 {
3976 uint16 valueo;
3979 {
3980 switch (valueo)
3981 {
3985 }
3988 }
3989 }
3990 break;
3991/* END REV 4.0 COMPATIBILITY */
3992 default:
3994 break;
3995 }
3996 } /* -- if (!dp->tdir_ignore) */
3997 } /* -- for-loop -- */
3998
4008 {
4009 /* Directory typically created with TIFFDeferStrileArrayWriting() */
4010 TIFFSetupStrips(tif);
4011 }
4013 {
4015 {
4019 {
4020 goto bad;
4021 }
4022 }
4024 {
4028 {
4029 goto bad;
4030 }
4031 }
4032 }
4033
4034 /*
4035 * OJPEG hack:
4036 * - If a) compression is OJPEG, and b) photometric tag is missing,
4037 * then we consistently find that photometric should be YCbCr
4038 * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
4039 * then we consistently find that the buggy implementation of the
4040 * buggy compression scheme matches photometric YCbCr instead.
4041 * - If a) compression is OJPEG, and b) bitspersample tag is missing,
4042 * then we consistently find bitspersample should be 8.
4043 * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4044 * and c) photometric is RGB or YCbCr, then we consistently find
4045 * samplesperpixel should be 3
4046 * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4047 * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
4048 * find samplesperpixel should be 3
4049 */
4051 {
4053 {
4055 "Photometric tag is missing, assuming data is YCbCr");
4057 goto bad;
4058 }
4060 {
4063 "Photometric tag value assumed incorrect, "
4064 "assuming data is YCbCr instead of RGB");
4065 }
4067 {
4069 "BitsPerSample tag is missing, assuming 8 bits per sample");
4071 goto bad;
4072 }
4074 {
4076 {
4078 "SamplesPerPixel tag is missing, "
4079 "assuming correct SamplesPerPixel value is 3");
4081 goto bad;
4082 }
4084 {
4086 "SamplesPerPixel tag is missing, "
4087 "applying correct SamplesPerPixel value of 3");
4089 goto bad;
4090 }
4093 {
4094 /*
4095 * SamplesPerPixel tag is missing, but is not required
4096 * by spec. Assume correct SamplesPerPixel value of 1.
4097 */
4099 goto bad;
4100 }
4101 }
4102 }
4103
4104 /*
4105 * Make sure all non-color channels are extrasamples.
4106 * If it's not the case, define them as such.
4107 */
4109 if (color_channels && tif->tif_dir.td_samplesperpixel - tif->tif_dir.td_extrasamples > color_channels) {
4110 uint16 old_extrasamples;
4111 uint16 *new_sampleinfo;
4112
4114 "color channels and ExtraSamples doesn't match SamplesPerPixel. "
4115 "Defining non-color channels as ExtraSamples.");
4116
4119
4120 // sampleinfo should contain information relative to these new extra samples
4122 if (!new_sampleinfo) {
4124 "temporary new sampleinfo array (%d 16 bit elements)",
4126 goto bad;
4127 }
4128
4131 _TIFFfree(new_sampleinfo);
4132 }
4133
4134 /*
4135 * Verify Palette image has a Colormap.
4136 */
4143 else {
4145 goto bad;
4146 }
4147 }
4148 /*
4149 * OJPEG hack:
4150 * We do no further messing with strip/tile offsets/bytecounts in OJPEG
4151 * TIFFs
4152 */
4154 {
4155 /*
4156 * Attempt to deal with a missing StripByteCounts tag.
4157 */
4159 /*
4160 * Some manufacturers violate the spec by not giving
4161 * the size of the strips. In this case, assume there
4162 * is one uncompressed strip of data.
4163 */
4169 goto bad;
4170 }
4172 "TIFF directory is missing required "
4173 "\"StripByteCounts\" field, calculating from imagelength");
4175 goto bad;
4176
4179 && ByteCountLooksBad(tif)) {
4180 /*
4181 * XXX: Plexus (and others) sometimes give a value of
4182 * zero for a tag when they don't know what the
4183 * correct value is! Try and handle the simple case
4184 * of estimating the size of a one strip image.
4185 */
4187 "Bogus \"StripByteCounts\" field, ignoring and calculating from imagelength");
4189 goto bad;
4190
4196 && TIFFGetStrileByteCount(tif, 0) != 0
4197 && TIFFGetStrileByteCount(tif, 1) != 0 ) {
4198 /*
4199 * XXX: Some vendors fill StripByteCount array with
4200 * absolutely wrong values (it can be equal to
4201 * StripOffset array, for example). Catch this case
4202 * here.
4203 *
4204 * We avoid this check if deferring strile loading
4205 * as it would always force us to load the strip/tile
4206 * information.
4207 */
4209 "Wrong \"StripByteCounts\" field, ignoring and calculating from imagelength");
4211 goto bad;
4212 }
4213 }
4215 {
4218 }
4220 {
4223 else
4225 }
4226
4227#ifdef STRIPBYTECOUNTSORTED_UNUSED
4228 /*
4229 * XXX: We can optimize checking for the strip bounds using the sorted
4230 * bytecounts array. See also comments for TIFFAppendToStrip()
4231 * function in tif_write.c.
4232 */
4234 uint32 strip;
4235
4236 tif->tif_dir.td_stripbytecountsorted = 1;
4239 TIFFGetStrileOffset(tif, strip)) {
4240 tif->tif_dir.td_stripbytecountsorted = 0;
4241 break;
4242 }
4243 }
4244 }
4245#endif
4246
4247 /*
4248 * An opportunity for compression mode dependent tag fixup
4249 */
4250 (*tif->tif_fixuptags)(tif);
4251
4252 /*
4253 * Some manufacturers make life difficult by writing
4254 * large amounts of uncompressed data as a single strip.
4255 * This is contrary to the recommendations of the spec.
4256 * The following makes an attempt at breaking such images
4257 * into strips closer to the recommended 8k bytes. A
4258 * side effect, however, is that the RowsPerStrip tag
4259 * value may be changed.
4260 */
4265 {
4266 ChopUpSingleUncompressedStrip(tif);
4267 }
4268
4269 /* There are also uncompressed striped files with strips larger than */
4270 /* 2 GB, which make them unfriendly with a lot of code. If possible, */
4271 /* try to expose smaller "virtual" strips. */
4275 TIFFStripSize64(tif) > 0x7FFFFFFFUL )
4276 {
4277 TryChopUpUncompressedBigTiff(tif);
4278 }
4279
4280 /*
4281 * Clear the dirty directory flag.
4282 */
4283 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
4284 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
4285
4286 /*
4287 * Reinitialize i/o since we are starting on a new directory.
4288 */
4294
4298 "Cannot handle zero scanline size");
4299 return (0);
4300 }
4301
4306 "Cannot handle zero tile size");
4307 return (0);
4308 }
4309 } else {
4312 "Cannot handle zero strip size");
4313 return (0);
4314 }
4315 }
4316 return (1);
4317bad:
4320 return (0);
4321}
void _TIFFsetShortArray(uint16 **wpp, uint16 *wp, uint32 n)
Definition: tif_dir.c:63
int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag)
Definition: tif_dirinfo.c:958
static int TIFFCheckDirOffset(TIFF *tif, uint64 diroff)
Definition: tif_dirread.c:4632
static void TryChopUpUncompressedBigTiff(TIFF *)
Definition: tif_dirread.c:5898
static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir, uint16 dircount)
Definition: tif_dirread.c:4509
static void ChopUpSingleUncompressedStrip(TIFF *)
Definition: tif_dirread.c:5828
static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF *tif, TIFFDirEntry *direntry, uint16 *value)
Definition: tif_dirread.c:2828
static int _TIFFGetMaxColorChannels(uint16 photometric)
Definition: tif_dirread.c:3502
static TIFFDirEntry * TIFFReadDirectoryFindEntry(TIFF *tif, TIFFDirEntry *dir, uint16 dircount, uint16 tagid)
Definition: tif_dirread.c:4344
Definition: pdh_main.c:94
Referenced by TIFFClientOpen(), TIFFSetDirectory(), and TIFFSetSubDirectory().
◆ TIFFReadDirectoryCheckOrder()
|
static |
Definition at line 4324 of file tif_dirread.c.
4325{
4329 TIFFDirEntry* o;
4330 m=0;
4332 {
4334 {
4336 "Invalid TIFF directory; tags are not sorted in ascending order");
4337 break;
4338 }
4340 }
4341}
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFReadDirectoryFindEntry()
|
static |
◆ TIFFReadDirectoryFindFieldInfo()
Definition at line 4358 of file tif_dirread.c.
4359{
4360 int32 ma,mb,mc;
4361 ma=-1;
4363 while (1)
4364 {
4365 if (ma+1==mc)
4366 {
4367 *fii = FAILED_FII;
4368 return;
4369 }
4370 mb=(ma+mc)/2;
4372 break;
4374 ma=mb;
4375 else
4376 mc=mb;
4377 }
4378 while (1)
4379 {
4380 if (mb==0)
4381 break;
4383 break;
4384 mb--;
4385 }
4386 *fii=mb;
4387}
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
Referenced by TIFFFetchNormalTag(), TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFReadDirEntryArray()
|
static |
Definition at line 928 of file tif_dirread.c.
929{
932}
static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry, uint32 *count, uint32 desttypesize, void **value, uint64 maxcount)
Definition: tif_dirread.c:833
Referenced by TIFFReadDirEntryByteArray(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryIfd8Array(), TIFFReadDirEntryLongArray(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryArrayWithLimit()
|
static |
Definition at line 833 of file tif_dirread.c.
836{
837 int typesize;
840 uint64 target_count64;
842
843 target_count64 = (direntry->tdir_count > maxcount) ?
844 maxcount : direntry->tdir_count;
845
846 if ((target_count64==0)||(typesize==0))
847 {
848 *value=0;
850 }
851 (void) desttypesize;
852
853 /*
854 * As a sanity check, make sure we have no more than a 2GB tag array
855 * in either the current data type or the dest data type. This also
856 * avoids problems with overflow of tmsize_t on 32bit systems.
857 */
862
864 datasize=(*count)*typesize;
866
869
873 {
875 }
876 else
877 {
881 }
883 {
886 else
887 {
894 else
897 {
900 }
901 }
902 }
903 else
904 {
907 else
908 {
915 else
918 {
921 }
922 }
923 }
926}
static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc(TIFF *tif, uint64 offset, tmsize_t size, void **pdest)
Definition: tif_dirread.c:778
Referenced by TIFFReadDirEntryArray(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryByte()
|
static |
Definition at line 202 of file tif_dirread.c.
203{
208 {
214 {
222 }
224 {
232 }
234 {
242 }
244 {
252 }
254 {
262 }
264 {
274 }
276 {
286 }
287 default:
289 }
290}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value)
Definition: tif_dirread.c:3117
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value)
Definition: tif_dirread.c:3093
static void TIFFReadDirEntryCheckedSshort(TIFF *tif, TIFFDirEntry *direntry, int16 *value)
Definition: tif_dirread.c:2906
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF *tif, TIFFDirEntry *direntry, int64 *value)
Definition: tif_dirread.c:2946
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value)
Definition: tif_dirread.c:3101
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value)
Definition: tif_dirread.c:3077
static void TIFFReadDirEntryCheckedShort(TIFF *tif, TIFFDirEntry *direntry, uint16 *value)
Definition: tif_dirread.c:2898
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF *tif, TIFFDirEntry *direntry, uint64 *value)
Definition: tif_dirread.c:2927
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value)
Definition: tif_dirread.c:3085
static void TIFFReadDirEntryCheckedLong(TIFF *tif, TIFFDirEntry *direntry, uint32 *value)
Definition: tif_dirread.c:2913
static void TIFFReadDirEntryCheckedByte(TIFF *tif, TIFFDirEntry *direntry, uint8 *value)
Definition: tif_dirread.c:2886
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value)
Definition: tif_dirread.c:3109
static void TIFFReadDirEntryCheckedSbyte(TIFF *tif, TIFFDirEntry *direntry, int8 *value)
Definition: tif_dirread.c:2892
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value)
Definition: tif_dirread.c:3069
static void TIFFReadDirEntryCheckedSlong(TIFF *tif, TIFFDirEntry *direntry, int32 *value)
Definition: tif_dirread.c:2920
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryByteArray()
|
static |
Definition at line 934 of file tif_dirread.c.
935{
938 void* origdata;
941 {
952 break;
953 default:
955 }
958 {
959 *value=0;
961 }
963 {
970 {
975 {
978 {
979 _TIFFfree(origdata);
981 }
982 m++;
983 }
986 }
987 }
990 {
991 _TIFFfree(origdata);
993 }
995 {
997 {
998 uint16* ma;
999 uint8* mb;
1001 ma=(uint16*)origdata;
1002 mb=data;
1004 {
1006 TIFFSwabShort(ma);
1009 break;
1010 *mb++=(uint8)(*ma++);
1011 }
1012 }
1013 break;
1015 {
1016 int16* ma;
1017 uint8* mb;
1019 ma=(int16*)origdata;
1020 mb=data;
1022 {
1027 break;
1028 *mb++=(uint8)(*ma++);
1029 }
1030 }
1031 break;
1033 {
1034 uint32* ma;
1035 uint8* mb;
1037 ma=(uint32*)origdata;
1038 mb=data;
1040 {
1042 TIFFSwabLong(ma);
1045 break;
1046 *mb++=(uint8)(*ma++);
1047 }
1048 }
1049 break;
1051 {
1052 int32* ma;
1053 uint8* mb;
1055 ma=(int32*)origdata;
1056 mb=data;
1058 {
1063 break;
1064 *mb++=(uint8)(*ma++);
1065 }
1066 }
1067 break;
1069 {
1070 uint64* ma;
1071 uint8* mb;
1073 ma=(uint64*)origdata;
1074 mb=data;
1076 {
1078 TIFFSwabLong8(ma);
1081 break;
1082 *mb++=(uint8)(*ma++);
1083 }
1084 }
1085 break;
1087 {
1088 int64* ma;
1089 uint8* mb;
1091 ma=(int64*)origdata;
1092 mb=data;
1094 {
1099 break;
1100 *mb++=(uint8)(*ma++);
1101 }
1102 }
1103 break;
1104 }
1105 _TIFFfree(origdata);
1107 {
1110 }
1113}
static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF *tif, TIFFDirEntry *direntry, uint32 *count, uint32 desttypesize, void **value)
Definition: tif_dirread.c:928
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryCheckedByte()
|
static |
Definition at line 2886 of file tif_dirread.c.
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedDouble()
|
static |
Definition at line 3043 of file tif_dirread.c.
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedFloat()
|
static |
Definition at line 3027 of file tif_dirread.c.
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedLong()
|
static |
Definition at line 2913 of file tif_dirread.c.
2914{
2918}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryIfd8(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedLong8()
|
static |
Definition at line 2927 of file tif_dirread.c.
2928{
2930 {
2938 }
2939 else
2944}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryIfd8(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedRational()
|
static |
Definition at line 2965 of file tif_dirread.c.
2966{
2968
2973 {
2981 }
2982 else
2986 /* Not completely sure what we should do when m.i[1]==0, but some */
2987 /* sanitizers do not like division by 0.0: */
2988 /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */
2990 *value=0.0;
2991 else
2994}
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedSbyte()
|
static |
Definition at line 2892 of file tif_dirread.c.
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedShort()
|
static |
Definition at line 2898 of file tif_dirread.c.
2899{
2901 /* *value=*(uint16*)(&direntry->tdir_offset); */
2904}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedSlong()
|
static |
Definition at line 2920 of file tif_dirread.c.
2921{
2925}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedSlong8()
|
static |
Definition at line 2946 of file tif_dirread.c.
2947{
2949 {
2957 }
2958 else
2963}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckedSrational()
|
static |
Definition at line 2996 of file tif_dirread.c.