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::@3466 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.
2997{
3004 {
3012 }
3013 else
3017 /* Not completely sure what we should do when m.i[1]==0, but some */
3018 /* sanitizers do not like division by 0.0: */
3019 /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */
3021 *value=0.0;
3022 else
3025}
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedSshort()
|
static |
Definition at line 2906 of file tif_dirread.c.
2907{
2911}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), and TIFFReadDirEntryShort().
◆ TIFFReadDirEntryCheckRangeByteLong()
|
static |
Definition at line 3093 of file tif_dirread.c.
3094{
3097 else
3099}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteLong8()
|
static |
Definition at line 3109 of file tif_dirread.c.
3110{
3113 else
3115}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSbyte()
|
static |
Definition at line 3069 of file tif_dirread.c.
3070{
3073 else
3075}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteShort()
|
static |
Definition at line 3077 of file tif_dirread.c.
3078{
3081 else
3083}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSlong()
|
static |
Definition at line 3101 of file tif_dirread.c.
3102{
3105 else
3107}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSlong8()
|
static |
Definition at line 3117 of file tif_dirread.c.
3118{
3121 else
3123}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSshort()
|
static |
Definition at line 3085 of file tif_dirread.c.
3086{
3089 else
3091}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeLong8Sbyte()
|
static |
Definition at line 3341 of file tif_dirread.c.
3342{
3345 else
3347}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLong8Slong()
|
static |
Definition at line 3359 of file tif_dirread.c.
3360{
3363 else
3365}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLong8Slong8()
|
static |
Definition at line 3368 of file tif_dirread.c.
3369{
3372 else
3374}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLong8Sshort()
|
static |
Definition at line 3350 of file tif_dirread.c.
3351{
3354 else
3356}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLongLong8()
|
static |
Definition at line 3294 of file tif_dirread.c.
3295{
3298 else
3300}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSbyte()
|
static |
Definition at line 3269 of file tif_dirread.c.
3270{
3273 else
3275}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSlong()
|
static |
Definition at line 3285 of file tif_dirread.c.
3286{
3289 else
3291}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSlong8()
|
static |
Definition at line 3303 of file tif_dirread.c.
3304{
3307 else
3309}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSshort()
|
static |
Definition at line 3277 of file tif_dirread.c.
3278{
3281 else
3283}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeSbyteByte()
|
static |
Definition at line 3125 of file tif_dirread.c.
3126{
3129 else
3131}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteLong()
|
static |
Definition at line 3149 of file tif_dirread.c.
3150{
3153 else
3155}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteLong8()
|
static |
Definition at line 3165 of file tif_dirread.c.
3166{
3169 else
3171}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteShort()
|
static |
Definition at line 3133 of file tif_dirread.c.
3134{
3137 else
3139}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteSlong()
|
static |
Definition at line 3157 of file tif_dirread.c.
3158{
3161 else
3163}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteSlong8()
|
static |
Definition at line 3173 of file tif_dirread.c.
3174{
3177 else
3179}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteSshort()
|
static |
Definition at line 3141 of file tif_dirread.c.
3142{
3145 else
3147}
Referenced by TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeShortLong()
|
static |
Definition at line 3197 of file tif_dirread.c.
3198{
3201 else
3203}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortLong8()
|
static |
Definition at line 3213 of file tif_dirread.c.
3214{
3217 else
3219}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSbyte()
|
static |
Definition at line 3181 of file tif_dirread.c.
3182{
3185 else
3187}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSlong()
|
static |
Definition at line 3205 of file tif_dirread.c.
3206{
3209 else
3211}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSlong8()
|
static |
Definition at line 3221 of file tif_dirread.c.
3222{
3225 else
3227}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSshort()
|
static |
Definition at line 3189 of file tif_dirread.c.
3190{
3193 else
3195}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeSlong8Long8()
|
static |
Definition at line 3377 of file tif_dirread.c.
3378{
3381 else
3383}
Referenced by TIFFReadDirEntrySlong8Array().
◆ TIFFReadDirEntryCheckRangeSlongLong()
|
static |
Definition at line 3312 of file tif_dirread.c.
3313{
3316 else
3318}
Referenced by TIFFReadDirEntrySlongArray().
◆ TIFFReadDirEntryCheckRangeSlongLong8()
|
static |
Definition at line 3322 of file tif_dirread.c.
3323{
3326 else
3328}
Referenced by TIFFReadDirEntrySlongArray().
◆ TIFFReadDirEntryCheckRangeSlongSlong8()
|
static |
Definition at line 3332 of file tif_dirread.c.
3333{
3336 else
3338}
Referenced by TIFFReadDirEntrySlongArray().
◆ TIFFReadDirEntryCheckRangeSshortLong()
|
static |
Definition at line 3237 of file tif_dirread.c.
3238{
3241 else
3243}
Referenced by TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortLong8()
|
static |
Definition at line 3253 of file tif_dirread.c.
3254{
3257 else
3259}
Referenced by TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortShort()
|
static |
Definition at line 3229 of file tif_dirread.c.
3230{
3233 else
3235}
Referenced by TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortSlong()
|
static |
Definition at line 3245 of file tif_dirread.c.
3246{
3249 else
3251}
Referenced by TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortSlong8()
|
static |
Definition at line 3261 of file tif_dirread.c.
3262{
3265 else
3267}
Referenced by TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryData()
|
static |
Definition at line 3386 of file tif_dirread.c.
Referenced by TIFFFetchSubjectDistance(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryCheckedDouble(), TIFFReadDirEntryCheckedLong8(), TIFFReadDirEntryCheckedRational(), TIFFReadDirEntryCheckedSlong8(), and TIFFReadDirEntryCheckedSrational().
◆ TIFFReadDirEntryDataAndRealloc()
|
static |
Definition at line 778 of file tif_dirread.c.
780{
781#if SIZEOF_SIZE_T == 8
783#endif
784 tmsize_t already_read = 0;
785
787
790
791 /* On 64 bit processes, read first a maximum of 1 MB, then 10 MB, etc */
792 /* so as to avoid allocating too much memory in case the file is too */
793 /* short. We could ask for the file size, but this might be */
794 /* expensive with some I/O layers (think of reading a gzipped file) */
795 /* Restrict to 64 bit processes, so as to avoid reallocs() */
796 /* on 32 bit processes where virtual memory is scarce. */
798 {
799 void* new_dest;
800 tmsize_t bytes_read;
802#if SIZEOF_SIZE_T == 8
804 {
805 to_read = threshold;
806 threshold *= THRESHOLD_MULTIPLIER;
807 }
808#endif
809
811 *pdest, already_read + to_read);
813 {
815 "Failed to allocate memory for %s "
816 "(%ld elements of %ld bytes each)",
817 "TIFFReadDirEntryArray",
820 }
821 *pdest = new_dest;
822
823 bytes_read = TIFFReadFile(tif,
825 already_read += bytes_read;
828 }
829 }
831}
Referenced by TIFFReadDirEntryArrayWithLimit().
◆ TIFFReadDirEntryDouble()
|
static |
Definition at line 652 of file tif_dirread.c.
653{
658 {
660 {
665 }
667 {
672 }
674 {
679 }
681 {
686 }
688 {
693 }
695 {
700 }
702 {
707#if defined(__WIN32__) && (_MSC_VER < 1500)
708 /*
709 * XXX: MSVC 6.0 does not support conversion
710 * of 64-bit integers into floating point
711 * values.
712 */
714#else
716#endif
718 }
720 {
727 }
735 {
740 }
744 default:
746 }
747}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:2996
static void TIFFReadDirEntryCheckedFloat(TIFF *tif, TIFFDirEntry *direntry, float *value)
Definition: tif_dirread.c:3027
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:3043
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:2965
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryDoubleArray()
|
static |
Definition at line 2530 of file tif_dirread.c.
2531{
2534 void* origdata;
2537 {
2550 break;
2551 default:
2553 }
2556 {
2557 *value=0;
2559 }
2561 {
2568 }
2571 {
2572 _TIFFfree(origdata);
2574 }
2576 {
2578 {
2579 uint8* ma;
2580 double* mb;
2582 ma=(uint8*)origdata;
2583 mb=data;
2585 *mb++=(double)(*ma++);
2586 }
2587 break;
2589 {
2590 int8* ma;
2591 double* mb;
2593 ma=(int8*)origdata;
2594 mb=data;
2596 *mb++=(double)(*ma++);
2597 }
2598 break;
2600 {
2601 uint16* ma;
2602 double* mb;
2604 ma=(uint16*)origdata;
2605 mb=data;
2607 {
2609 TIFFSwabShort(ma);
2610 *mb++=(double)(*ma++);
2611 }
2612 }
2613 break;
2615 {
2616 int16* ma;
2617 double* mb;
2619 ma=(int16*)origdata;
2620 mb=data;
2622 {
2625 *mb++=(double)(*ma++);
2626 }
2627 }
2628 break;
2630 {
2631 uint32* ma;
2632 double* mb;
2634 ma=(uint32*)origdata;
2635 mb=data;
2637 {
2639 TIFFSwabLong(ma);
2640 *mb++=(double)(*ma++);
2641 }
2642 }
2643 break;
2645 {
2646 int32* ma;
2647 double* mb;
2649 ma=(int32*)origdata;
2650 mb=data;
2652 {
2655 *mb++=(double)(*ma++);
2656 }
2657 }
2658 break;
2660 {
2661 uint64* ma;
2662 double* mb;
2664 ma=(uint64*)origdata;
2665 mb=data;
2667 {
2669 TIFFSwabLong8(ma);
2670#if defined(__WIN32__) && (_MSC_VER < 1500)
2671 /*
2672 * XXX: MSVC 6.0 does not support
2673 * conversion of 64-bit integers into
2674 * floating point values.
2675 */
2676 *mb++ = _TIFFUInt64ToDouble(*ma++);
2677#else
2678 *mb++ = (double)(*ma++);
2679#endif
2680 }
2681 }
2682 break;
2684 {
2685 int64* ma;
2686 double* mb;
2688 ma=(int64*)origdata;
2689 mb=data;
2691 {
2694 *mb++=(double)(*ma++);
2695 }
2696 }
2697 break;
2699 {
2700 uint32* ma;
2701 uint32 maa;
2702 uint32 mab;
2703 double* mb;
2705 ma=(uint32*)origdata;
2706 mb=data;
2708 {
2710 TIFFSwabLong(ma);
2711 maa=*ma++;
2713 TIFFSwabLong(ma);
2714 mab=*ma++;
2715 if (mab==0)
2716 *mb++=0.0;
2717 else
2719 }
2720 }
2721 break;
2723 {
2724 uint32* ma;
2725 int32 maa;
2726 uint32 mab;
2727 double* mb;
2729 ma=(uint32*)origdata;
2730 mb=data;
2732 {
2734 TIFFSwabLong(ma);
2735 maa=*(int32*)ma;
2736 ma++;
2738 TIFFSwabLong(ma);
2739 mab=*ma++;
2740 if (mab==0)
2741 *mb++=0.0;
2742 else
2744 }
2745 }
2746 break;
2748 {
2749 float* ma;
2750 double* mb;
2755 ma=(float*)origdata;
2756 mb=data;
2758 *mb++=(double)(*ma++);
2759 }
2760 break;
2761 }
2762 _TIFFfree(origdata);
2765}
void TIFFCvtIEEEFloatToNative(TIFF *, uint32, float *)
void TIFFCvtIEEEDoubleToNative(TIFF *, uint32, double *)
void TIFFSwabArrayOfLong8(register uint64 *lp, tmsize_t n)
Definition: tif_swab.c:120
Referenced by TIFFFetchNormalTag(), and TIFFReadDirectory().
◆ TIFFReadDirEntryFloat()
|
static |
Definition at line 539 of file tif_dirread.c.
540{
545 {
547 {
552 }
554 {
559 }
561 {
566 }
568 {
573 }
575 {
580 }
582 {
587 }
589 {
594#if defined(__WIN32__) && (_MSC_VER < 1500)
595 /*
596 * XXX: MSVC 6.0 does not support conversion
597 * of 64-bit integers into floating point
598 * values.
599 */
601#else
603#endif
605 }
607 {
614 }
616 {
623 }
625 {
632 }
637 {
646 }
647 default:
649 }
650}
static float(__cdecl *square_half_float)(float x
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryFloatArray()
|
static |
Definition at line 2285 of file tif_dirread.c.
2286{
2289 void* origdata;
2292 {
2305 break;
2306 default:
2308 }
2311 {
2312 *value=0;
2314 }
2316 {
2323 }
2326 {
2327 _TIFFfree(origdata);
2329 }
2331 {
2333 {
2334 uint8* ma;
2335 float* mb;
2337 ma=(uint8*)origdata;
2338 mb=data;
2340 *mb++=(float)(*ma++);
2341 }
2342 break;
2344 {
2345 int8* ma;
2346 float* mb;
2348 ma=(int8*)origdata;
2349 mb=data;
2351 *mb++=(float)(*ma++);
2352 }
2353 break;
2355 {
2356 uint16* ma;
2357 float* mb;
2359 ma=(uint16*)origdata;
2360 mb=data;
2362 {
2364 TIFFSwabShort(ma);
2365 *mb++=(float)(*ma++);
2366 }
2367 }
2368 break;
2370 {
2371 int16* ma;
2372 float* mb;
2374 ma=(int16*)origdata;
2375 mb=data;
2377 {
2380 *mb++=(float)(*ma++);
2381 }
2382 }
2383 break;
2385 {
2386 uint32* ma;
2387 float* mb;
2389 ma=(uint32*)origdata;
2390 mb=data;
2392 {
2394 TIFFSwabLong(ma);
2395 *mb++=(float)(*ma++);
2396 }
2397 }
2398 break;
2400 {
2401 int32* ma;
2402 float* mb;
2404 ma=(int32*)origdata;
2405 mb=data;
2407 {
2410 *mb++=(float)(*ma++);
2411 }
2412 }
2413 break;
2415 {
2416 uint64* ma;
2417 float* mb;
2419 ma=(uint64*)origdata;
2420 mb=data;
2422 {
2424 TIFFSwabLong8(ma);
2425#if defined(__WIN32__) && (_MSC_VER < 1500)
2426 /*
2427 * XXX: MSVC 6.0 does not support
2428 * conversion of 64-bit integers into
2429 * floating point values.
2430 */
2431 *mb++ = _TIFFUInt64ToFloat(*ma++);
2432#else
2433 *mb++ = (float)(*ma++);
2434#endif
2435 }
2436 }
2437 break;
2439 {
2440 int64* ma;
2441 float* mb;
2443 ma=(int64*)origdata;
2444 mb=data;
2446 {
2449 *mb++=(float)(*ma++);
2450 }
2451 }
2452 break;
2454 {
2455 uint32* ma;
2456 uint32 maa;
2457 uint32 mab;
2458 float* mb;
2460 ma=(uint32*)origdata;
2461 mb=data;
2463 {
2465 TIFFSwabLong(ma);
2466 maa=*ma++;
2468 TIFFSwabLong(ma);
2469 mab=*ma++;
2470 if (mab==0)
2471 *mb++=0.0;
2472 else
2474 }
2475 }
2476 break;
2478 {
2479 uint32* ma;
2480 int32 maa;
2481 uint32 mab;
2482 float* mb;
2484 ma=(uint32*)origdata;
2485 mb=data;
2487 {
2489 TIFFSwabLong(ma);
2490 maa=*(int32*)ma;
2491 ma++;
2493 TIFFSwabLong(ma);
2494 mab=*ma++;
2495 if (mab==0)
2496 *mb++=0.0;
2497 else
2499 }
2500 }
2501 break;
2503 {
2504 double* ma;
2505 float* mb;
2510 ma=(double*)origdata;
2511 mb=data;
2513 {
2520 }
2521 }
2522 break;
2523 }
2524 _TIFFfree(origdata);
2527}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryIfd8()
|
static |
Definition at line 749 of file tif_dirread.c.
750{
755 {
758 {
763 }
768 default:
770 }
771}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryIfd8Array()
|
static |
Definition at line 2767 of file tif_dirread.c.
2768{
2771 void* origdata;
2774 {
2779 break;
2780 default:
2782 }
2785 {
2786 *value=0;
2788 }
2790 {
2797 }
2800 {
2801 _TIFFfree(origdata);
2803 }
2805 {
2808 {
2809 uint32* ma;
2810 uint64* mb;
2812 ma=(uint32*)origdata;
2813 mb=data;
2815 {
2817 TIFFSwabLong(ma);
2818 *mb++=(uint64)(*ma++);
2819 }
2820 }
2821 break;
2822 }
2823 _TIFFfree(origdata);
2826}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong()
|
static |
Definition at line 378 of file tif_dirread.c.
379{
384 {
386 {
391 }
393 {
401 }
403 {
408 }
410 {
418 }
423 {
431 }
433 {
443 }
445 {
455 }
456 default:
458 }
459}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongLong8(uint64 value)
Definition: tif_dirread.c:3294
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value)
Definition: tif_dirread.c:3269
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value)
Definition: tif_dirread.c:3285
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value)
Definition: tif_dirread.c:3277
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong8(int64 value)
Definition: tif_dirread.c:3303
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong8()
|
static |
Definition at line 461 of file tif_dirread.c.
462{
467 {
469 {
474 }
476 {
484 }
486 {
491 }
493 {
501 }
503 {
508 }
510 {
518 }
523 {
533 }
534 default:
536 }
537}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong8(int64 value)
Definition: tif_dirread.c:3368
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value)
Definition: tif_dirread.c:3341
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong(int32 value)
Definition: tif_dirread.c:3359
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sshort(int16 value)
Definition: tif_dirread.c:3350
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong8Array()
|
static |
Definition at line 2130 of file tif_dirread.c.
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong8ArrayWithLimit()
|
static |
Definition at line 1963 of file tif_dirread.c.
1965{
1968 void* origdata;
1971 {
1980 break;
1981 default:
1983 }
1986 {
1987 *value=0;
1989 }
1991 {
1998 {
2003 {
2008 {
2009 _TIFFfree(origdata);
2011 }
2012 m++;
2013 }
2016 }
2017 }
2020 {
2021 _TIFFfree(origdata);
2023 }
2025 {
2027 {
2028 uint8* ma;
2029 uint64* mb;
2031 ma=(uint8*)origdata;
2032 mb=data;
2034 *mb++=(uint64)(*ma++);
2035 }
2036 break;
2038 {
2039 int8* ma;
2040 uint64* mb;
2042 ma=(int8*)origdata;
2043 mb=data;
2045 {
2048 break;
2049 *mb++=(uint64)(*ma++);
2050 }
2051 }
2052 break;
2054 {
2055 uint16* ma;
2056 uint64* mb;
2058 ma=(uint16*)origdata;
2059 mb=data;
2061 {
2063 TIFFSwabShort(ma);
2064 *mb++=(uint64)(*ma++);
2065 }
2066 }
2067 break;
2069 {
2070 int16* ma;
2071 uint64* mb;
2073 ma=(int16*)origdata;
2074 mb=data;
2076 {
2081 break;
2082 *mb++=(uint64)(*ma++);
2083 }
2084 }
2085 break;
2087 {
2088 uint32* ma;
2089 uint64* mb;
2091 ma=(uint32*)origdata;
2092 mb=data;
2094 {
2096 TIFFSwabLong(ma);
2097 *mb++=(uint64)(*ma++);
2098 }
2099 }
2100 break;
2102 {
2103 int32* ma;
2104 uint64* mb;
2106 ma=(int32*)origdata;
2107 mb=data;
2109 {
2114 break;
2115 *mb++=(uint64)(*ma++);
2116 }
2117 }
2118 break;
2119 }
2120 _TIFFfree(origdata);
2122 {
2125 }
2128}
Referenced by TIFFFetchStripThing(), and TIFFReadDirEntryLong8Array().
◆ TIFFReadDirEntryLongArray()
|
static |
Definition at line 1633 of file tif_dirread.c.
1634{
1637 void* origdata;
1640 {
1649 break;
1650 default:
1652 }
1655 {
1656 *value=0;
1658 }
1660 {
1667 {
1672 {
1677 {
1678 _TIFFfree(origdata);
1680 }
1681 m++;
1682 }
1685 }
1686 }
1689 {
1690 _TIFFfree(origdata);
1692 }
1694 {
1696 {
1697 uint8* ma;
1698 uint32* mb;
1700 ma=(uint8*)origdata;
1701 mb=data;
1703 *mb++=(uint32)(*ma++);
1704 }
1705 break;
1707 {
1708 int8* ma;
1709 uint32* mb;
1711 ma=(int8*)origdata;
1712 mb=data;
1714 {
1717 break;
1718 *mb++=(uint32)(*ma++);
1719 }
1720 }
1721 break;
1723 {
1724 uint16* ma;
1725 uint32* mb;
1727 ma=(uint16*)origdata;
1728 mb=data;
1730 {
1732 TIFFSwabShort(ma);
1733 *mb++=(uint32)(*ma++);
1734 }
1735 }
1736 break;
1738 {
1739 int16* ma;
1740 uint32* mb;
1742 ma=(int16*)origdata;
1743 mb=data;
1745 {
1750 break;
1751 *mb++=(uint32)(*ma++);
1752 }
1753 }
1754 break;
1756 {
1757 uint64* ma;
1758 uint32* mb;
1760 ma=(uint64*)origdata;
1761 mb=data;
1763 {
1765 TIFFSwabLong8(ma);
1768 break;
1769 *mb++=(uint32)(*ma++);
1770 }
1771 }
1772 break;
1774 {
1775 int64* ma;
1776 uint32* mb;
1778 ma=(int64*)origdata;
1779 mb=data;
1781 {
1786 break;
1787 *mb++=(uint32)(*ma++);
1788 }
1789 }
1790 break;
1791 }
1792 _TIFFfree(origdata);
1794 {
1797 }
1800}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryOutputErr()
|
static |
Definition at line 3410 of file tif_dirread.c.
3411{
3412 if (!recover) {
3416 "Incorrect count for \"%s\"",
3417 tagname);
3418 break;
3421 "Incompatible type for \"%s\"",
3422 tagname);
3423 break;
3426 "IO error during reading of \"%s\"",
3427 tagname);
3428 break;
3431 "Incorrect value for \"%s\"",
3432 tagname);
3433 break;
3436 "Cannot handle different values per sample for \"%s\"",
3437 tagname);
3438 break;
3441 "Sanity check on size of \"%s\" value failed",
3442 tagname);
3443 break;
3446 "Out of memory reading of \"%s\"",
3447 tagname);
3448 break;
3449 default:
3451 break;
3452 }
3453 } else {
3457 "Incorrect count for \"%s\"; tag ignored",
3458 tagname);
3459 break;
3462 "Incompatible type for \"%s\"; tag ignored",
3463 tagname);
3464 break;
3467 "IO error during reading of \"%s\"; tag ignored",
3468 tagname);
3469 break;
3472 "Incorrect value for \"%s\"; tag ignored",
3473 tagname);
3474 break;
3477 "Cannot handle different values per sample for \"%s\"; tag ignored",
3478 tagname);
3479 break;
3482 "Sanity check on size of \"%s\" value failed; tag ignored",
3483 tagname);
3484 break;
3487 "Out of memory reading of \"%s\"; tag ignored",
3488 tagname);
3489 break;
3490 default:
3492 break;
3493 }
3494 }
3495}
Referenced by TIFFFetchNormalTag(), TIFFFetchStripThing(), TIFFFetchSubjectDistance(), and TIFFReadDirectory().
◆ TIFFReadDirEntryPersampleShort()
|
static |
Definition at line 2828 of file tif_dirread.c.
2829{
2832 uint16* na;
2833 uint16 nb;
2839 na=m;
2841 *value=*na++;
2842 nb--;
2843 while (nb>0)
2844 {
2846 {
2848 break;
2849 }
2850 nb--;
2851 }
2854}
Referenced by TIFFReadDirectory().
◆ TIFFReadDirEntrySbyteArray()
|
static |
Definition at line 1115 of file tif_dirread.c.
1116{
1119 void* origdata;
1122 {
1132 break;
1133 default:
1135 }
1138 {
1139 *value=0;
1141 }
1143 {
1146 {
1151 {
1154 {
1155 _TIFFfree(origdata);
1157 }
1158 m++;
1159 }
1162 }
1166 }
1169 {
1170 _TIFFfree(origdata);
1172 }
1174 {
1176 {
1177 uint16* ma;
1178 int8* mb;
1180 ma=(uint16*)origdata;
1181 mb=data;
1183 {
1185 TIFFSwabShort(ma);
1188 break;
1189 *mb++=(int8)(*ma++);
1190 }
1191 }
1192 break;
1194 {
1195 int16* ma;
1196 int8* mb;
1198 ma=(int16*)origdata;
1199 mb=data;
1201 {
1206 break;
1207 *mb++=(int8)(*ma++);
1208 }
1209 }
1210 break;
1212 {
1213 uint32* ma;
1214 int8* mb;
1216 ma=(uint32*)origdata;
1217 mb=data;
1219 {
1221 TIFFSwabLong(ma);
1224 break;
1225 *mb++=(int8)(*ma++);
1226 }
1227 }
1228 break;
1230 {
1231 int32* ma;
1232 int8* mb;
1234 ma=(int32*)origdata;
1235 mb=data;
1237 {
1242 break;
1243 *mb++=(int8)(*ma++);
1244 }
1245 }
1246 break;
1248 {
1249 uint64* ma;
1250 int8* mb;
1252 ma=(uint64*)origdata;
1253 mb=data;
1255 {
1257 TIFFSwabLong8(ma);
1260 break;
1261 *mb++=(int8)(*ma++);
1262 }
1263 }
1264 break;
1266 {
1267 int64* ma;
1268 int8* mb;
1270 ma=(int64*)origdata;
1271 mb=data;
1273 {
1278 break;
1279 *mb++=(int8)(*ma++);
1280 }
1281 }
1282 break;
1283 }
1284 _TIFFfree(origdata);
1286 {
1289 }
1292}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value)
Definition: tif_dirread.c:3157
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 value)
Definition: tif_dirread.c:3165
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 value)
Definition: tif_dirread.c:3141
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value)
Definition: tif_dirread.c:3125
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value)
Definition: tif_dirread.c:3149
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 value)
Definition: tif_dirread.c:3133
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 value)
Definition: tif_dirread.c:3173
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryShort()
|
static |
Definition at line 292 of file tif_dirread.c.
293{
298 {
300 {
305 }
307 {
315 }
320 {
328 }
330 {
338 }
340 {
348 }
350 {
360 }
362 {
372 }
373 default:
375 }
376}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 value)
Definition: tif_dirread.c:3221
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 value)
Definition: tif_dirread.c:3213
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value)
Definition: tif_dirread.c:3181
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value)
Definition: tif_dirread.c:3197
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 value)
Definition: tif_dirread.c:3189
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value)
Definition: tif_dirread.c:3205
Referenced by TIFFFetchNormalTag(), and TIFFReadDirectory().
◆ TIFFReadDirEntryShortArray()
|
static |
Definition at line 1294 of file tif_dirread.c.
1295{
1298 void* origdata;
1301 {
1310 break;
1311 default:
1313 }
1316 {
1317 *value=0;
1319 }
1321 {
1328 {
1333 {
1338 {
1339 _TIFFfree(origdata);
1341 }
1342 m++;
1343 }
1346 }
1347 }
1350 {
1351 _TIFFfree(origdata);
1353 }
1355 {
1357 {
1358 uint8* ma;
1359 uint16* mb;
1361 ma=(uint8*)origdata;
1362 mb=data;
1364 *mb++=(uint16)(*ma++);
1365 }
1366 break;
1368 {
1369 int8* ma;
1370 uint16* mb;
1372 ma=(int8*)origdata;
1373 mb=data;
1375 {
1378 break;
1379 *mb++=(uint16)(*ma++);
1380 }
1381 }
1382 break;
1384 {
1385 uint32* ma;
1386 uint16* mb;
1388 ma=(uint32*)origdata;
1389 mb=data;
1391 {
1393 TIFFSwabLong(ma);
1396 break;
1397 *mb++=(uint16)(*ma++);
1398 }
1399 }
1400 break;
1402 {
1403 int32* ma;
1404 uint16* mb;
1406 ma=(int32*)origdata;
1407 mb=data;
1409 {
1414 break;
1415 *mb++=(uint16)(*ma++);
1416 }
1417 }
1418 break;
1420 {
1421 uint64* ma;
1422 uint16* mb;
1424 ma=(uint64*)origdata;
1425 mb=data;
1427 {
1429 TIFFSwabLong8(ma);
1432 break;
1433 *mb++=(uint16)(*ma++);
1434 }
1435 }
1436 break;
1438 {
1439 int64* ma;
1440 uint16* mb;
1442 ma=(int64*)origdata;
1443 mb=data;
1445 {
1450 break;
1451 *mb++=(uint16)(*ma++);
1452 }
1453 }
1454 break;
1455 }
1456 _TIFFfree(origdata);
1458 {
1461 }
1464}
void TIFFSwabArrayOfShort(register uint16 *wp, tmsize_t n)
Definition: tif_swab.c:71
Referenced by TIFFFetchNormalTag(), TIFFReadDirectory(), and TIFFReadDirEntryPersampleShort().
◆ TIFFReadDirEntrySlong8Array()
|
static |
Definition at line 2135 of file tif_dirread.c.
2136{
2139 void* origdata;
2142 {
2151 break;
2152 default:
2154 }
2157 {
2158 *value=0;
2160 }
2162 {
2164 {
2169 {
2174 {
2175 _TIFFfree(origdata);
2177 }
2178 m++;
2179 }
2182 }
2188 }
2191 {
2192 _TIFFfree(origdata);
2194 }
2196 {
2198 {
2199 uint8* ma;
2200 int64* mb;
2202 ma=(uint8*)origdata;
2203 mb=data;
2205 *mb++=(int64)(*ma++);
2206 }
2207 break;
2209 {
2210 int8* ma;
2211 int64* mb;
2213 ma=(int8*)origdata;
2214 mb=data;
2216 *mb++=(int64)(*ma++);
2217 }
2218 break;
2220 {
2221 uint16* ma;
2222 int64* mb;
2224 ma=(uint16*)origdata;
2225 mb=data;
2227 {
2229 TIFFSwabShort(ma);
2230 *mb++=(int64)(*ma++);
2231 }
2232 }
2233 break;
2235 {
2236 int16* ma;
2237 int64* mb;
2239 ma=(int16*)origdata;
2240 mb=data;
2242 {
2245 *mb++=(int64)(*ma++);
2246 }
2247 }
2248 break;
2250 {
2251 uint32* ma;
2252 int64* mb;
2254 ma=(uint32*)origdata;
2255 mb=data;
2257 {
2259 TIFFSwabLong(ma);
2260 *mb++=(int64)(*ma++);
2261 }
2262 }
2263 break;
2265 {
2266 int32* ma;
2267 int64* mb;
2269 ma=(int32*)origdata;
2270 mb=data;
2272 {
2275 *mb++=(int64)(*ma++);
2276 }
2277 }
2278 break;
2279 }
2280 _TIFFfree(origdata);
2283}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlong8Long8(uint64 value)
Definition: tif_dirread.c:3377
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySlongArray()
|
static |
Definition at line 1802 of file tif_dirread.c.
1803{
1806 void* origdata;
1809 {
1818 break;
1819 default:
1821 }
1824 {
1825 *value=0;
1827 }
1829 {
1831 {
1836 {
1841 {
1842 _TIFFfree(origdata);
1844 }
1845 m++;
1846 }
1849 }
1855 }
1858 {
1859 _TIFFfree(origdata);
1861 }
1863 {
1865 {
1866 uint8* ma;
1867 int32* mb;
1869 ma=(uint8*)origdata;
1870 mb=data;
1872 *mb++=(int32)(*ma++);
1873 }
1874 break;
1876 {
1877 int8* ma;
1878 int32* mb;
1880 ma=(int8*)origdata;
1881 mb=data;
1883 *mb++=(int32)(*ma++);
1884 }
1885 break;
1887 {
1888 uint16* ma;
1889 int32* mb;
1891 ma=(uint16*)origdata;
1892 mb=data;
1894 {
1896 TIFFSwabShort(ma);
1897 *mb++=(int32)(*ma++);
1898 }
1899 }
1900 break;
1902 {
1903 int16* ma;
1904 int32* mb;
1906 ma=(int16*)origdata;
1907 mb=data;
1909 {
1912 *mb++=(int32)(*ma++);
1913 }
1914 }
1915 break;
1917 {
1918 uint64* ma;
1919 int32* mb;
1921 ma=(uint64*)origdata;
1922 mb=data;
1924 {
1926 TIFFSwabLong8(ma);
1929 break;
1930 *mb++=(int32)(*ma++);
1931 }
1932 }
1933 break;
1935 {
1936 int64* ma;
1937 int32* mb;
1939 ma=(int64*)origdata;
1940 mb=data;
1942 {
1947 break;
1948 *mb++=(int32)(*ma++);
1949 }
1950 }
1951 break;
1952 }
1953 _TIFFfree(origdata);
1955 {
1958 }
1961}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong8(uint64 value)
Definition: tif_dirread.c:3322
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong(uint32 value)
Definition: tif_dirread.c:3312
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongSlong8(int64 value)
Definition: tif_dirread.c:3332
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySshortArray()
|
static |
Definition at line 1466 of file tif_dirread.c.
1467{
1470 void* origdata;
1473 {
1482 break;
1483 default:
1485 }
1488 {
1489 *value=0;
1491 }
1493 {
1495 {
1500 {
1505 {
1506 _TIFFfree(origdata);
1508 }
1509 m++;
1510 }
1513 }
1519 }
1522 {
1523 _TIFFfree(origdata);
1525 }
1527 {
1529 {
1530 uint8* ma;
1531 int16* mb;
1533 ma=(uint8*)origdata;
1534 mb=data;
1536 *mb++=(int16)(*ma++);
1537 }
1538 break;
1540 {
1541 int8* ma;
1542 int16* mb;
1544 ma=(int8*)origdata;
1545 mb=data;
1547 *mb++=(int16)(*ma++);
1548 }
1549 break;
1551 {
1552 uint32* ma;
1553 int16* mb;
1555 ma=(uint32*)origdata;
1556 mb=data;
1558 {
1560 TIFFSwabLong(ma);
1563 break;
1564 *mb++=(int16)(*ma++);
1565 }
1566 }
1567 break;
1569 {
1570 int32* ma;
1571 int16* mb;
1573 ma=(int32*)origdata;
1574 mb=data;
1576 {
1581 break;
1582 *mb++=(int16)(*ma++);
1583 }
1584 }
1585 break;
1587 {
1588 uint64* ma;
1589 int16* mb;
1591 ma=(uint64*)origdata;
1592 mb=data;
1594 {
1596 TIFFSwabLong8(ma);
1599 break;
1600 *mb++=(int16)(*ma++);
1601 }
1602 }
1603 break;
1605 {
1606 int64* ma;
1607 int16* mb;
1609 ma=(int64*)origdata;
1610 mb=data;
1612 {
1617 break;
1618 *mb++=(int16)(*ma++);
1619 }
1620 }
1621 break;
1622 }
1623 _TIFFfree(origdata);
1625 {
1628 }
1631}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 value)
Definition: tif_dirread.c:3245
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 value)
Definition: tif_dirread.c:3261
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 value)
Definition: tif_dirread.c:3237
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 value)
Definition: tif_dirread.c:3253
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 value)
Definition: tif_dirread.c:3229
Referenced by TIFFFetchNormalTag().
◆ TIFFReadEXIFDirectory()
Definition at line 4501 of file tif_dirread.c.
4502{
4506}
Definition: tif_dir.h:275
int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff, const TIFFFieldArray *infoarray)
Definition: tif_dirread.c:4394
◆ TIFFReadUInt64()
◆ TryChopUpUncompressedBigTiff()
Definition at line 5898 of file tif_dirread.c.
5899{
5901 uint32 rowblock;
5902 uint64 rowblockbytes;
5904 uint64 stripsize;
5905 uint32 rowblocksperstrip;
5906 uint32 rowsperstrip;
5907 uint64 stripbytes;
5908 uint32 nstrips;
5909
5910 stripsize = TIFFStripSize64(tif);
5911
5915 assert( stripsize > 0x7FFFFFFFUL );
5916
5917 /* On a newly created file, just re-opened to be filled, we */
5918 /* don't want strip chop to trigger as it is going to cause issues */
5919 /* later ( StripOffsets and StripByteCounts improperly filled) . */
5921 return;
5922
5924 (!isUpSampled(tif)))
5925 rowblock = td->td_ycbcrsubsampling[1];
5926 else
5927 rowblock = 1;
5928 rowblockbytes = TIFFVStripSize64(tif, rowblock);
5929 if( rowblockbytes == 0 || rowblockbytes > 0x7FFFFFFFUL )
5930 {
5931 /* In case of file with gigantic width */
5932 return;
5933 }
5934
5935 /* Check that the strips are contiguous and of the expected size */
5937 {
5939 {
5942 {
5943 return;
5944 }
5945 }
5946 else
5947 {
5949 {
5950 return;
5951 }
5954 {
5955 return;
5956 }
5957 }
5958 }
5959
5960 /* Aim for 512 MB strips (that will still be manageable by 32 bit builds */
5961 rowblocksperstrip = (uint32) (512 * 1024 * 1024 / rowblockbytes);
5962 if( rowblocksperstrip == 0 )
5963 rowblocksperstrip = 1;
5964 rowsperstrip = rowblocksperstrip * rowblock;
5965 stripbytes = rowblocksperstrip * rowblockbytes;
5966 assert( stripbytes <= 0x7FFFFFFFUL );
5967
5969 if( nstrips == 0 )
5970 return;
5971
5972 /* If we are going to allocate a lot of memory, make sure that the */
5973 /* file is as big as needed */
5975 nstrips > 1000000 )
5976 {
5980 if( last_offset > filesize ||
5981 last_bytecount > filesize - last_offset )
5982 {
5983 return;
5984 }
5985 }
5986
5987 allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
5988}
Referenced by TIFFReadDirectory().
