tif_dirread.c File Reference
#include "tiffconf.h"#include "tiffiop.h"#include <float.h>#include <limits.h>#include <stdlib.h>#include <string.h>
Include dependency graph for tif_dirread.c:
Go to the source code of this file.
Classes | |
| union | _UInt64Aligned_t |
Macros | |
| #define | FAILED_FII ((uint32_t)-1) |
| #define | INITIAL_THRESHOLD (1024 * 1024) |
| #define | THRESHOLD_MULTIPLIER 10 |
| #define | MAX_THRESHOLD |
| #define | MAX_SIZE_TAG_DATA 2147483647U |
| #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 44 of file tif_dirread.c.
◆ INITIAL_THRESHOLD
| #define INITIAL_THRESHOLD (1024 * 1024) |
Definition at line 1185 of file tif_dirread.c.
◆ IO_CACHE_PAGE_SIZE
| #define IO_CACHE_PAGE_SIZE 4096 |
◆ MAX_SIZE_TAG_DATA
Definition at line 1251 of file tif_dirread.c.
◆ MAX_THRESHOLD
| #define MAX_THRESHOLD |
Value:
Definition at line 1187 of file tif_dirread.c.
◆ THRESHOLD_MULTIPLIER
| #define THRESHOLD_MULTIPLIER 10 |
Definition at line 1186 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 57 of file tif_dirread.c.
58{
59 TIFFReadDirEntryErrOk = 0,
60 TIFFReadDirEntryErrCount = 1,
61 TIFFReadDirEntryErrType = 2,
62 TIFFReadDirEntryErrIo = 3,
63 TIFFReadDirEntryErrRange = 4,
64 TIFFReadDirEntryErrPsdif = 5,
65 TIFFReadDirEntryErrSizesan = 6,
66 TIFFReadDirEntryErrAlloc = 7,
67};
Function Documentation
◆ _TIFFCheckDirNumberAndOffset()
Definition at line 5665 of file tif_dirread.c.
5666{
5667 if (diroff == 0) /* no more directories */
5668 return 0;
5669
5671 {
5675 {
5677 "Not enough memory");
5678 return 1;
5679 }
5680 }
5681
5683 {
5684 /* No free callback for this map, as it shares the same items as
5685 * tif->tif_map_dir_offset_to_number. */
5689 {
5691 "Not enough memory");
5692 return 1;
5693 }
5694 }
5695
5696 /* Check if offset is already in the list:
5697 * - yes: check, if offset is at the same IFD number - if not, it is an IFD
5698 * loop
5699 * - no: add to list or update offset at that IFD number
5700 */
5702 entry.offset = diroff;
5703 entry.dirNumber = dirn;
5704
5705 TIFFOffsetAndDirNumber *foundEntry =
5708 if (foundEntry)
5709 {
5711 {
5712 return 1;
5713 }
5714 else
5715 {
5717 "TIFF directory %d has IFD looping to directory %u "
5720 diroff);
5721 return 0;
5722 }
5723 }
5724
5725 /* Check if offset of an IFD has been changed and update offset of that IFD
5726 * number. */
5729 if (foundEntry)
5730 {
5732 {
5733 TIFFOffsetAndDirNumber entryOld;
5735 entryOld.dirNumber = dirn;
5736 /* We must remove first from tif_map_dir_number_to_offset as the */
5737 /* entry is owned (and thus freed) by */
5738 /* tif_map_dir_offset_to_number */
5739 TIFFOffsetAndDirNumber *foundEntryOld =
5741 tif->tif_map_dir_number_to_offset, &entryOld);
5742 if (foundEntryOld)
5743 {
5745 foundEntryOld);
5746 }
5748 tif->tif_map_dir_offset_to_number, &entryOld);
5749 if (foundEntryOld)
5750 {
5752 foundEntryOld);
5753 }
5754
5758 {
5759 return 0;
5760 }
5761
5762 /* Add IFD offset and dirn to IFD directory list */
5763 *entryPtr = entry;
5764
5766 {
5767 TIFFErrorExtR(
5768 tif, "_TIFFCheckDirNumberAndOffset",
5769 "Insertion in tif_map_dir_offset_to_number failed");
5770 return 0;
5771 }
5773 {
5774 TIFFErrorExtR(
5775 tif, "_TIFFCheckDirNumberAndOffset",
5776 "Insertion in tif_map_dir_number_to_offset failed");
5777 return 0;
5778 }
5779 }
5780 return 1;
5781 }
5782
5783 /* Arbitrary (hopefully big enough) limit */
5785 TIFF_MAX_DIR_COUNT)
5786 {
5788 "Cannot handle more than %u TIFF directories",
5789 TIFF_MAX_DIR_COUNT);
5790 return 0;
5791 }
5792
5793 TIFFOffsetAndDirNumber *entryPtr =
5796 {
5798 "malloc(sizeof(TIFFOffsetAndDirNumber)) failed");
5799 return 0;
5800 }
5801
5802 /* Add IFD offset and dirn to IFD directory list */
5803 *entryPtr = entry;
5804
5806 {
5808 "Insertion in tif_map_dir_offset_to_number failed");
5809 return 0;
5810 }
5812 {
5814 "Insertion in tif_map_dir_number_to_offset failed");
5815 return 0;
5816 }
5817
5818 return 1;
5819} /* --- _TIFFCheckDirNumberAndOffset() ---*/
Definition: tiffiop.h:99
TIFFHashSet * tif_map_dir_number_to_offset
Definition: tiffiop.h:154
TIFFHashSet * tif_map_dir_offset_to_number
Definition: tiffiop.h:153
static bool equalFuncNumberToOffset(const void *elt1, const void *elt2)
Definition: tif_dirread.c:5646
static unsigned long hashFuncOffsetToNumber(const void *elt)
Definition: tif_dirread.c:5621
static bool equalFuncOffsetToNumber(const void *elt1, const void *elt2)
Definition: tif_dirread.c:5630
static unsigned long hashFuncNumberToOffset(const void *elt)
Definition: tif_dirread.c:5639
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_error.c:107
void * TIFFHashSetLookup(TIFFHashSet *set, const void *elt)
Definition: tif_hash_set.c:502
bool TIFFHashSetRemove(TIFFHashSet *set, const void *elt)
Definition: tif_hash_set.c:577
TIFFHashSet * TIFFHashSetNew(TIFFHashSetHashFunc fnHashFunc, TIFFHashSetEqualFunc fnEqualFunc, TIFFHashSetFreeEltFunc fnFreeEltFunc)
Definition: tif_hash_set.c:138
void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_warning.c:80
Referenced by TIFFAdvanceDirectory(), TIFFReadDirectory(), TIFFSetSubDirectory(), and TIFFWriteDirectorySec().
◆ _TIFFFetchStrileValue()
|
static |
Definition at line 8200 of file tif_dirread.c.
8202{
8206 {
8207 return 0;
8208 }
8210 {
8212 uint32_t nStripArrayAllocNew;
8213 uint64_t nArraySize64;
8214 size_t nArraySize;
8215 uint64_t *offsetArray;
8216 uint64_t *bytecountArray;
8217
8218 if (strile > 1000000)
8219 {
8221 /* Avoid excessive memory allocation attempt */
8222 /* For such a big blockid we need at least a TIFF_LONG per strile */
8223 /* for the offset array. */
8225 {
8227 return 0;
8228 }
8229 }
8230
8232 td->td_nstrips < 1024 * 1024)
8233 {
8234 nStripArrayAllocNew = td->td_nstrips;
8235 }
8236 else
8237 {
8238#define TIFF_MAX(a, b) (((a) > (b)) ? (a) : (b))
8239#define TIFF_MIN(a, b) (((a) < (b)) ? (a) : (b))
8240 nStripArrayAllocNew = TIFF_MAX(strile + 1, 1024U * 512U);
8241 if (nStripArrayAllocNew < 0xFFFFFFFFU / 2)
8242 nStripArrayAllocNew *= 2;
8244 }
8245 assert(strile < nStripArrayAllocNew);
8247 nArraySize = (size_t)(nArraySize64);
8248#if SIZEOF_SIZE_T == 4
8249 if (nArraySize != nArraySize64)
8250 {
8252 "Cannot allocate strip offset and bytecount arrays");
8253 return 0;
8254 }
8255#endif
8257 nArraySize));
8259 tif, td->td_stripbytecount_p, nArraySize));
8260 if (offsetArray)
8261 td->td_stripoffset_p = offsetArray;
8262 if (bytecountArray)
8263 td->td_stripbytecount_p = bytecountArray;
8264 if (offsetArray && bytecountArray)
8265 {
8266 td->td_stripoffsetbyteallocsize = nStripArrayAllocNew;
8267 /* Initialize new entries to ~0 / -1 */
8268 /* coverity[overrun-buffer-arg] */
8270 (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) *
8272 /* coverity[overrun-buffer-arg] */
8274 (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) *
8276 }
8277 else
8278 {
8280 "Cannot allocate strip offset and bytecount arrays");
8285 td->td_stripoffsetbyteallocsize = 0;
8286 }
8287 }
8289 return 0;
8290
8291 if (~((*parray)[strile]) == 0)
8292 {
8294 {
8295 (*parray)[strile] = 0;
8296 return 0;
8297 }
8298 }
8299
8300 return 1;
8301}
Definition: tif_dir.h:78
uint32_t td_stripoffsetbyteallocsize
Definition: tif_dir.h:117
Definition: dirent.h:25
Definition: dbghelp_private.h:377
static int _TIFFPartialReadStripArray(TIFF *tif, TIFFDirEntry *dirent, int strile, uint64_t *panVals)
Definition: tif_dirread.c:8042
#define TIFF_MIN(a, b)
#define TIFF_MAX(a, b)
Referenced by _TIFFGetStrileOffsetOrByteCountValue().
◆ _TIFFFillStriles()
Definition at line 8381 of file tif_dirread.c.
static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
Definition: tif_dirread.c:8383
Referenced by _TIFFGetStrileOffsetOrByteCountValue(), _TIFFVGetField(), TIFFReadDirectory(), TIFFWriteCheck(), and TIFFWriteDirectorySec().
◆ _TIFFFillStrilesInternal()
Definition at line 8383 of file tif_dirread.c.
8384{
8386 int return_value = 1;
8387
8388 /* Do not do anything if TIFF_DEFERSTRILELOAD is not set */
8391 return 1;
8392
8394 {
8395 /* In case of lazy loading, reload completely the arrays */
8400 td->td_stripoffsetbyteallocsize = 0;
8401 tif->tif_flags &= ~TIFF_LAZYSTRILELOAD;
8402 }
8403
8404 /* If stripoffset array is already loaded, exit with success */
8406 return 1;
8407
8408 /* If tdir_count was canceled, then we already got there, but in error */
8410 return 0;
8411
8413 &td->td_stripoffset_p))
8414 {
8415 return_value = 0;
8416 }
8417
8418 if (loadStripByteCount &&
8421 {
8422 return_value = 0;
8423 }
8424
8427
8428#ifdef STRIPBYTECOUNTSORTED_UNUSED
8430 {
8431 uint32_t strip;
8432
8433 tif->tif_dir.td_stripbytecountsorted = 1;
8435 {
8438 {
8439 tif->tif_dir.td_stripbytecountsorted = 0;
8440 break;
8441 }
8442 }
8443 }
8444#endif
8445
8446 return return_value;
8447}
Definition: tif_dir.h:54
static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32_t nstrips, uint64_t **lpp)
Definition: tif_dirread.c:7643
Referenced by _TIFFFillStriles(), and EstimateStripByteCounts().
◆ _TIFFGetDirNumberFromOffset()
Definition at line 5828 of file tif_dirread.c.
5829{
5830 if (diroff == 0) /* no more directories */
5831 return 0;
5832
5833 /* Check if offset is already in the list and return matching directory
5834 * number. Otherwise update IFD list using TIFFNumberOfDirectories() and
5835 * search again in IFD list.
5836 */
5838 return 0;
5840 entry.offset = diroff;
5842
5843 TIFFOffsetAndDirNumber *foundEntry =
5846 if (foundEntry)
5847 {
5848 *dirn = foundEntry->dirNumber;
5849 return 1;
5850 }
5851
5852 /* This updates the directory list for all main-IFDs in the file. */
5853 TIFFNumberOfDirectories(tif);
5854
5857 if (foundEntry)
5858 {
5859 *dirn = foundEntry->dirNumber;
5860 return 1;
5861 }
5862
5863 return 0;
5864} /*--- _TIFFGetDirNumberFromOffset() ---*/
Referenced by TIFFLinkDirectory(), and TIFFSetSubDirectory().
◆ _TIFFGetMaxColorChannels()
Definition at line 4016 of file tif_dirread.c.
4017{
4018 switch (photometric)
4019 {
4023 return 1;
4030 return 3;
4033 return 4;
4036 default:
4037 return 0;
4038 }
4039}
Referenced by TIFFReadDirectory().
◆ _TIFFGetOffsetFromDirNumber()
Definition at line 5873 of file tif_dirread.c.
5874{
5875
5877 return 0;
5880 entry.dirNumber = dirn;
5881
5882 TIFFOffsetAndDirNumber *foundEntry =
5885 if (foundEntry)
5886 {
5887 *diroff = foundEntry->offset;
5888 return 1;
5889 }
5890
5891 return 0;
5892} /*--- _TIFFGetOffsetFromDirNumber() ---*/
Referenced by TIFFSetDirectory().
◆ _TIFFGetStrileOffsetOrByteCountValue()
|
static |
Definition at line 8303 of file tif_dirread.c.
8307{
8309 if (pbErr)
8310 *pbErr = 0;
8313 {
8315 /* If the values may fit in the toff_long/toff_long8 member */
8316 /* then use _TIFFFillStriles to simplify _TIFFFetchStrileValue */
8317 dirent->tdir_count <= 4)
8318 {
8320 {
8321 if (pbErr)
8322 *pbErr = 1;
8323 /* Do not return, as we want this function to always */
8324 /* return the same value if called several times with */
8325 /* the same arguments */
8326 }
8327 }
8328 else
8329 {
8331 {
8332 if (pbErr)
8333 *pbErr = 1;
8334 return 0;
8335 }
8336 }
8337 }
8339 {
8340 if (pbErr)
8341 *pbErr = 1;
8342 return 0;
8343 }
8344 return (*parray)[strile];
8345}
static int _TIFFFetchStrileValue(TIFF *tif, uint32_t strile, TIFFDirEntry *dirent, uint64_t **parray)
Definition: tif_dirread.c:8200
Referenced by TIFFGetStrileByteCountWithErr(), and TIFFGetStrileOffsetWithErr().
◆ _TIFFPartialReadStripArray()
|
static |
Definition at line 8042 of file tif_dirread.c.
8044{
8046#define IO_CACHE_PAGE_SIZE 4096
8047
8048 size_t sizeofval;
8050 int sizeofvalint;
8051 uint64_t nBaseOffset;
8052 uint64_t nOffset;
8053 uint64_t nOffsetStartPage;
8054 uint64_t nOffsetEndPage;
8055 tmsize_t nToRead;
8056 tmsize_t nRead;
8057 uint64_t nLastStripOffset;
8058 int iStartBefore;
8062
8064
8066 {
8068 }
8070 {
8072 }
8074 {
8076 }
8078 {
8079 /* Non conformant but used by some images as in */
8080 /* https://github.com/OSGeo/gdal/issues/2165 */
8082 }
8083 else
8084 {
8086 "Invalid type for [Strip|Tile][Offset/ByteCount] tag");
8087 panVals[strile] = 0;
8088 return 0;
8089 }
8090 sizeofvalint = (int)(sizeofval);
8091
8093 {
8095 if (bSwab)
8097 nBaseOffset = offset;
8098 }
8099 else
8100 {
8102 if (bSwab)
8104 nBaseOffset = offset;
8105 }
8106 /* To avoid later unsigned integer overflows */
8108 {
8110 strile);
8111 panVals[strile] = 0;
8112 return 0;
8113 }
8114 nOffset = nBaseOffset + sizeofval * strile;
8116 nOffsetEndPage = nOffsetStartPage + IO_CACHE_PAGE_SIZE;
8117
8118 if (nOffset + sizeofval > nOffsetEndPage)
8119 nOffsetEndPage += IO_CACHE_PAGE_SIZE;
8120#undef IO_CACHE_PAGE_SIZE
8121
8122 nLastStripOffset = nBaseOffset + arraySize * sizeofval;
8123 if (nLastStripOffset < nOffsetEndPage)
8124 nOffsetEndPage = nLastStripOffset;
8125 if (nOffsetStartPage >= nOffsetEndPage)
8126 {
8128 strile);
8129 panVals[strile] = 0;
8130 return 0;
8131 }
8133 {
8134 panVals[strile] = 0;
8135 return 0;
8136 }
8137
8138 nToRead = (tmsize_t)(nOffsetEndPage - nOffsetStartPage);
8140 if (nRead < nToRead)
8141 {
8143 "Cannot read offset/size for strile around ~%d", strile);
8144 return 0;
8145 }
8146 iStartBefore = -(int)((nOffset - nOffsetStartPage) / sizeofval);
8147 if (strile + iStartBefore < 0)
8148 iStartBefore = -strile;
8152 nOffsetEndPage;
8153 ++i)
8154 {
8156 {
8161 if (bSwab)
8164 }
8166 {
8171 if (bSwab)
8174 }
8176 {
8181 if (bSwab)
8184 }
8185 else /* if( dirent->tdir_type == TIFF_SLONG8 ) */
8186 {
8187 /* Non conformant data type */
8192 if (bSwab)
8195 }
8196 }
8197 return 1;
8198}
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_t _TIFFUnsanitizedAddUInt64AndInt(uint64_t a, int b)
Definition: tif_dirread.c:8033
Referenced by _TIFFFetchStrileValue().
◆ _TIFFRemoveEntryFromDirectoryListByOffset()
Definition at line 5900 of file tif_dirread.c.
5901{
5903 return 1;
5904
5905 TIFFOffsetAndDirNumber entryOld;
5906 entryOld.offset = diroff;
5907 entryOld.dirNumber = 0;
5908 /* We must remove first from tif_map_dir_number_to_offset as the
5909 * entry is owned (and thus freed) by tif_map_dir_offset_to_number.
5910 * However, we need firstly to find the directory number from offset. */
5911
5912 TIFFOffsetAndDirNumber *foundEntryOldOff =
5914 tif->tif_map_dir_offset_to_number, &entryOld);
5915 if (foundEntryOldOff)
5916 {
5919 {
5920 TIFFOffsetAndDirNumber *foundEntryOldDir =
5922 tif->tif_map_dir_number_to_offset, &entryOld);
5923 if (foundEntryOldDir)
5924 {
5926 foundEntryOldDir);
5928 foundEntryOldOff);
5929 return 1;
5930 }
5931 }
5932 else
5933 {
5935 "Unexpectedly tif_map_dir_number_to_offset is "
5936 "missing but tif_map_dir_offset_to_number exists.");
5937 return 0;
5938 }
5939 }
5940 return 1;
5941} /*--- _TIFFRemoveEntryFromDirectoryListByOffset() ---*/
Referenced by TIFFRewriteDirectorySec().
◆ _TIFFUnsanitizedAddUInt64AndInt()
|
static |
Definition at line 8033 of file tif_dirread.c.
8034{
8036}
Referenced by _TIFFPartialReadStripArray().
◆ allocChoppedUpStripArrays()
|
static |
Definition at line 7770 of file tif_dirread.c.
7773{
7775 uint64_t bytecount;
7777 uint64_t last_offset;
7778 uint64_t last_bytecount;
7780 uint64_t *newcounts;
7781 uint64_t *newoffsets;
7782
7787 last_offset + last_bytecount < offset)
7788 {
7789 return;
7790 }
7791 bytecount = last_offset + last_bytecount - offset;
7792
7793 /* Before allocating a huge amount of memory for corrupted files, check if
7794 * size of StripByteCount and StripOffset tags is not greater than
7795 * file size.
7796 */
7798 if (allocsize > 100 * 1024 * 1024)
7799 {
7801 if (allocsize > filesize)
7802 {
7804 "Requested memory size for StripByteCount and "
7807 ". Memory not allocated",
7808 allocsize, filesize);
7809 return;
7810 }
7811 }
7812
7813 newcounts =
7815 "for chopped \"StripByteCounts\" array");
7819 {
7820 /*
7821 * Unable to allocate new strip information, give up and use
7822 * the original one strip information.
7823 */
7825 _TIFFfreeExt(tif, newcounts);
7827 _TIFFfreeExt(tif, newoffsets);
7828 return;
7829 }
7830
7831 /*
7832 * Fill the strip information arrays with new bytecounts and offsets
7833 * that reflect the broken-up format.
7834 */
7836 {
7837 if (stripbytes > bytecount)
7838 stripbytes = bytecount;
7839 newcounts[i] = stripbytes;
7841 offset += stripbytes;
7842 bytecount -= stripbytes;
7843 }
7844
7845 /*
7846 * Replace old single strip info with multi-strip info.
7847 */
7850
7853 td->td_stripbytecount_p = newcounts;
7854 td->td_stripoffset_p = newoffsets;
7855#ifdef STRIPBYTECOUNTSORTED_UNUSED
7856 td->td_stripbytecountsorted = 1;
7857#endif
7859}
void * _TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:122
uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile)
Definition: tif_dirread.c:8349
uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile)
Definition: tif_dirread.c:8366
Referenced by ChopUpSingleUncompressedStrip(), and TryChopUpUncompressedBigTiff().
◆ ByteCountLooksBad()
Definition at line 4041 of file tif_dirread.c.
4042{
4043 /*
4044 * Assume we have wrong StripByteCount value (in case
4045 * of single strip) in following cases:
4046 * - it is equal to zero along with StripOffset;
4047 * - it is larger than file itself (in case of uncompressed
4048 * image);
4049 * - it is smaller than the size of the bytes per row
4050 * multiplied on the number of rows. The last case should
4051 * not be checked in the case of writing new image,
4052 * because we may do not know the exact strip size
4053 * until the whole image will be written and directory
4054 * dumped out.
4055 */
4058 uint64_t filesize;
4059
4061 return 0;
4062 if (bytecount == 0)
4063 return 1;
4065 return 0;
4066 filesize = TIFFGetFileSize(tif);
4068 return 1;
4070 {
4074 {
4075 return 1;
4076 }
4077 if (bytecount < scanlinesize * tif->tif_dir.td_imagelength)
4078 return 1;
4079 }
4080 return 0;
4081}
Referenced by TIFFReadDirectory().
◆ CalcFinalIFDdatasizeReading()
Definition at line 4160 of file tif_dirread.c.
4161{
4162 /* IFD data size is only needed if file-writing is enabled.
4163 * This also avoids the seek() to EOF to determine the file size, which
4164 * causes the stdin-streaming-friendly mode of libtiff for GDAL to fail. */
4166 return;
4167
4168 /* Sort TIFFEntryOffsetAndLength array in ascending order. */
4172
4173 /* Get offset of end of IFD entry space. */
4174 uint64_t IFDendoffset;
4176 IFDendoffset = tif->tif_diroff + 2 + dircount * 12 + 4;
4177 else
4178 IFDendoffset = tif->tif_diroff + 8 + dircount * 20 + 8;
4179
4180 /* Check which offsets are right behind IFD entries. However, LibTIFF
4181 * increments the writing address for every external data to an even offset.
4182 * Thus gaps of 1 byte can occur. */
4187 {
4190 {
4193 }
4195 {
4196 /* Add gap byte after previous IFD data set. */
4199 }
4200 else
4201 {
4202 /* Further data is no more continuously after IFD */
4203 break;
4204 }
4205 }
4206 /* Check for gap byte of some easy cases. This should cover 90% of cases.
4207 * Otherwise, IFD will be re-written even it might be safely overwritten. */
4209 {
4211 size++;
4212 }
4213 else
4214 {
4215 /* Check for IFD data ends at EOF. Then IFD can always be safely
4216 * overwritten. */
4219 {
4221 return;
4222 }
4223 }
4224
4225 /* Finally, add the size of the IFD tag entries themselves. */
4228 else
4230} /*-- CalcFinalIFDdatasizeReading() --*/
_ACRTIMP void __cdecl qsort(void *, size_t, size_t, int(__cdecl *)(const void *, const void *))
TIFFEntryOffsetAndLength * td_dirdatasize_offsets
Definition: tif_dir.h:162
Definition: tif_dir.h:69
static int cmpTIFFEntryOffsetAndLength(const void *a, const void *b)
Definition: tif_dirread.c:4140
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ CheckDirCount()
|
static |
Definition at line 5947 of file tif_dirread.c.
5948{
5950 {
5957 return (0);
5958 }
5960 {
5968 return (1);
5969 }
5970 return (1);
5971}
Definition: tif_dir.h:331
const TIFFField * TIFFFieldWithTag(TIFF *tif, uint32_t tag)
Definition: tif_dirinfo.c:845
Referenced by TIFFReadCustomDirectory().
◆ ChopUpSingleUncompressedStrip()
Definition at line 7867 of file tif_dirread.c.
7868{
7870 uint64_t bytecount;
7872 uint32_t rowblock;
7873 uint64_t rowblockbytes;
7874 uint64_t stripbytes;
7875 uint32_t nstrips;
7876 uint32_t rowsperstrip;
7877
7878 bytecount = TIFFGetStrileByteCount(tif, 0);
7879 /* On a newly created file, just re-opened to be filled, we */
7880 /* don't want strip chop to trigger as it is going to cause issues */
7881 /* later ( StripOffsets and StripByteCounts improperly filled) . */
7883 return;
7887 rowblock = td->td_ycbcrsubsampling[1];
7888 else
7889 rowblock = 1;
7890 rowblockbytes = TIFFVTileSize64(tif, rowblock);
7891 /*
7892 * Make the rows hold at least one scanline, but fill specified amount
7893 * of data if possible.
7894 */
7896 {
7897 stripbytes = rowblockbytes;
7898 rowsperstrip = rowblock;
7899 }
7900 else if (rowblockbytes > 0)
7901 {
7902 uint32_t rowblocksperstrip;
7904 rowsperstrip = rowblocksperstrip * rowblock;
7905 stripbytes = rowblocksperstrip * rowblockbytes;
7906 }
7907 else
7908 return;
7909
7910 /*
7911 * never increase the number of rows per strip
7912 */
7914 return;
7916 if (nstrips == 0)
7917 return;
7918
7919 /* If we are going to allocate a lot of memory, make sure that the */
7920 /* file is as big as needed */
7924 {
7925 return;
7926 }
7927
7928 allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
7929}
static void allocChoppedUpStripArrays(TIFF *tif, uint32_t nstrips, uint64_t stripbytes, uint32_t rowsperstrip)
Definition: tif_dirread.c:7770
Referenced by TIFFReadDirectory().
◆ cmpTIFFEntryOffsetAndLength()
Definition at line 4140 of file tif_dirread.c.
4141{
4144 /* Compare offsets */
4146 return 1;
4148 return -1;
4149 else
4150 return 0;
4151}
Referenced by CalcFinalIFDdatasizeReading().
◆ equalFuncNumberToOffset()
Definition at line 5646 of file tif_dirread.c.
5647{
5653}
Referenced by _TIFFCheckDirNumberAndOffset().
◆ equalFuncOffsetToNumber()
Definition at line 5630 of file tif_dirread.c.
5631{
5637}
Referenced by _TIFFCheckDirNumberAndOffset().
◆ EstimateStripByteCounts()
|
static |
Definition at line 5475 of file tif_dirread.c.
5477{
5479
5480 TIFFDirEntry *dp;
5482 uint32_t strip;
5483
5484 /* Do not try to load stripbytecount as we will compute it */
5486 return -1;
5487
5489 uint64_t filesize = 0;
5490 if (allocsize > 100 * 1024 * 1024)
5491 {
5492 /* Before allocating a huge amount of memory for corrupted files, check
5493 * if size of requested memory is not greater than file size. */
5494 filesize = TIFFGetFileSize(tif);
5495 if (allocsize > filesize)
5496 {
5497 TIFFWarningExtR(
5498 tif, module,
5501 allocsize, filesize);
5502 return -1;
5503 }
5504 }
5505
5511 return -1;
5512
5514 {
5519 else
5521 /* calculate amount of space used by indirect values */
5523 {
5524 uint32_t typewidth;
5527 if (typewidth == 0)
5528 {
5529 TIFFErrorExtR(
5530 tif, module,
5532 dp->tdir_type);
5533 return -1;
5534 }
5536 return -1;
5539 {
5541 datasize = 0;
5542 }
5543 else
5544 {
5546 datasize = 0;
5547 }
5549 return -1;
5551 }
5552 if (filesize == 0)
5553 filesize = TIFFGetFileSize(tif);
5555 /* we should perhaps return in error ? */
5556 space = filesize;
5557 else
5563 /*
5564 * This gross hack handles the case were the offset to
5565 * the last strip is past the place where we think the strip
5566 * should begin. Since a strip of data must be contiguous,
5567 * it's safe to assume that we've overestimated the amount
5568 * of data in the strip and trim this number back accordingly.
5569 */
5570 strip--;
5573 return -1;
5575 filesize)
5576 {
5578 {
5579 /* Not sure what we should in that case... */
5580 td->td_stripbytecount_p[strip] = 0;
5581 }
5582 else
5583 {
5584 td->td_stripbytecount_p[strip] =
5585 filesize - td->td_stripoffset_p[strip];
5586 }
5587 }
5588 }
5590 {
5592
5594 td->td_stripbytecount_p[strip] = bytespertile;
5595 }
5596 else
5597 {
5601 {
5603 return -1;
5604 td->td_stripbytecount_p[strip] = rowbytes * rowsperstrip;
5605 }
5606 }
5610 return 1;
5611}
Definition: tiff.h:117
Definition: tiff.h:111
Definition: btrfs_drv.h:517
Referenced by TIFFReadDirectory().
◆ EvaluateIFDdatasizeReading()
|
static |
Definition at line 4087 of file tif_dirread.c.
4088{
4091 {
4093 "Too large IFD data size");
4094 return false;
4095 }
4098 {
4100 {
4102 "Too large IFD data size");
4103 return false;
4104 }
4107 {
4108 /* The offset of TIFFDirEntry are not swapped when read in. That has
4109 * to be done when used. */
4113 tif->tif_dir
4116 }
4117 else
4118 {
4119 tif->tif_dir
4123 TIFFSwabLong8(
4124 &tif->tif_dir
4126 .td_dirdatasize_Noffsets]
4127 .offset);
4128 }
4129 tif->tif_dir
4131 .length = datalength;
4133 }
4134 return true;
4135}
union TIFFDirEntry::@3701 tdir_offset
Referenced by TIFFFetchNormalTag(), and TIFFReadDirectory().
◆ hashFuncNumberToOffset()
Definition at line 5639 of file tif_dirread.c.
5640{
5644}
Referenced by _TIFFCheckDirNumberAndOffset().
◆ hashFuncOffsetToNumber()
Definition at line 5621 of file tif_dirread.c.
Referenced by _TIFFCheckDirNumberAndOffset().
◆ MissingRequired()
Definition at line 5613 of file tif_dirread.c.
Referenced by TIFFReadDirectory().
◆ TIFFCvtIEEEDoubleToNative()
Referenced by TIFFReadDirEntryDoubleArray(), and TIFFReadDirEntryFloatArray().
◆ TIFFCvtIEEEFloatToNative()
Referenced by TIFFReadDirEntryDoubleArray(), and TIFFReadDirEntryFloatArray().
◆ TIFFFetchDirectory()
|
static |
Definition at line 5978 of file tif_dirread.c.
5980{
5982
5983 void *origdir;
5984 uint16_t dircount16;
5985 uint32_t dirsize;
5987 uint8_t *ma;
5988 TIFFDirEntry *mb;
5990
5991 assert(pdir);
5992
5993 tif->tif_diroff = diroff;
5994 if (nextdiroff)
5995 *nextdiroff = 0;
5997 {
5999 {
6001 "%s: Seek error accessing TIFF directory",
6002 tif->tif_name);
6003 return 0;
6004 }
6006 {
6008 {
6010 "%s: Can not read TIFF directory count",
6011 tif->tif_name);
6012 return 0;
6013 }
6015 TIFFSwabShort(&dircount16);
6016 if (dircount16 > 4096)
6017 {
6019 "Sanity check on directory count failed, this is "
6020 "probably not a valid IFD offset");
6021 return 0;
6022 }
6023 dirsize = 12;
6024 }
6025 else
6026 {
6027 uint64_t dircount64;
6029 {
6031 "%s: Can not read TIFF directory count",
6032 tif->tif_name);
6033 return 0;
6034 }
6036 TIFFSwabLong8(&dircount64);
6037 if (dircount64 > 4096)
6038 {
6040 "Sanity check on directory count failed, this is "
6041 "probably not a valid IFD offset");
6042 return 0;
6043 }
6044 dircount16 = (uint16_t)dircount64;
6045 dirsize = 20;
6046 }
6047 origdir = _TIFFCheckMalloc(tif, dircount16, dirsize,
6048 "to read TIFF directory");
6050 return 0;
6052 {
6054 tif->tif_name);
6055 _TIFFfreeExt(tif, origdir);
6056 return 0;
6057 }
6058 /*
6059 * Read offset to next directory for sequential scans if
6060 * needed.
6061 */
6062 if (nextdiroff)
6063 {
6065 {
6066 uint32_t nextdiroff32;
6068 nextdiroff32 = 0;
6070 TIFFSwabLong(&nextdiroff32);
6071 *nextdiroff = nextdiroff32;
6072 }
6073 else
6074 {
6076 *nextdiroff = 0;
6078 TIFFSwabLong8(nextdiroff);
6079 }
6080 }
6081 }
6082 else
6083 {
6085 tmsize_t off;
6087 {
6089 return (0);
6090 }
6092
6093 /*
6094 * Check for integer overflow when validating the dir_off,
6095 * otherwise a very high offset may cause an OOB read and
6096 * crash the client. Make two comparisons instead of
6097 *
6098 * off + sizeof(uint16_t) > tif->tif_size
6099 *
6100 * to avoid overflow.
6101 */
6103 {
6107 {
6109 return 0;
6110 }
6111 else
6112 {
6114 }
6117 TIFFSwabShort(&dircount16);
6118 if (dircount16 > 4096)
6119 {
6121 "Sanity check on directory count failed, this is "
6122 "probably not a valid IFD offset");
6123 return 0;
6124 }
6125 dirsize = 12;
6126 }
6127 else
6128 {
6129 uint64_t dircount64;
6133 {
6135 return 0;
6136 }
6137 else
6138 {
6140 }
6143 TIFFSwabLong8(&dircount64);
6144 if (dircount64 > 4096)
6145 {
6147 "Sanity check on directory count failed, this is "
6148 "probably not a valid IFD offset");
6149 return 0;
6150 }
6151 dircount16 = (uint16_t)dircount64;
6152 dirsize = 20;
6153 }
6154 if (dircount16 == 0)
6155 {
6157 "Sanity check on directory count failed, zero tag "
6158 "directories not supported");
6159 return 0;
6160 }
6161 /* Before allocating a huge amount of memory for corrupted files, check
6162 * if size of requested memory is not greater than file size. */
6165 if (allocsize > filesize)
6166 {
6167 TIFFWarningExtR(
6168 tif, module,
6171 ". Memory not allocated, TIFF directory not read",
6172 allocsize, filesize);
6173 return 0;
6174 }
6175 origdir = _TIFFCheckMalloc(tif, dircount16, dirsize,
6176 "to read TIFF directory");
6178 return 0;
6179 m = off + dircount16 * dirsize;
6182 {
6184 _TIFFfreeExt(tif, origdir);
6185 return 0;
6186 }
6187 else
6188 {
6190 }
6191 if (nextdiroff)
6192 {
6193 off += dircount16 * dirsize;
6195 {
6196 uint32_t nextdiroff32;
6200 nextdiroff32 = 0;
6201 else
6205 TIFFSwabLong(&nextdiroff32);
6206 *nextdiroff = nextdiroff32;
6207 }
6208 else
6209 {
6213 *nextdiroff = 0;
6214 else
6218 TIFFSwabLong8(nextdiroff);
6219 }
6220 }
6221 }
6222 /* No check against filesize needed here because "dir" should have same size
6223 * than "origdir" checked above. */
6227 {
6228 _TIFFfreeExt(tif, origdir);
6229 return 0;
6230 }
6231 ma = (uint8_t *)origdir;
6232 mb = dir;
6234 {
6245 {
6253 }
6254 else
6255 {
6262 }
6263 mb++;
6264 }
6265 _TIFFfreeExt(tif, origdir);
6266 *pdir = dir;
6267 return dircount16;
6268}
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFFetchNormalTag()
|
static |
Definition at line 6273 of file tif_dirread.c.
6274{
6277 uint32_t fii;
6281 {
6284 return 0;
6285 }
6286 fip = tif->tif_fields[fii];
6290 this in specialized code */
6293 the case for pseudo-tags */
6296 {
6298 TIFFErrorExtR(
6299 tif, "TIFFFetchNormalTag",
6300 "Defined set_get_field_type of custom tag %u (%s) is "
6301 "TIFF_SETGET_UNDEFINED and thus tag is not read from file",
6303 break;
6305 {
6310 {
6311 size_t mb = 0;
6314 {
6316 {
6317 /* optimization: if data is known to be 0 terminated, we
6318 * can use strlen() */
6320 }
6321 else
6322 {
6323 /* general case. equivalent to non-portable */
6324 /* mb = strnlen((const char*)data,
6325 * (uint32_t)dp->tdir_count); */
6328 {
6329 if (*ma == 0)
6330 break;
6331 ma++;
6332 mb++;
6333 }
6334 }
6335 }
6337 {
6340 return (0);
6341 }
6343 TIFFWarningExtR(
6344 tif, module,
6345 "ASCII value for tag \"%s\" contains null byte in "
6346 "value; value incorrectly truncated during reading due "
6347 "to implementation limitations",
6348 fip->field_name);
6350 {
6352 "ASCII value for tag \"%s\" does not end "
6353 "in null byte. Forcing it to be null",
6354 fip->field_name);
6355 /* TIFFReadDirEntryArrayWithLimit() ensures this can't be
6356 * larger than MAX_SIZE_TAG_DATA */
6358 uint8_t *o =
6361 {
6364 return (0);
6365 }
6367 {
6369 }
6373 data = o;
6374 }
6379 return (0);
6380 }
6381 }
6382 break;
6383 case TIFF_SETGET_UINT8:
6384 {
6390 {
6392 return (0);
6393 }
6394 }
6395 break;
6397 {
6403 {
6405 return (0);
6406 }
6407 }
6408 break;
6410 {
6416 {
6418 return (0);
6419 }
6420 }
6421 break;
6423 {
6429 {
6431 return (0);
6432 }
6433 }
6434 break;
6436 {
6442 {
6444 return (0);
6445 }
6446 }
6447 break;
6449 {
6455 {
6457 return (0);
6458 }
6459 }
6460 break;
6462 {
6468 {
6470 return 0;
6472 return (0);
6473 }
6474 }
6475 break;
6477 {
6483 {
6485 return 0;
6487 return (0);
6488 }
6489 }
6490 break;
6492 {
6498 {
6500 return 0;
6502 return (0);
6503 }
6504 }
6505 break;
6507 {
6513 {
6515 return 0;
6517 return (0);
6518 }
6519 }
6520 break;
6522 {
6528 {
6530 return 0;
6532 return (0);
6533 }
6534 }
6535 break;
6537 {
6542 {
6544 "incorrect count for field \"%s\", expected 2, "
6547 return (0);
6548 }
6551 {
6557 return (0);
6558 }
6559 }
6560 break;
6562 {
6567 {
6569 "incorrect count for field \"%s\", expected "
6572 dp->tdir_count);
6573 return (0);
6574 }
6575 else
6576 {
6579 {
6581 {
6584 return 0;
6585 }
6591 return (0);
6592 }
6593 }
6594 }
6595 break;
6597 {
6602 {
6604 "incorrect count for field \"%s\", expected "
6607 dp->tdir_count);
6608 return (0);
6609 }
6610 else
6611 {
6614 {
6616 {
6619 return 0;
6620 }
6626 return (0);
6627 }
6628 }
6629 }
6630 break;
6632 {
6637 {
6639 "incorrect count for field \"%s\", expected "
6642 dp->tdir_count);
6643 return (0);
6644 }
6645 else
6646 {
6649 {
6651 {
6654 return 0;
6655 }
6661 return (0);
6662 }
6663 }
6664 }
6665 break;
6667 {
6672 {
6674 "incorrect count for field \"%s\", expected "
6677 dp->tdir_count);
6678 return (0);
6679 }
6680 else
6681 {
6684 {
6686 {
6689 return 0;
6690 }
6696 return (0);
6697 }
6698 }
6699 }
6700 break;
6702 {
6707 {
6709 "incorrect count for field \"%s\", expected "
6712 dp->tdir_count);
6713 return (0);
6714 }
6715 else
6716 {
6719 {
6721 {
6724 return 0;
6725 }
6731 return (0);
6732 }
6733 }
6734 }
6735 break;
6737 {
6742 {
6744 "incorrect count for field \"%s\", expected "
6747 dp->tdir_count);
6748 return (0);
6749 }
6750 else
6751 {
6754 {
6756 {
6759 return 0;
6760 }
6766 return (0);
6767 }
6768 }
6769 }
6770 break;
6772 {
6777 {
6779 "incorrect count for field \"%s\", expected "
6782 dp->tdir_count);
6783 return (0);
6784 }
6785 else
6786 {
6789 {
6791 {
6794 return 0;
6795 }
6801 return (0);
6802 }
6803 }
6804 }
6805 break;
6807 {
6812 {
6814 "incorrect count for field \"%s\", expected "
6817 dp->tdir_count);
6818 return (0);
6819 }
6820 else
6821 {
6824 {
6826 {
6829 return 0;
6830 }
6836 return (0);
6837 }
6838 }
6839 }
6840 break;
6842 {
6847 {
6849 "incorrect count for field \"%s\", expected "
6852 dp->tdir_count);
6853 return (0);
6854 }
6855 else
6856 {
6859 {
6861 {
6864 return 0;
6865 }
6871 return (0);
6872 }
6873 }
6874 }
6875 break;
6876 /*--: Rational2Double: Extend for Double Arrays and Rational-Arrays read
6877 * into Double-Arrays. */
6879 {
6884 {
6886 "incorrect count for field \"%s\", expected "
6889 dp->tdir_count);
6890 return (0);
6891 }
6892 else
6893 {
6896 {
6898 {
6901 return 0;
6902 }
6908 return (0);
6909 }
6910 }
6911 }
6912 break;
6914 {
6920 else
6921 {
6924 {
6926 {
6929 return 0;
6930 }
6934 {
6936 "ASCII value for ASCII array tag "
6937 "\"%s\" does not end in null "
6938 "byte. Forcing it to be null",
6939 fip->field_name);
6940 /* Enlarge buffer and add terminating null. */
6941 uint8_t *o =
6944 {
6947 return (0);
6948 }
6950 {
6952 }
6957 data = o;
6958 }
6964 return (0);
6965 }
6966 }
6967 }
6968 break;
6970 {
6976 else
6977 {
6980 {
6982 {
6985 return 0;
6986 }
6993 return (0);
6994 }
6995 }
6996 }
6997 break;
6999 {
7005 else
7006 {
7009 {
7011 {
7014 return 0;
7015 }
7022 return (0);
7023 }
7024 }
7025 }
7026 break;
7028 {
7034 else
7035 {
7038 {
7040 {
7043 return 0;
7044 }
7051 return (0);
7052 }
7053 }
7054 }
7055 break;
7057 {
7063 else
7064 {
7067 {
7069 {
7072 return 0;
7073 }
7080 return (0);
7081 }
7082 }
7083 }
7084 break;
7086 {
7092 else
7093 {
7096 {
7098 {
7101 return 0;
7102 }
7109 return (0);
7110 }
7111 }
7112 }
7113 break;
7115 {
7121 else
7122 {
7125 {
7127 {
7130 return 0;
7131 }
7138 return (0);
7139 }
7140 }
7141 }
7142 break;
7144 {
7150 else
7151 {
7154 {
7156 {
7159 return 0;
7160 }
7167 return (0);
7168 }
7169 }
7170 }
7171 break;
7173 {
7179 else
7180 {
7183 {
7185 {
7188 return 0;
7189 }
7196 return (0);
7197 }
7198 }
7199 }
7200 break;
7202 {
7208 else
7209 {
7212 {
7214 {
7217 return 0;
7218 }
7225 return (0);
7226 }
7227 }
7228 }
7229 break;
7231 {
7237 else
7238 {
7241 {
7243 {
7246 return 0;
7247 }
7254 return (0);
7255 }
7256 }
7257 }
7258 break;
7260 {
7266 else
7267 {
7270 {
7272 {
7275 return 0;
7276 }
7283 return (0);
7284 }
7285 }
7286 }
7287 break;
7289 {
7295 {
7297 {
7300 return 0;
7301 }
7305 {
7306 TIFFWarningExtR(
7307 tif, module,
7308 "ASCII value for ASCII array tag \"%s\" does not end "
7309 "in null byte. Forcing it to be null",
7310 fip->field_name);
7311 /* Enlarge buffer and add terminating null. */
7312 uint8_t *o =
7315 {
7318 return (0);
7319 }
7321 {
7323 }
7328 data = o;
7329 }
7331 data);
7335 return (0);
7336 }
7337 }
7338 break;
7340 {
7347 {
7348 /* Adobe's software (wrongly) writes RichTIFFIPTC tag with
7349 * data type LONG instead of UNDEFINED. Work around this
7350 * frequently found issue */
7351 void *origdata;
7354 {
7356 }
7357 else
7358 {
7363 }
7364 }
7365 else
7366 {
7369 }
7371 {
7373 {
7376 return 0;
7377 }
7383 return (0);
7384 }
7385 }
7386 break;
7388 {
7394 {
7396 {
7399 return 0;
7400 }
7403 data);
7407 return (0);
7408 }
7409 }
7410 break;
7412 {
7418 {
7420 {
7423 return 0;
7424 }
7427 data);
7431 return (0);
7432 }
7433 }
7434 break;
7436 {
7442 {
7444 {
7447 return 0;
7448 }
7451 data);
7455 return (0);
7456 }
7457 }
7458 break;
7460 {
7466 {
7468 {
7471 return 0;
7472 }
7475 data);
7479 return (0);
7480 }
7481 }
7482 break;
7484 {
7490 {
7492 {
7495 return 0;
7496 }
7499 data);
7503 return (0);
7504 }
7505 }
7506 break;
7508 {
7514 {
7516 {
7519 return 0;
7520 }
7523 data);
7527 return (0);
7528 }
7529 }
7530 break;
7532 {
7538 {
7540 {
7543 return 0;
7544 }
7547 data);
7551 return (0);
7552 }
7553 }
7554 break;
7556 {
7562 {
7564 {
7567 return 0;
7568 }
7571 data);
7575 return (0);
7576 }
7577 }
7578 break;
7580 {
7586 {
7588 {
7591 return 0;
7592 }
7595 data);
7599 return (0);
7600 }
7601 }
7602 break;
7604 {
7610 {
7612 {
7615 return 0;
7616 }
7619 data);
7623 return (0);
7624 }
7625 }
7626 break;
7627 default:
7629 break;
7630 }
7632 {
7634 return (0);
7635 }
7636 return (1);
7637}
static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF *tif, TIFFDirEntry *direntry, int64_t **value)
Definition: tif_dirread.c:2601
static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
Definition: tif_dirread.c:485
static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16_t tagid, uint32_t *fii)
Definition: tif_dirread.c:5242
static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t *count, uint32_t desttypesize, void **value)
Definition: tif_dirread.c:1382
static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
Definition: tif_dirread.c:2988
static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err, const char *module, const char *tagname, int recover)
Definition: tif_dirread.c:3919
static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF *tif, TIFFDirEntry *direntry, float *value)
Definition: tif_dirread.c:967
static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyte(TIFF *tif, TIFFDirEntry *direntry, int8_t *value)
Definition: tif_dirread.c:391
static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF *tif, TIFFDirEntry *direntry, uint8_t *value)
Definition: tif_dirread.c:299
static bool EvaluateIFDdatasizeReading(TIFF *tif, TIFFDirEntry *dp)
Definition: tif_dirread.c:4087
static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8(TIFF *tif, TIFFDirEntry *direntry, int64_t *value)
Definition: tif_dirread.c:897
static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:1072
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value)
Definition: tif_dirread.c:2594
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value)
Definition: tif_dirread.c:656
static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF *tif, TIFFDirEntry *direntry, int8_t **value)
Definition: tif_dirread.c:1572
static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16_t **value)
Definition: tif_dirread.c:1752
static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF *tif, TIFFDirEntry *direntry, int16_t **value)
Definition: tif_dirread.c:1925
static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF *tif, TIFFDirEntry *direntry, int32_t **value)
Definition: tif_dirread.c:2263
static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF *tif, TIFFDirEntry *direntry, float **value)
Definition: tif_dirread.c:2752
static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
Definition: tif_dirread.c:1161
static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong(TIFF *tif, TIFFDirEntry *direntry, int32_t *value)
Definition: tif_dirread.c:740
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
Definition: tif_dirread.c:818
static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value)
Definition: tif_dirread.c:3217
static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
Definition: tif_dirread.c:2093
static enum TIFFReadDirEntryErr TIFFReadDirEntrySshort(TIFF *tif, TIFFDirEntry *direntry, int16_t *value)
Definition: tif_dirread.c:572
static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF *tif, TIFFDirEntry *direntry, uint8_t **value)
Definition: tif_dirread.c:1390
void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
Definition: tif_swab.c:117
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFFetchStripThing()
|
static |
Definition at line 7643 of file tif_dirread.c.
7645{
7651 {
7655 return (0);
7656 }
7658 {
7659 uint64_t *resizeddata;
7662 uint32_t max_nstrips = 1000000;
7663 if (pszMax)
7667 (nstrips <= max_nstrips));
7668
7669 if (nstrips > max_nstrips)
7670 {
7672 return (0);
7673 }
7674
7676 if (allocsize > 100 * 1024 * 1024)
7677 {
7678 /* Before allocating a huge amount of memory for corrupted files,
7679 * check if size of requested memory is not greater than file size.
7680 */
7682 if (allocsize > filesize)
7683 {
7684 TIFFWarningExtR(
7685 tif, module,
7688 ". Memory not allocated",
7689 allocsize, filesize);
7691 return (0);
7692 }
7693 }
7696 if (resizeddata == 0)
7697 {
7699 return (0);
7700 }
7707 data = resizeddata;
7708 }
7709 *lpp = data;
7710 return (1);
7711}
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value, uint64_t maxcount)
Definition: tif_dirread.c:2425
Referenced by _TIFFFillStrilesInternal(), and TIFFReadDirectory().
◆ TIFFFetchSubjectDistance()
|
static |
Definition at line 7716 of file tif_dirread.c.
7717{
7721 m.l = 0;
7729 else
7730 {
7732 {
7738 }
7739 else
7740 {
7743 }
7744 }
7746 {
7751 n = 0.0;
7753 /*
7754 * XXX: Numerator 0xFFFFFFFF means that we have infinite
7755 * distance. Indicate that with a negative floating point
7756 * SubjectDistance value.
7757 */
7758 n = -1.0;
7759 else
7762 }
7763 else
7764 {
7766 return (0);
7767 }
7768}
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:91
static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF *tif, uint64_t offset, tmsize_t size, void *dest)
Definition: tif_dirread.c:3892
Definition: tif_dirread.c:271
Referenced by TIFFReadCustomDirectory().
◆ TIFFGetStrileByteCount()
Definition at line 8366 of file tif_dirread.c.
8367{
8369}
uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile, int *pbErr)
Definition: tif_dirread.c:8373
Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), ChopUpSingleUncompressedStrip(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFRawStripSize64(), TIFFReadDirectory(), TIFFReadRawStrip(), TIFFReadRawTile(), TIFFSeek(), TIFFStartStrip(), TIFFStartTile(), and TryChopUpUncompressedBigTiff().
◆ TIFFGetStrileByteCountWithErr()
Definition at line 8373 of file tif_dirread.c.
8374{
8378 pbErr);
8379}
static uint64_t _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32_t strile, TIFFDirEntry *dirent, uint64_t **parray, int *pbErr)
Definition: tif_dirread.c:8303
Referenced by TIFFGetStrileByteCount().
◆ TIFFGetStrileOffset()
Definition at line 8349 of file tif_dirread.c.
8350{
8352}
uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile, int *pbErr)
Definition: tif_dirread.c:8356
Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFReadDirectory(), TIFFReadRawStrip1(), TIFFReadRawStripOrTile2(), TIFFReadRawTile1(), and TryChopUpUncompressedBigTiff().
◆ TIFFGetStrileOffsetWithErr()
Definition at line 8356 of file tif_dirread.c.
Referenced by TIFFGetStrileOffset().
◆ TIFFReadCustomDirectory()
| int TIFFReadCustomDirectory | ( | TIFF * | tif, |
| toff_t | diroff, | ||
| const TIFFFieldArray * | infoarray | ||
| ) |
Definition at line 5278 of file tif_dirread.c.
5280{
5283 uint16_t dircount;
5284 TIFFDirEntry *dp;
5285 uint16_t di;
5287 uint32_t fii;
5288
5291 if (!dircount)
5292 {
5295 diroff);
5296 return 0;
5297 }
5299
5300 /*
5301 * Mark duplicates of any tag to be ignored (bugzilla 1994)
5302 * to avoid certain pathological problems.
5303 */
5304 {
5305 TIFFDirEntry *ma;
5306 uint16_t mb;
5308 {
5309 TIFFDirEntry *na;
5310 uint16_t nb;
5311 for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
5312 {
5314 {
5316 }
5317 }
5318 }
5319 }
5320
5321 /* Free any old stuff and reinit. */
5322 TIFFFreeDirectory(tif);
5323 /* Even if custom directories do not need the default settings of a standard
5324 * IFD, the pointer to the TIFFSetField() and TIFFGetField() (i.e.
5325 * tif->tif_tagmethods.vsetfield and tif->tif_tagmethods.vgetfield) need to
5326 * be initialized, which is done in TIFFDefaultDirectory().
5327 * After that, the field array for the custom tags needs to be setup again.
5328 */
5329 TIFFDefaultDirectory(tif);
5330 _TIFFSetupFields(tif, infoarray);
5331
5332 /* Allocate arrays for offset values outside IFD entry for IFD data size
5333 * checking. Note: Counter are reset within TIFFFreeDirectory(). */
5338 {
5339 TIFFErrorExtR(
5340 tif, module,
5341 "Failed to allocate memory for counting IFD data size at reading");
5344 return 0;
5345 }
5346
5348 {
5351 {
5353 {
5356 ") encountered",
5358 }
5362 {
5364 {
5365 TIFFWarningExtR(
5366 tif, module,
5370 }
5372 }
5373 else
5374 {
5377 }
5378 }
5380 {
5381 fip = tif->tif_fields[fii];
5384 else
5385 {
5386 /* check data type */
5389 {
5390 fii++;
5394 {
5395 fii = 0xFFFF;
5396 break;
5397 }
5398 fip = tif->tif_fields[fii];
5399 }
5400 if (fii == 0xFFFF)
5401 {
5404 " for \"%s\"; tag ignored",
5407 }
5408 else
5409 {
5410 /* check count if known in advance */
5413 {
5416 expected =
5418 else
5422 }
5423 }
5424 }
5426 {
5428 {
5431 {
5432 /* should only be called on a Exif directory */
5433 /* when exifFields[] is active */
5435 }
5436 else
5437 {
5439 }
5440 break;
5441 default:
5443 break;
5444 }
5445 } /*-- if (!dp->tdir_ignore) */
5446 }
5447 }
5448 /* Evaluate final IFD data size. */
5449 CalcFinalIFDdatasizeReading(tif, dircount);
5450
5451 /* To be able to return from SubIFD or custom-IFD to main-IFD */
5455 return 1;
5456}
Definition: nsiface.idl:2307
int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32_t n)
Definition: tif_dirinfo.c:573
TIFFField * _TIFFCreateAnonField(TIFF *tif, uint32_t tag, TIFFDataType field_type)
Definition: tif_dirinfo.c:898
void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *fieldarray)
Definition: tif_dirinfo.c:513
static int CheckDirCount(TIFF *, TIFFDirEntry *, uint32_t)
Definition: tif_dirread.c:5947
static void CalcFinalIFDdatasizeReading(TIFF *tif, uint16_t dircount)
Definition: tif_dirread.c:4160
static void TIFFReadDirectoryCheckOrder(TIFF *tif, TIFFDirEntry *dir, uint16_t dircount)
Definition: tif_dirread.c:5206
static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff, TIFFDirEntry **pdir, uint64_t *nextdiroff)
Definition: tif_dirread.c:5978
static int TIFFFetchSubjectDistance(TIFF *, TIFFDirEntry *)
Definition: tif_dirread.c:7716
static int TIFFFetchNormalTag(TIFF *, TIFFDirEntry *, int recover)
Definition: tif_dirread.c:6273
Referenced by TIFFReadEXIFDirectory(), and TIFFReadGPSDirectory().
◆ TIFFReadDirectory()
Definition at line 4236 of file tif_dirread.c.
4237{
4240 uint16_t dircount;
4241 TIFFDirEntry *dp;
4242 uint16_t di;
4245 toff_t nextdiroff;
4247 int color_channels;
4248
4250 {
4251 /* In this special case, tif_diroff needs also to be set to 0.
4252 * This is behind the last IFD, thus no checking or reading necessary.
4253 */
4255 return 0;
4256 }
4257
4258 nextdiroff = tif->tif_nextdiroff;
4259 /* tif_curdir++ and tif_nextdiroff should only be updated after SUCCESSFUL
4260 * reading of the directory. Otherwise, invalid IFD offsets could corrupt
4261 * the IFD list. */
4263 tif->tif_curdir ==
4265 ? 0
4266 : tif->tif_curdir + 1,
4267 nextdiroff))
4268 {
4269 return 0; /* bad offset (IFD looping or more than TIFF_MAX_DIR_COUNT
4270 IFDs) */
4271 }
4273 if (!dircount)
4274 {
4277 nextdiroff);
4278 return 0;
4279 }
4280 /* Set global values after a valid directory has been fetched.
4281 * tif_diroff is already set to nextdiroff in TIFFFetchDirectory() in the
4282 * beginning. */
4284 tif->tif_curdir = 0;
4285 else
4286 tif->tif_curdir++;
4287
4289
4290 /*
4291 * Mark duplicates of any tag to be ignored (bugzilla 1994)
4292 * to avoid certain pathological problems.
4293 */
4294 {
4295 TIFFDirEntry *ma;
4296 uint16_t mb;
4298 {
4299 TIFFDirEntry *na;
4300 uint16_t nb;
4301 for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
4302 {
4304 {
4306 }
4307 }
4308 }
4309 }
4310
4313 tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
4314
4315 /* free any old stuff and reinit */
4316 TIFFFreeDirectory(tif);
4317 TIFFDefaultDirectory(tif);
4318
4319 /* After setup a fresh directory indicate that now active IFD is also
4320 * present on file, even if its entries could not be read successfully
4321 * below. */
4323
4324 /* Allocate arrays for offset values outside IFD entry for IFD data size
4325 * checking. Note: Counter are reset within TIFFFreeDirectory(). */
4330 {
4331 TIFFErrorExtR(
4332 tif, module,
4333 "Failed to allocate memory for counting IFD data size at reading");
4334 goto bad;
4335 }
4336 /*
4337 * Electronic Arts writes gray-scale TIFF files
4338 * without a PlanarConfiguration directory entry.
4339 * Thus we setup a default value here, even though
4340 * the TIFF spec says there is no default value.
4341 * After PlanarConfiguration is preset in TIFFDefaultDirectory()
4342 * the following setting is not needed, but does not harm either.
4343 */
4345 /*
4346 * Setup default value and then make a pass over
4347 * the fields to check type and tag information,
4348 * and to extract info required to size data
4349 * structures. A second pass is made afterwards
4350 * to read in everything not taken in the first pass.
4351 * But we must process the Compression tag first
4352 * in order to merge in codec-private tag definitions (otherwise
4353 * we may get complaints about unknown tags). However, the
4354 * Compression tag may be dependent on the SamplesPerPixel
4355 * tag value because older TIFF specs permitted Compression
4356 * to be written as a SamplesPerPixel-count tag entry.
4357 * Thus if we don't first figure out the correct SamplesPerPixel
4358 * tag value then we may end up ignoring the Compression tag
4359 * value because it has an incorrect count value (if the
4360 * true value of SamplesPerPixel is not 1).
4361 */
4362 dp =
4364 if (dp)
4365 {
4367 goto bad;
4369 }
4371 if (dp)
4372 {
4373 /*
4374 * The 5.0 spec says the Compression tag has one value, while
4375 * earlier specs say it has one value per sample. Because of
4376 * this, we accept the tag if one value is supplied with either
4377 * count.
4378 */
4385 {
4387 goto bad;
4388 }
4390 goto bad;
4392 }
4393 else
4394 {
4396 goto bad;
4397 }
4398 /*
4399 * First real pass over the directory.
4400 */
4402 {
4404 {
4407 {
4409 {
4414 }
4415 /* the following knowingly leaks the
4416 anonymous field structure */
4420 {
4421 TIFFWarningExtR(
4422 tif, module,
4427 }
4428 else
4429 {
4432 }
4433 }
4434 }
4436 {
4437 fip = tif->tif_fields[fii];
4440 else
4441 {
4443 {
4449 break;
4460 goto bad;
4462 break;
4463 default:
4466 break;
4467 }
4468 }
4469 }
4470 }
4471 /*
4472 * XXX: OJPEG hack.
4473 * If a) compression is OJPEG, b) planarconfig tag says it's separate,
4474 * c) strip offsets/bytecounts tag are both present and
4475 * d) both contain exactly one value, then we consistently find
4476 * that the buggy implementation of the buggy compression scheme
4477 * matches contig planarconfig best. So we 'fix-up' the tag here
4478 */
4481 {
4483 goto bad;
4485 TIFFTAG_STRIPOFFSETS);
4487 {
4489 TIFFTAG_STRIPBYTECOUNTS);
4491 {
4494 "Planarconfig tag value assumed incorrect, "
4495 "assuming data is contig instead of chunky");
4496 }
4497 }
4498 }
4499 /*
4500 * Allocate directory structure and setup defaults.
4501 */
4503 {
4505 goto bad;
4506 }
4507
4508 /*
4509 * Second pass: extract other information.
4510 */
4512 {
4514 {
4516 {
4522 /*
4523 * The MinSampleValue, MaxSampleValue, BitsPerSample
4524 * DataType and SampleFormat tags are supposed to be
4525 * written as one value/sample, but some vendors
4526 * incorrectly write one value only -- so we accept
4527 * that as well (yuck). Other vendors write correct
4528 * value for NumberOfSamples, but incorrect one for
4529 * BitsPerSample and friends, and we will read this
4530 * too.
4531 */
4532 {
4537 goto bad;
4539 err =
4542 {
4547 goto bad;
4548 }
4550 goto bad;
4552 bitspersample_read = TRUE;
4553 }
4554 break;
4557 {
4558
4561 uint32_t saved_flags;
4566 else
4569 goto bad;
4571 {
4576 goto bad;
4577 }
4578 saved_flags = tif->tif_flags;
4581 tif->tif_flags = saved_flags;
4584 goto bad;
4585 }
4586 break;
4589 {
4591 {
4595 break;
4596 default:
4597 /* Warn except if directory typically created with
4598 * TIFFDeferStrileArrayWriting() */
4602 {
4604 TIFFWarningExtR(
4607 }
4608 break;
4609 }
4613 goto bad;
4614 }
4615 break;
4618 {
4620 {
4624 break;
4625 default:
4626 /* Warn except if directory typically created with
4627 * TIFFDeferStrileArrayWriting() */
4631 {
4633 TIFFWarningExtR(
4636 }
4637 break;
4638 }
4642 goto bad;
4643 }
4644 break;
4647 {
4649 uint32_t countpersample;
4650 uint32_t countrequired;
4651 uint32_t incrementpersample;
4653 /* It would be dangerous to instantiate those tag values */
4654 /* since if td_bitspersample has not yet been read (due to
4655 */
4656 /* unordered tags), it could be read afterwards with a */
4657 /* values greater than the default one (1), which may cause
4658 */
4659 /* crashes in user code */
4660 if (!bitspersample_read)
4661 {
4663 TIFFWarningExtR(
4664 tif, module,
4665 "Ignoring %s since BitsPerSample tag not found",
4667 continue;
4668 }
4669 /* ColorMap or TransferFunction for high bit */
4670 /* depths do not make much sense and could be */
4671 /* used as a denial of service vector */
4673 {
4675 TIFFWarningExtR(
4676 tif, module,
4680 continue;
4681 }
4685 {
4686 countrequired = countpersample;
4687 incrementpersample = 0;
4688 }
4689 else
4690 {
4691 countrequired = 3 * countpersample;
4692 incrementpersample = countpersample;
4693 }
4696 else
4699 goto bad;
4701 {
4706 }
4707 else
4708 {
4710 value + incrementpersample,
4711 value + 2 * incrementpersample);
4713 }
4714 }
4715 break;
4716 /* BEGIN REV 4.0 COMPATIBILITY */
4718 {
4719 uint16_t valueo;
4722 TIFFReadDirEntryErrOk)
4723 {
4724 switch (valueo)
4725 {
4728 break;
4731 break;
4732 default:
4733 value = 0;
4734 break;
4735 }
4738 }
4739 }
4740 break;
4741 /* END REV 4.0 COMPATIBILITY */
4742#if 0
4744 /* TIFFTAG_EP_BATTERYLEVEL can be RATIONAL or ASCII.
4745 * LibTiff defines it as ASCII and converts RATIONAL to an
4746 * ASCII string. */
4748 {
4750 {
4751 /* Read rational and convert to ASCII*/
4753 TIFFRational_t rValue;
4754 err = TIFFReadDirEntryCheckedRationalDirect(
4755 tif, dp, &rValue);
4757 {
4762 1);
4763 }
4764 else
4765 {
4766 char szAux[32];
4770 }
4771 }
4772 break;
4775 break;
4776 default:
4779 "Invalid data type for tag %s. "
4780 "ASCII or RATIONAL expected",
4781 fip ? fip->field_name
4782 : "unknown tagname");
4783 break;
4784 }
4785 break;
4786#endif
4787 default:
4789 break;
4790 } /* -- switch (dp->tdir_tag) -- */
4791 } /* -- if (!dp->tdir_ignore) */
4792 } /* -- for-loop -- */
4793
4794 /* Evaluate final IFD data size. */
4795 CalcFinalIFDdatasizeReading(tif, dircount);
4796
4797 /*
4798 * OJPEG hack:
4799 * - If a) compression is OJPEG, and b) photometric tag is missing,
4800 * then we consistently find that photometric should be YCbCr
4801 * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
4802 * then we consistently find that the buggy implementation of the
4803 * buggy compression scheme matches photometric YCbCr instead.
4804 * - If a) compression is OJPEG, and b) bitspersample tag is missing,
4805 * then we consistently find bitspersample should be 8.
4806 * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4807 * and c) photometric is RGB or YCbCr, then we consistently find
4808 * samplesperpixel should be 3
4809 * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4810 * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
4811 * find samplesperpixel should be 3
4812 */
4814 {
4816 {
4817 TIFFWarningExtR(
4818 tif, module,
4819 "Photometric tag is missing, assuming data is YCbCr");
4821 goto bad;
4822 }
4824 {
4827 "Photometric tag value assumed incorrect, "
4828 "assuming data is YCbCr instead of RGB");
4829 }
4831 {
4832 TIFFWarningExtR(
4833 tif, module,
4834 "BitsPerSample tag is missing, assuming 8 bits per sample");
4836 goto bad;
4837 }
4839 {
4841 {
4843 "SamplesPerPixel tag is missing, "
4844 "assuming correct SamplesPerPixel value is 3");
4846 goto bad;
4847 }
4849 {
4851 "SamplesPerPixel tag is missing, "
4852 "applying correct SamplesPerPixel value of 3");
4854 goto bad;
4855 }
4858 {
4859 /*
4860 * SamplesPerPixel tag is missing, but is not required
4861 * by spec. Assume correct SamplesPerPixel value of 1.
4862 */
4864 goto bad;
4865 }
4866 }
4867 }
4868
4869 /*
4870 * Setup appropriate structures (by strip or by tile)
4871 * We do that only after the above OJPEG hack which alters SamplesPerPixel
4872 * and thus influences the number of strips in the separate planarconfig.
4873 */
4875 {
4880 tif->tif_flags &= ~TIFF_ISTILED;
4881 }
4882 else
4883 {
4886 }
4888 {
4891 goto bad;
4892 }
4897 {
4898#ifdef OJPEG_SUPPORT
4901 {
4902 /*
4903 * XXX: OJPEG hack.
4904 * If a) compression is OJPEG, b) it's not a tiled TIFF,
4905 * and c) the number of strips is 1,
4906 * then we tolerate the absence of stripoffsets tag,
4907 * because, presumably, all required data is in the
4908 * JpegInterchangeFormat stream.
4909 */
4911 }
4912 else
4913#endif
4914 {
4916 goto bad;
4917 }
4918 }
4919
4929 {
4930 /* Directory typically created with TIFFDeferStrileArrayWriting() */
4931 TIFFSetupStrips(tif);
4932 }
4934 {
4936 {
4940 {
4941 goto bad;
4942 }
4943 }
4945 {
4949 {
4950 goto bad;
4951 }
4952 }
4953 }
4954
4955 /*
4956 * Make sure all non-color channels are extrasamples.
4957 * If it's not the case, define them as such.
4958 */
4960 if (color_channels &&
4962 color_channels)
4963 {
4964 uint16_t old_extrasamples;
4965 uint16_t *new_sampleinfo;
4966
4967 TIFFWarningExtR(
4968 tif, module,
4969 "Sum of Photometric type-related "
4970 "color channels and ExtraSamples doesn't match SamplesPerPixel. "
4971 "Defining non-color channels as ExtraSamples.");
4972
4976
4977 // sampleinfo should contain information relative to these new extra
4978 // samples
4981 if (!new_sampleinfo)
4982 {
4984 "Failed to allocate memory for "
4985 "temporary new sampleinfo array "
4988 goto bad;
4989 }
4990
4991 if (old_extrasamples > 0)
4996 _TIFFfreeExt(tif, new_sampleinfo);
4997 }
4998
4999 /*
5000 * Verify Palette image has a Colormap.
5001 */
5004 {
5010 else
5011 {
5013 goto bad;
5014 }
5015 }
5016 /*
5017 * OJPEG hack:
5018 * We do no further messing with strip/tile offsets/bytecounts in OJPEG
5019 * TIFFs
5020 */
5022 {
5023 /*
5024 * Attempt to deal with a missing StripByteCounts tag.
5025 */
5027 {
5028 /*
5029 * Some manufacturers violate the spec by not giving
5030 * the size of the strips. In this case, assume there
5031 * is one uncompressed strip of data.
5032 */
5038 {
5040 goto bad;
5041 }
5042 TIFFWarningExtR(
5043 tif, module,
5044 "TIFF directory is missing required "
5045 "\"StripByteCounts\" field, calculating from imagelength");
5047 goto bad;
5048 }
5051 {
5052 /*
5053 * XXX: Plexus (and others) sometimes give a value of
5054 * zero for a tag when they don't know what the
5055 * correct value is! Try and handle the simple case
5056 * of estimating the size of a one strip image.
5057 */
5059 "Bogus \"StripByteCounts\" field, ignoring and "
5060 "calculating from imagelength");
5062 goto bad;
5063 }
5068 TIFFGetStrileByteCount(tif, 0) !=
5069 TIFFGetStrileByteCount(tif, 1) &&
5070 TIFFGetStrileByteCount(tif, 0) != 0 &&
5071 TIFFGetStrileByteCount(tif, 1) != 0)
5072 {
5073 /*
5074 * XXX: Some vendors fill StripByteCount array with
5075 * absolutely wrong values (it can be equal to
5076 * StripOffset array, for example). Catch this case
5077 * here.
5078 *
5079 * We avoid this check if deferring strile loading
5080 * as it would always force us to load the strip/tile
5081 * information.
5082 */
5084 "Wrong \"StripByteCounts\" field, ignoring and "
5085 "calculating from imagelength");
5087 goto bad;
5088 }
5089 }
5091 {
5094 }
5096 {
5099 else
5102 }
5103
5104#ifdef STRIPBYTECOUNTSORTED_UNUSED
5105 /*
5106 * XXX: We can optimize checking for the strip bounds using the sorted
5107 * bytecounts array. See also comments for TIFFAppendToStrip()
5108 * function in tif_write.c.
5109 */
5111 {
5112 uint32_t strip;
5113
5114 tif->tif_dir.td_stripbytecountsorted = 1;
5116 {
5118 TIFFGetStrileOffset(tif, strip))
5119 {
5120 tif->tif_dir.td_stripbytecountsorted = 0;
5121 break;
5122 }
5123 }
5124 }
5125#endif
5126
5127 /*
5128 * An opportunity for compression mode dependent tag fixup
5129 */
5130 (*tif->tif_fixuptags)(tif);
5131
5132 /*
5133 * Some manufacturers make life difficult by writing
5134 * large amounts of uncompressed data as a single strip.
5135 * This is contrary to the recommendations of the spec.
5136 * The following makes an attempt at breaking such images
5137 * into strips closer to the recommended 8k bytes. A
5138 * side effect, however, is that the RowsPerStrip tag
5139 * value may be changed.
5140 */
5145 {
5146 ChopUpSingleUncompressedStrip(tif);
5147 }
5148
5149 /* There are also uncompressed striped files with strips larger than */
5150 /* 2 GB, which make them unfriendly with a lot of code. If possible, */
5151 /* try to expose smaller "virtual" strips. */
5155 TIFFStripSize64(tif) > 0x7FFFFFFFUL)
5156 {
5157 TryChopUpUncompressedBigTiff(tif);
5158 }
5159
5160 /*
5161 * Clear the dirty directory flag.
5162 */
5163 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
5164 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
5165
5166 /*
5167 * Reinitialize i/o since we are starting on a new directory.
5168 */
5174
5177 {
5179 return (0);
5180 }
5181
5183 {
5186 {
5188 return (0);
5189 }
5190 }
5191 else
5192 {
5194 {
5196 return (0);
5197 }
5198 }
5199 return (1);
5200bad:
5203 return (0);
5204} /*-- TIFFReadDirectory() --*/
Definition: tiffio.h:278
void _TIFFsetShortArrayExt(TIFF *tif, uint16_t **wpp, const uint16_t *wp, uint32_t n)
Definition: tif_dir.c:78
int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag)
Definition: tif_dirinfo.c:1247
int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
Definition: tif_dirread.c:5665
static void TryChopUpUncompressedBigTiff(TIFF *)
Definition: tif_dirread.c:7937
static TIFFDirEntry * TIFFReadDirectoryFindEntry(TIFF *tif, TIFFDirEntry *dir, uint16_t dircount, uint16_t tagid)
Definition: tif_dirread.c:5227
static void ChopUpSingleUncompressedStrip(TIFF *)
Definition: tif_dirread.c:7867
static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir, uint16_t dircount)
Definition: tif_dirread.c:5475
static int _TIFFGetMaxColorChannels(uint16_t photometric)
Definition: tif_dirread.c:4016
static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
Definition: tif_dirread.c:3279
void * _TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz)
Definition: tif_open.c:201
Definition: pdh_main.c:96
Referenced by TIFFClientOpenExt(), TIFFSetDirectory(), and TIFFSetSubDirectory().
◆ TIFFReadDirectoryCheckOrder()
|
static |
Definition at line 5206 of file tif_dirread.c.
5208{
5212 TIFFDirEntry *o;
5213 m = 0;
5215 {
5217 {
5219 "Invalid TIFF directory; tags are not sorted in "
5220 "ascending order");
5221 break;
5222 }
5224 }
5225}
Referenced by TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFReadDirectoryFindEntry()
|
static |
◆ TIFFReadDirectoryFindFieldInfo()
Definition at line 5242 of file tif_dirread.c.
5244{
5245 int32_t ma, mb, mc;
5246 ma = -1;
5248 while (1)
5249 {
5250 if (ma + 1 == mc)
5251 {
5252 *fii = FAILED_FII;
5253 return;
5254 }
5255 mb = (ma + mc) / 2;
5257 break;
5259 ma = mb;
5260 else
5261 mc = mb;
5262 }
5263 while (1)
5264 {
5265 if (mb == 0)
5266 break;
5268 break;
5269 mb--;
5270 }
5271 *fii = mb;
5272}
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
Referenced by TIFFFetchNormalTag(), TIFFReadCustomDirectory(), and TIFFReadDirectory().
◆ TIFFReadDirEntryArray()
|
static |
Definition at line 1382 of file tif_dirread.c.
1384{
1387}
static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry, uint32_t *count, uint32_t desttypesize, void **value, uint64_t maxcount)
Definition: tif_dirread.c:1254
Referenced by TIFFFetchNormalTag(), TIFFReadDirEntryByteArray(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryIfd8Array(), TIFFReadDirEntryLongArray(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryArrayWithLimit()
|
static |
Definition at line 1254 of file tif_dirread.c.
1257{
1258 int typesize;
1261 uint64_t target_count64;
1262 int original_datasize_clamped;
1264
1265 target_count64 =
1267
1268 if ((target_count64 == 0) || (typesize == 0))
1269 {
1270 *value = 0;
1272 }
1273 (void)desttypesize;
1274
1275 /* We just want to know if the original tag size is more than 4 bytes
1276 * (classic TIFF) or 8 bytes (BigTIFF)
1277 */
1278 original_datasize_clamped =
1280 typesize;
1281
1282 /*
1283 * As a sanity check, make sure we have no more than a 2GB tag array
1284 * in either the current data type or the dest data type. This also
1285 * avoids problems with overflow of tmsize_t on 32bit systems.
1286 */
1291
1293 datasize = (*count) * typesize;
1295
1297 {
1298 /* Before allocating a huge amount of memory for corrupted files, check
1299 * if size of requested memory is not greater than file size.
1300 */
1303 {
1307 ". Memory not allocated, tag not read",
1309 filesize);
1311 }
1312 }
1313
1316
1319 {
1321 }
1322 else
1323 {
1327 }
1329 {
1330 /* Only the condition on original_datasize_clamped. The second
1331 * one is implied, but Coverity Scan cannot see it. */
1334 else
1335 {
1343 else
1347 {
1350 }
1351 }
1352 }
1353 else
1354 {
1355 /* See above comment for the Classic TIFF case */
1358 else
1359 {
1367 else
1371 {
1374 }
1375 }
1376 }
1379}
static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc(TIFF *tif, uint64_t offset, tmsize_t size, void **pdest)
Definition: tif_dirread.c:1191
Referenced by TIFFReadDirEntryArray(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryByte()
|
static |
Definition at line 299 of file tif_dirread.c.
300{
305 {
308 field_readcount==1 */
312 {
320 }
322 {
330 }
332 {
340 }
342 {
350 }
352 {
360 }
362 {
372 }
374 {
384 }
385 default:
387 }
388}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
Definition: tif_dirread.c:3356
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32_t value)
Definition: tif_dirread.c:3576
static void TIFFReadDirEntryCheckedSlong(TIFF *tif, TIFFDirEntry *direntry, int32_t *value)
Definition: tif_dirread.c:3347
static void TIFFReadDirEntryCheckedShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
Definition: tif_dirread.c:3322
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16_t value)
Definition: tif_dirread.c:3558
static void TIFFReadDirEntryCheckedByte(TIFF *tif, TIFFDirEntry *direntry, uint8_t *value)
Definition: tif_dirread.c:3308
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64_t value)
Definition: tif_dirread.c:3594
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8_t value)
Definition: tif_dirread.c:3549
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32_t value)
Definition: tif_dirread.c:3585
static void TIFFReadDirEntryCheckedSshort(TIFF *tif, TIFFDirEntry *direntry, int16_t *value)
Definition: tif_dirread.c:3331
static void TIFFReadDirEntryCheckedSbyte(TIFF *tif, TIFFDirEntry *direntry, int8_t *value)
Definition: tif_dirread.c:3315
static void TIFFReadDirEntryCheckedLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value)
Definition: tif_dirread.c:3339
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF *tif, TIFFDirEntry *direntry, int64_t *value)
Definition: tif_dirread.c:3376
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16_t value)
Definition: tif_dirread.c:3567
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64_t value)
Definition: tif_dirread.c:3603
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryByteArray()
|
static |
Definition at line 1390 of file tif_dirread.c.
1391{
1394 void *origdata;
1397 {
1408 break;
1409 default:
1411 }
1414 {
1415 *value = 0;
1417 }
1419 {
1426 {
1431 {
1434 {
1435 _TIFFfreeExt(tif, origdata);
1437 }
1438 m++;
1439 }
1442 }
1443 }
1446 {
1447 _TIFFfreeExt(tif, origdata);
1449 }
1451 {
1453 {
1454 uint16_t *ma;
1455 uint8_t *mb;
1457 ma = (uint16_t *)origdata;
1458 mb = data;
1460 {
1462 TIFFSwabShort(ma);
1465 break;
1466 *mb++ = (uint8_t)(*ma++);
1467 }
1468 }
1469 break;
1471 {
1472 int16_t *ma;
1473 uint8_t *mb;
1475 ma = (int16_t *)origdata;
1476 mb = data;
1478 {
1483 break;
1484 *mb++ = (uint8_t)(*ma++);
1485 }
1486 }
1487 break;
1489 {
1490 uint32_t *ma;
1491 uint8_t *mb;
1493 ma = (uint32_t *)origdata;
1494 mb = data;
1496 {
1498 TIFFSwabLong(ma);
1501 break;
1502 *mb++ = (uint8_t)(*ma++);
1503 }
1504 }
1505 break;
1507 {
1508 int32_t *ma;
1509 uint8_t *mb;
1511 ma = (int32_t *)origdata;
1512 mb = data;
1514 {
1519 break;
1520 *mb++ = (uint8_t)(*ma++);
1521 }
1522 }
1523 break;
1525 {
1526 uint64_t *ma;
1527 uint8_t *mb;
1529 ma = (uint64_t *)origdata;
1530 mb = data;
1532 {
1534 TIFFSwabLong8(ma);
1537 break;
1538 *mb++ = (uint8_t)(*ma++);
1539 }
1540 }
1541 break;
1543 {
1544 int64_t *ma;
1545 uint8_t *mb;
1547 ma = (int64_t *)origdata;
1548 mb = data;
1550 {
1555 break;
1556 *mb++ = (uint8_t)(*ma++);
1557 }
1558 }
1559 break;
1560 }
1561 _TIFFfreeExt(tif, origdata);
1563 {
1566 }
1569}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryCheckedByte()
|
static |
Definition at line 3308 of file tif_dirread.c.
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedDouble()
|
static |
Definition at line 3522 of file tif_dirread.c.
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedFloat()
|
static |
Definition at line 3504 of file tif_dirread.c.
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedLong()
|
static |
Definition at line 3339 of file tif_dirread.c.
3341{
3345}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryIfd8(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedLong8()
|
static |
Definition at line 3356 of file tif_dirread.c.
3357{
3359 {
3367 }
3368 else
3373}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryIfd8(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedRational()
|
static |
Definition at line 3396 of file tif_dirread.c.
3398{
3400
3405 {
3413 }
3414 else
3418 /* Not completely sure what we should do when m.i[1]==0, but some */
3419 /* sanitizers do not like division by 0.0: */
3420 /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */
3422 *value = 0.0;
3423 else
3426}
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedSbyte()
|
static |
Definition at line 3315 of file tif_dirread.c.
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedShort()
|
static |
Definition at line 3322 of file tif_dirread.c.
3324{
3326 /* *value=*(uint16_t*)(&direntry->tdir_offset); */
3329}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedSlong()
|
static |
Definition at line 3347 of file tif_dirread.c.
3349{
3353}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedSlong8()
|
static |
Definition at line 3376 of file tif_dirread.c.
3377{
3379 {
3387 }
3388 else
3393}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckedSrational()
|
static |
Definition at line 3429 of file tif_dirread.c.
3431{
3438 {
3446 }
3447 else
3451 /* Not completely sure what we should do when m.i[1]==0, but some */
3452 /* sanitizers do not like division by 0.0: */
3453 /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */
3455 *value = 0.0;
3456 else
3459}
Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryFloat().
◆ TIFFReadDirEntryCheckedSshort()
|
static |
Definition at line 3331 of file tif_dirread.c.
3333{
3337}
Referenced by TIFFReadDirEntryByte(), TIFFReadDirEntryDouble(), TIFFReadDirEntryFloat(), TIFFReadDirEntryLong(), TIFFReadDirEntryLong8(), TIFFReadDirEntrySbyte(), TIFFReadDirEntryShort(), TIFFReadDirEntrySlong(), TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySshort().
◆ TIFFReadDirEntryCheckRangeByteLong()
|
static |
Definition at line 3576 of file tif_dirread.c.
3577{
3580 else
3582}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteLong8()
|
static |
Definition at line 3594 of file tif_dirread.c.
3595{
3598 else
3600}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSbyte()
|
static |
Definition at line 3549 of file tif_dirread.c.
3550{
3553 else
3555}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteShort()
|
static |
Definition at line 3558 of file tif_dirread.c.
3559{
3562 else
3564}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSlong()
|
static |
Definition at line 3585 of file tif_dirread.c.
3586{
3589 else
3591}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSlong8()
|
static |
Definition at line 3603 of file tif_dirread.c.
3604{
3607 else
3609}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeByteSshort()
|
static |
Definition at line 3567 of file tif_dirread.c.
3568{
3571 else
3573}
Referenced by TIFFReadDirEntryByte(), and TIFFReadDirEntryByteArray().
◆ TIFFReadDirEntryCheckRangeLong8Sbyte()
|
static |
Definition at line 3848 of file tif_dirread.c.
3849{
3852 else
3854}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLong8Slong()
|
static |
Definition at line 3866 of file tif_dirread.c.
3867{
3870 else
3872}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLong8Slong8()
|
static |
Definition at line 3875 of file tif_dirread.c.
3876{
3879 else
3881}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLong8Sshort()
|
static |
Definition at line 3857 of file tif_dirread.c.
3858{
3861 else
3863}
Referenced by TIFFReadDirEntryLong8(), and TIFFReadDirEntryLong8ArrayWithLimit().
◆ TIFFReadDirEntryCheckRangeLongLong8()
|
static |
Definition at line 3801 of file tif_dirread.c.
3802{
3805 else
3807}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSbyte()
|
static |
Definition at line 3774 of file tif_dirread.c.
3775{
3778 else
3780}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSlong()
|
static |
Definition at line 3792 of file tif_dirread.c.
3793{
3796 else
3798}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSlong8()
|
static |
Definition at line 3810 of file tif_dirread.c.
3811{
3814 else
3816}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeLongSshort()
|
static |
Definition at line 3783 of file tif_dirread.c.
3784{
3787 else
3789}
Referenced by TIFFReadDirEntryLong(), and TIFFReadDirEntryLongArray().
◆ TIFFReadDirEntryCheckRangeSbyteByte()
|
static |
Definition at line 3612 of file tif_dirread.c.
3613{
3616 else
3618}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteLong()
|
static |
Definition at line 3639 of file tif_dirread.c.
3640{
3643 else
3645}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteLong8()
|
static |
Definition at line 3657 of file tif_dirread.c.
3658{
3661 else
3663}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteShort()
|
static |
Definition at line 3621 of file tif_dirread.c.
3622{
3625 else
3627}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteSlong()
|
static |
Definition at line 3648 of file tif_dirread.c.
3649{
3652 else
3654}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteSlong8()
|
static |
Definition at line 3666 of file tif_dirread.c.
3667{
3670 else
3672}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeSbyteSshort()
|
static |
Definition at line 3630 of file tif_dirread.c.
3631{
3634 else
3636}
Referenced by TIFFReadDirEntrySbyte(), and TIFFReadDirEntrySbyteArray().
◆ TIFFReadDirEntryCheckRangeShortLong()
|
static |
Definition at line 3693 of file tif_dirread.c.
3694{
3697 else
3699}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortLong8()
|
static |
Definition at line 3711 of file tif_dirread.c.
3712{
3715 else
3717}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSbyte()
|
static |
Definition at line 3675 of file tif_dirread.c.
3676{
3679 else
3681}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSlong()
|
static |
Definition at line 3702 of file tif_dirread.c.
3703{
3706 else
3708}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSlong8()
|
static |
Definition at line 3720 of file tif_dirread.c.
3721{
3724 else
3726}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeShortSshort()
|
static |
Definition at line 3684 of file tif_dirread.c.
3685{
3688 else
3690}
Referenced by TIFFReadDirEntryShort(), and TIFFReadDirEntryShortArray().
◆ TIFFReadDirEntryCheckRangeSlong8Long8()
|
static |
Definition at line 3884 of file tif_dirread.c.
3885{
3888 else
3890}
Referenced by TIFFReadDirEntrySlong8(), and TIFFReadDirEntrySlong8Array().
◆ TIFFReadDirEntryCheckRangeSlongLong()
|
static |
Definition at line 3819 of file tif_dirread.c.
3820{
3823 else
3825}
Referenced by TIFFReadDirEntrySlong(), and TIFFReadDirEntrySlongArray().
◆ TIFFReadDirEntryCheckRangeSlongLong8()
|
static |
Definition at line 3829 of file tif_dirread.c.
3830{
3833 else
3835}
Referenced by TIFFReadDirEntrySlong(), and TIFFReadDirEntrySlongArray().
◆ TIFFReadDirEntryCheckRangeSlongSlong8()
|
static |
Definition at line 3839 of file tif_dirread.c.
3840{
3843 else
3845}
Referenced by TIFFReadDirEntrySlong(), and TIFFReadDirEntrySlongArray().
◆ TIFFReadDirEntryCheckRangeSshortLong()
|
static |
Definition at line 3738 of file tif_dirread.c.
3739{
3742 else
3744}
Referenced by TIFFReadDirEntrySshort(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortLong8()
|
static |
Definition at line 3756 of file tif_dirread.c.
3757{
3760 else
3762}
Referenced by TIFFReadDirEntrySshort(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortShort()
|
static |
Definition at line 3729 of file tif_dirread.c.
3730{
3733 else
3735}
Referenced by TIFFReadDirEntrySshort(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortSlong()
|
static |
Definition at line 3747 of file tif_dirread.c.
3748{
3751 else
3753}
Referenced by TIFFReadDirEntrySshort(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryCheckRangeSshortSlong8()
|
static |
Definition at line 3765 of file tif_dirread.c.
3766{
3769 else
3771}
Referenced by TIFFReadDirEntrySshort(), and TIFFReadDirEntrySshortArray().
◆ TIFFReadDirEntryData()
|
static |
Definition at line 3892 of file tif_dirread.c.
3894{
3897 {
3902 }
3903 else
3904 {
3905 size_t ma, mb;
3908 {
3910 }
3911 mb = ma + size;
3915 }
3917}
Referenced by TIFFFetchSubjectDistance(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryCheckedDouble(), TIFFReadDirEntryCheckedLong8(), TIFFReadDirEntryCheckedRational(), TIFFReadDirEntryCheckedSlong8(), and TIFFReadDirEntryCheckedSrational().
◆ TIFFReadDirEntryDataAndRealloc()
|
static |
Definition at line 1191 of file tif_dirread.c.
1195{
1196#if SIZEOF_SIZE_T == 8
1198#endif
1199 tmsize_t already_read = 0;
1200
1202
1205
1206 /* On 64 bit processes, read first a maximum of 1 MB, then 10 MB, etc */
1207 /* so as to avoid allocating too much memory in case the file is too */
1208 /* short. We could ask for the file size, but this might be */
1209 /* expensive with some I/O layers (think of reading a gzipped file) */
1210 /* Restrict to 64 bit processes, so as to avoid reallocs() */
1211 /* on 32 bit processes where virtual memory is scarce. */
1213 {
1214 void *new_dest;
1215 tmsize_t bytes_read;
1217#if SIZEOF_SIZE_T == 8
1219 {
1220 to_read = threshold;
1221 threshold *= THRESHOLD_MULTIPLIER;
1222 }
1223#endif
1224
1225 new_dest =
1228 {
1230 "Failed to allocate memory for %s "
1234 already_read + to_read);
1236 }
1237 *pdest = new_dest;
1238
1240 already_read += bytes_read;
1242 {
1244 }
1245 }
1247}
Referenced by TIFFReadDirEntryArrayWithLimit().
◆ TIFFReadDirEntryDouble()
|
static |
Definition at line 1072 of file tif_dirread.c.
1073{
1078 {
1080 {
1085 }
1087 {
1092 }
1094 {
1099 }
1101 {
1106 }
1108 {
1113 }
1115 {
1120 }
1122 {
1129 }
1131 {
1138 }
1146 {
1151 }
1155 default:
1157 }
1158}
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:3429
static void TIFFReadDirEntryCheckedFloat(TIFF *tif, TIFFDirEntry *direntry, float *value)
Definition: tif_dirread.c:3504
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:3522
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF *tif, TIFFDirEntry *direntry, double *value)
Definition: tif_dirread.c:3396
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryDoubleArray()
|
static |
Definition at line 2988 of file tif_dirread.c.
2989{
2992 void *origdata;
2995 {
3008 break;
3009 default:
3011 }
3014 {
3015 *value = 0;
3017 }
3019 {
3026 }
3029 {
3030 _TIFFfreeExt(tif, origdata);
3032 }
3034 {
3036 {
3037 uint8_t *ma;
3038 double *mb;
3040 ma = (uint8_t *)origdata;
3041 mb = data;
3043 *mb++ = (double)(*ma++);
3044 }
3045 break;
3047 {
3048 int8_t *ma;
3049 double *mb;
3051 ma = (int8_t *)origdata;
3052 mb = data;
3054 *mb++ = (double)(*ma++);
3055 }
3056 break;
3058 {
3059 uint16_t *ma;
3060 double *mb;
3062 ma = (uint16_t *)origdata;
3063 mb = data;
3065 {
3067 TIFFSwabShort(ma);
3068 *mb++ = (double)(*ma++);
3069 }
3070 }
3071 break;
3073 {
3074 int16_t *ma;
3075 double *mb;
3077 ma = (int16_t *)origdata;
3078 mb = data;
3080 {
3083 *mb++ = (double)(*ma++);
3084 }
3085 }
3086 break;
3088 {
3089 uint32_t *ma;
3090 double *mb;
3092 ma = (uint32_t *)origdata;
3093 mb = data;
3095 {
3097 TIFFSwabLong(ma);
3098 *mb++ = (double)(*ma++);
3099 }
3100 }
3101 break;
3103 {
3104 int32_t *ma;
3105 double *mb;
3107 ma = (int32_t *)origdata;
3108 mb = data;
3110 {
3113 *mb++ = (double)(*ma++);
3114 }
3115 }
3116 break;
3118 {
3119 uint64_t *ma;
3120 double *mb;
3122 ma = (uint64_t *)origdata;
3123 mb = data;
3125 {
3127 TIFFSwabLong8(ma);
3128 *mb++ = (double)(*ma++);
3129 }
3130 }
3131 break;
3133 {
3134 int64_t *ma;
3135 double *mb;
3137 ma = (int64_t *)origdata;
3138 mb = data;
3140 {
3143 *mb++ = (double)(*ma++);
3144 }
3145 }
3146 break;
3148 {
3149 uint32_t *ma;
3150 uint32_t maa;
3151 uint32_t mab;
3152 double *mb;
3154 ma = (uint32_t *)origdata;
3155 mb = data;
3157 {
3159 TIFFSwabLong(ma);
3160 maa = *ma++;
3162 TIFFSwabLong(ma);
3163 mab = *ma++;
3164 if (mab == 0)
3165 *mb++ = 0.0;
3166 else
3168 }
3169 }
3170 break;
3172 {
3173 uint32_t *ma;
3174 int32_t maa;
3175 uint32_t mab;
3176 double *mb;
3178 ma = (uint32_t *)origdata;
3179 mb = data;
3181 {
3183 TIFFSwabLong(ma);
3184 maa = *(int32_t *)ma;
3185 ma++;
3187 TIFFSwabLong(ma);
3188 mab = *ma++;
3189 if (mab == 0)
3190 *mb++ = 0.0;
3191 else
3193 }
3194 }
3195 break;
3197 {
3198 float *ma;
3199 double *mb;
3204 ma = (float *)origdata;
3205 mb = data;
3207 *mb++ = (double)(*ma++);
3208 }
3209 break;
3210 }
3211 _TIFFfreeExt(tif, origdata);
3214}
void TIFFCvtIEEEFloatToNative(TIFF *, uint32_t, float *)
void TIFFCvtIEEEDoubleToNative(TIFF *, uint32_t, double *)
void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
Definition: tif_swab.c:138
Referenced by TIFFFetchNormalTag(), and TIFFReadDirectory().
◆ TIFFReadDirEntryFloat()
|
static |
Definition at line 967 of file tif_dirread.c.
968{
973 {
975 {
980 }
982 {
987 }
989 {
994 }
996 {
1001 }
1003 {
1008 }
1010 {
1015 }
1017 {
1024 }
1026 {
1033 }
1035 {
1042 }
1044 {
1051 }
1056 {
1065 }
1066 default:
1068 }
1069}
static float(__cdecl *square_half_float)(float x
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryFloatArray()
|
static |
Definition at line 2752 of file tif_dirread.c.
2753{
2756 void *origdata;
2759 {
2772 break;
2773 default:
2775 }
2778 {
2779 *value = 0;
2781 }
2783 {
2790 }
2793 {
2794 _TIFFfreeExt(tif, origdata);
2796 }
2798 {
2800 {
2801 uint8_t *ma;
2802 float *mb;
2804 ma = (uint8_t *)origdata;
2805 mb = data;
2807 *mb++ = (float)(*ma++);
2808 }
2809 break;
2811 {
2812 int8_t *ma;
2813 float *mb;
2815 ma = (int8_t *)origdata;
2816 mb = data;
2818 *mb++ = (float)(*ma++);
2819 }
2820 break;
2822 {
2823 uint16_t *ma;
2824 float *mb;
2826 ma = (uint16_t *)origdata;
2827 mb = data;
2829 {
2831 TIFFSwabShort(ma);
2832 *mb++ = (float)(*ma++);
2833 }
2834 }
2835 break;
2837 {
2838 int16_t *ma;
2839 float *mb;
2841 ma = (int16_t *)origdata;
2842 mb = data;
2844 {
2847 *mb++ = (float)(*ma++);
2848 }
2849 }
2850 break;
2852 {
2853 uint32_t *ma;
2854 float *mb;
2856 ma = (uint32_t *)origdata;
2857 mb = data;
2859 {
2861 TIFFSwabLong(ma);
2862 *mb++ = (float)(*ma++);
2863 }
2864 }
2865 break;
2867 {
2868 int32_t *ma;
2869 float *mb;
2871 ma = (int32_t *)origdata;
2872 mb = data;
2874 {
2877 *mb++ = (float)(*ma++);
2878 }
2879 }
2880 break;
2882 {
2883 uint64_t *ma;
2884 float *mb;
2886 ma = (uint64_t *)origdata;
2887 mb = data;
2889 {
2891 TIFFSwabLong8(ma);
2892 *mb++ = (float)(*ma++);
2893 }
2894 }
2895 break;
2897 {
2898 int64_t *ma;
2899 float *mb;
2901 ma = (int64_t *)origdata;
2902 mb = data;
2904 {
2907 *mb++ = (float)(*ma++);
2908 }
2909 }
2910 break;
2912 {
2913 uint32_t *ma;
2914 uint32_t maa;
2915 uint32_t mab;
2916 float *mb;
2918 ma = (uint32_t *)origdata;
2919 mb = data;
2921 {
2923 TIFFSwabLong(ma);
2924 maa = *ma++;
2926 TIFFSwabLong(ma);
2927 mab = *ma++;
2928 if (mab == 0)
2929 *mb++ = 0.0;
2930 else
2932 }
2933 }
2934 break;
2936 {
2937 uint32_t *ma;
2938 int32_t maa;
2939 uint32_t mab;
2940 float *mb;
2942 ma = (uint32_t *)origdata;
2943 mb = data;
2945 {
2947 TIFFSwabLong(ma);
2948 maa = *(int32_t *)ma;
2949 ma++;
2951 TIFFSwabLong(ma);
2952 mab = *ma++;
2953 if (mab == 0)
2954 *mb++ = 0.0;
2955 else
2957 }
2958 }
2959 break;
2961 {
2962 double *ma;
2963 float *mb;
2968 ma = (double *)origdata;
2969 mb = data;
2971 {
2978 }
2979 }
2980 break;
2981 }
2982 _TIFFfreeExt(tif, origdata);
2985}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryIfd8()
|
static |
Definition at line 1161 of file tif_dirread.c.
1162{
1167 {
1170 {
1175 }
1180 default:
1182 }
1183}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryIfd8Array()
|
static |
Definition at line 3217 of file tif_dirread.c.
3218{
3221 void *origdata;
3224 {
3229 break;
3230 default:
3232 }
3235 {
3236 *value = 0;
3238 }
3240 {
3247 }
3250 {
3251 _TIFFfreeExt(tif, origdata);
3253 }
3255 {
3258 {
3259 uint32_t *ma;
3260 uint64_t *mb;
3262 ma = (uint32_t *)origdata;
3263 mb = data;
3265 {
3267 TIFFSwabLong(ma);
3268 *mb++ = (uint64_t)(*ma++);
3269 }
3270 }
3271 break;
3272 }
3273 _TIFFfreeExt(tif, origdata);
3276}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong()
|
static |
Definition at line 656 of file tif_dirread.c.
657{
662 {
664 {
669 }
671 {
679 }
681 {
686 }
688 {
696 }
701 {
709 }
711 {
721 }
723 {
733 }
734 default:
736 }
737} /*-- TIFFReadDirEntryLong() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32_t value)
Definition: tif_dirread.c:3792
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8_t value)
Definition: tif_dirread.c:3774
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16_t value)
Definition: tif_dirread.c:3783
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongLong8(uint64_t value)
Definition: tif_dirread.c:3801
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong8(int64_t value)
Definition: tif_dirread.c:3810
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong8()
|
static |
Definition at line 818 of file tif_dirread.c.
819{
824 {
826 {
831 }
833 {
841 }
843 {
848 }
850 {
858 }
860 {
865 }
867 {
875 }
880 {
890 }
891 default:
893 }
894} /*-- TIFFReadDirEntryLong8() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sbyte(int8_t value)
Definition: tif_dirread.c:3848
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong8(int64_t value)
Definition: tif_dirread.c:3875
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong(int32_t value)
Definition: tif_dirread.c:3866
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sshort(int16_t value)
Definition: tif_dirread.c:3857
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong8Array()
|
static |
Definition at line 2594 of file tif_dirread.c.
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryLong8ArrayWithLimit()
|
static |
Definition at line 2425 of file tif_dirread.c.
2427{
2430 void *origdata;
2433 {
2442 break;
2443 default:
2445 }
2447 maxcount);
2449 {
2450 *value = 0;
2452 }
2454 {
2461 {
2466 {
2471 {
2472 _TIFFfreeExt(tif, origdata);
2474 }
2475 m++;
2476 }
2479 }
2480 }
2483 {
2484 _TIFFfreeExt(tif, origdata);
2486 }
2488 {
2490 {
2491 uint8_t *ma;
2492 uint64_t *mb;
2494 ma = (uint8_t *)origdata;
2495 mb = data;
2497 *mb++ = (uint64_t)(*ma++);
2498 }
2499 break;
2501 {
2502 int8_t *ma;
2503 uint64_t *mb;
2505 ma = (int8_t *)origdata;
2506 mb = data;
2508 {
2511 break;
2512 *mb++ = (uint64_t)(*ma++);
2513 }
2514 }
2515 break;
2517 {
2518 uint16_t *ma;
2519 uint64_t *mb;
2521 ma = (uint16_t *)origdata;
2522 mb = data;
2524 {
2526 TIFFSwabShort(ma);
2527 *mb++ = (uint64_t)(*ma++);
2528 }
2529 }
2530 break;
2532 {
2533 int16_t *ma;
2534 uint64_t *mb;
2536 ma = (int16_t *)origdata;
2537 mb = data;
2539 {
2544 break;
2545 *mb++ = (uint64_t)(*ma++);
2546 }
2547 }
2548 break;
2550 {
2551 uint32_t *ma;
2552 uint64_t *mb;
2554 ma = (uint32_t *)origdata;
2555 mb = data;
2557 {
2559 TIFFSwabLong(ma);
2560 *mb++ = (uint64_t)(*ma++);
2561 }
2562 }
2563 break;
2565 {
2566 int32_t *ma;
2567 uint64_t *mb;
2569 ma = (int32_t *)origdata;
2570 mb = data;
2572 {
2577 break;
2578 *mb++ = (uint64_t)(*ma++);
2579 }
2580 }
2581 break;
2582 }
2583 _TIFFfreeExt(tif, origdata);
2585 {
2588 }
2591}
Referenced by TIFFFetchStripThing(), and TIFFReadDirEntryLong8Array().
◆ TIFFReadDirEntryLongArray()
|
static |
Definition at line 2093 of file tif_dirread.c.
2094{
2097 void *origdata;
2100 {
2109 break;
2110 default:
2112 }
2115 {
2116 *value = 0;
2118 }
2120 {
2127 {
2132 {
2137 {
2138 _TIFFfreeExt(tif, origdata);
2140 }
2141 m++;
2142 }
2145 }
2146 }
2149 {
2150 _TIFFfreeExt(tif, origdata);
2152 }
2154 {
2156 {
2157 uint8_t *ma;
2158 uint32_t *mb;
2160 ma = (uint8_t *)origdata;
2161 mb = data;
2163 *mb++ = (uint32_t)(*ma++);
2164 }
2165 break;
2167 {
2168 int8_t *ma;
2169 uint32_t *mb;
2171 ma = (int8_t *)origdata;
2172 mb = data;
2174 {
2177 break;
2178 *mb++ = (uint32_t)(*ma++);
2179 }
2180 }
2181 break;
2183 {
2184 uint16_t *ma;
2185 uint32_t *mb;
2187 ma = (uint16_t *)origdata;
2188 mb = data;
2190 {
2192 TIFFSwabShort(ma);
2193 *mb++ = (uint32_t)(*ma++);
2194 }
2195 }
2196 break;
2198 {
2199 int16_t *ma;
2200 uint32_t *mb;
2202 ma = (int16_t *)origdata;
2203 mb = data;
2205 {
2210 break;
2211 *mb++ = (uint32_t)(*ma++);
2212 }
2213 }
2214 break;
2216 {
2217 uint64_t *ma;
2218 uint32_t *mb;
2220 ma = (uint64_t *)origdata;
2221 mb = data;
2223 {
2225 TIFFSwabLong8(ma);
2228 break;
2229 *mb++ = (uint32_t)(*ma++);
2230 }
2231 }
2232 break;
2234 {
2235 int64_t *ma;
2236 uint32_t *mb;
2238 ma = (int64_t *)origdata;
2239 mb = data;
2241 {
2246 break;
2247 *mb++ = (uint32_t)(*ma++);
2248 }
2249 }
2250 break;
2251 }
2252 _TIFFfreeExt(tif, origdata);
2254 {
2257 }
2260}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryOutputErr()
|
static |
Definition at line 3919 of file tif_dirread.c.
3922{
3923 if (!recover)
3924 {
3926 {
3929 tagname);
3930 break;
3933 tagname);
3934 break;
3937 tagname);
3938 break;
3941 tagname);
3942 break;
3944 TIFFErrorExtR(
3945 tif, module,
3946 "Cannot handle different values per sample for \"%s\"",
3947 tagname);
3948 break;
3951 "Sanity check on size of \"%s\" value failed",
3952 tagname);
3953 break;
3956 tagname);
3957 break;
3958 default:
3960 break;
3961 }
3962 }
3963 else
3964 {
3966 {
3969 "Incorrect count for \"%s\"; tag ignored",
3970 tagname);
3971 break;
3974 "Incompatible type for \"%s\"; tag ignored",
3975 tagname);
3976 break;
3978 TIFFWarningExtR(
3979 tif, module,
3981 break;
3984 "Incorrect value for \"%s\"; tag ignored",
3985 tagname);
3986 break;
3989 "Cannot handle different values per sample for "
3990 "\"%s\"; tag ignored",
3991 tagname);
3992 break;
3994 TIFFWarningExtR(
3995 tif, module,
3996 "Sanity check on size of \"%s\" value failed; tag ignored",
3997 tagname);
3998 break;
4001 "Out of memory reading of \"%s\"; tag ignored",
4002 tagname);
4003 break;
4004 default:
4006 break;
4007 }
4008 }
4009}
Referenced by TIFFFetchNormalTag(), TIFFFetchStripThing(), TIFFFetchSubjectDistance(), and TIFFReadDirectory().
◆ TIFFReadDirEntryPersampleShort()
|
static |
Definition at line 3279 of file tif_dirread.c.
3281{
3284 uint16_t *na;
3285 uint16_t nb;
3291 na = m;
3293 *value = *na++;
3294 nb--;
3295 while (nb > 0)
3296 {
3298 {
3300 break;
3301 }
3302 nb--;
3303 }
3306}
Referenced by TIFFReadDirectory().
◆ TIFFReadDirEntrySbyte()
|
static |
Definition at line 391 of file tif_dirread.c.
392{
397 {
400 field_readcount==1 */
401 {
409 }
411 {
414 }
416 {
424 }
426 {
434 }
436 {
444 }
446 {
454 }
456 {
466 }
468 {
478 }
479 default:
481 }
482} /*-- TIFFReadDirEntrySbyte() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16_t value)
Definition: tif_dirread.c:3630
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16_t value)
Definition: tif_dirread.c:3621
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32_t value)
Definition: tif_dirread.c:3639
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32_t value)
Definition: tif_dirread.c:3648
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64_t value)
Definition: tif_dirread.c:3657
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8_t value)
Definition: tif_dirread.c:3612
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64_t value)
Definition: tif_dirread.c:3666
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySbyteArray()
|
static |
Definition at line 1572 of file tif_dirread.c.
1573{
1576 void *origdata;
1579 {
1589 break;
1590 default:
1592 }
1595 {
1596 *value = 0;
1598 }
1600 {
1603 {
1608 {
1611 {
1612 _TIFFfreeExt(tif, origdata);
1614 }
1615 m++;
1616 }
1619 }
1623 }
1626 {
1627 _TIFFfreeExt(tif, origdata);
1629 }
1631 {
1633 {
1634 uint16_t *ma;
1635 int8_t *mb;
1637 ma = (uint16_t *)origdata;
1638 mb = data;
1640 {
1642 TIFFSwabShort(ma);
1645 break;
1646 *mb++ = (int8_t)(*ma++);
1647 }
1648 }
1649 break;
1651 {
1652 int16_t *ma;
1653 int8_t *mb;
1655 ma = (int16_t *)origdata;
1656 mb = data;
1658 {
1663 break;
1664 *mb++ = (int8_t)(*ma++);
1665 }
1666 }
1667 break;
1669 {
1670 uint32_t *ma;
1671 int8_t *mb;
1673 ma = (uint32_t *)origdata;
1674 mb = data;
1676 {
1678 TIFFSwabLong(ma);
1681 break;
1682 *mb++ = (int8_t)(*ma++);
1683 }
1684 }
1685 break;
1687 {
1688 int32_t *ma;
1689 int8_t *mb;
1691 ma = (int32_t *)origdata;
1692 mb = data;
1694 {
1699 break;
1700 *mb++ = (int8_t)(*ma++);
1701 }
1702 }
1703 break;
1705 {
1706 uint64_t *ma;
1707 int8_t *mb;
1709 ma = (uint64_t *)origdata;
1710 mb = data;
1712 {
1714 TIFFSwabLong8(ma);
1717 break;
1718 *mb++ = (int8_t)(*ma++);
1719 }
1720 }
1721 break;
1723 {
1724 int64_t *ma;
1725 int8_t *mb;
1727 ma = (int64_t *)origdata;
1728 mb = data;
1730 {
1735 break;
1736 *mb++ = (int8_t)(*ma++);
1737 }
1738 }
1739 break;
1740 }
1741 _TIFFfreeExt(tif, origdata);
1743 {
1746 }
1749}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntryShort()
|
static |
Definition at line 485 of file tif_dirread.c.
486{
491 {
493 {
498 }
500 {
508 }
513 {
521 }
523 {
531 }
533 {
541 }
543 {
553 }
555 {
565 }
566 default:
568 }
569} /*-- TIFFReadDirEntryShort() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32_t value)
Definition: tif_dirread.c:3693
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8_t value)
Definition: tif_dirread.c:3675
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16_t value)
Definition: tif_dirread.c:3684
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64_t value)
Definition: tif_dirread.c:3711
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32_t value)
Definition: tif_dirread.c:3702
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64_t value)
Definition: tif_dirread.c:3720
Referenced by TIFFFetchNormalTag(), and TIFFReadDirectory().
◆ TIFFReadDirEntryShortArray()
|
static |
Definition at line 1752 of file tif_dirread.c.
1753{
1756 void *origdata;
1759 {
1768 break;
1769 default:
1771 }
1774 {
1775 *value = 0;
1777 }
1779 {
1786 {
1791 {
1796 {
1797 _TIFFfreeExt(tif, origdata);
1799 }
1800 m++;
1801 }
1804 }
1805 }
1808 {
1809 _TIFFfreeExt(tif, origdata);
1811 }
1813 {
1815 {
1816 uint8_t *ma;
1817 uint16_t *mb;
1819 ma = (uint8_t *)origdata;
1820 mb = data;
1822 *mb++ = (uint16_t)(*ma++);
1823 }
1824 break;
1826 {
1827 int8_t *ma;
1828 uint16_t *mb;
1830 ma = (int8_t *)origdata;
1831 mb = data;
1833 {
1836 break;
1837 *mb++ = (uint16_t)(*ma++);
1838 }
1839 }
1840 break;
1842 {
1843 uint32_t *ma;
1844 uint16_t *mb;
1846 ma = (uint32_t *)origdata;
1847 mb = data;
1849 {
1851 TIFFSwabLong(ma);
1854 break;
1855 *mb++ = (uint16_t)(*ma++);
1856 }
1857 }
1858 break;
1860 {
1861 int32_t *ma;
1862 uint16_t *mb;
1864 ma = (int32_t *)origdata;
1865 mb = data;
1867 {
1872 break;
1873 *mb++ = (uint16_t)(*ma++);
1874 }
1875 }
1876 break;
1878 {
1879 uint64_t *ma;
1880 uint16_t *mb;
1882 ma = (uint64_t *)origdata;
1883 mb = data;
1885 {
1887 TIFFSwabLong8(ma);
1890 break;
1891 *mb++ = (uint16_t)(*ma++);
1892 }
1893 }
1894 break;
1896 {
1897 int64_t *ma;
1898 uint16_t *mb;
1900 ma = (int64_t *)origdata;
1901 mb = data;
1903 {
1908 break;
1909 *mb++ = (uint16_t)(*ma++);
1910 }
1911 }
1912 break;
1913 }
1914 _TIFFfreeExt(tif, origdata);
1916 {
1919 }
1922}
void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
Definition: tif_swab.c:81
Referenced by TIFFFetchNormalTag(), TIFFReadDirectory(), and TIFFReadDirEntryPersampleShort().
◆ TIFFReadDirEntrySlong()
|
static |
Definition at line 740 of file tif_dirread.c.
741{
746 {
748 {
753 }
755 {
760 }
762 {
767 }
769 {
774 }
776 {
784 }
789 {
799 }
801 {
811 }
812 default:
814 }
815} /*-- TIFFReadDirEntrySlong() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongSlong8(int64_t value)
Definition: tif_dirread.c:3839
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong(uint32_t value)
Definition: tif_dirread.c:3819
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong8(uint64_t value)
Definition: tif_dirread.c:3829
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySlong8()
|
static |
Definition at line 897 of file tif_dirread.c.
898{
903 {
905 {
910 }
912 {
917 }
919 {
924 }
926 {
931 }
933 {
938 }
940 {
945 }
947 {
957 }
961 default:
963 }
964} /*-- TIFFReadDirEntrySlong8() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlong8Long8(uint64_t value)
Definition: tif_dirread.c:3884
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySlong8Array()
|
static |
Definition at line 2601 of file tif_dirread.c.
2602{
2605 void *origdata;
2608 {
2617 break;
2618 default:
2620 }
2623 {
2624 *value = 0;
2626 }
2628 {
2630 {
2635 {
2640 {
2641 _TIFFfreeExt(tif, origdata);
2643 }
2644 m++;
2645 }
2648 }
2654 }
2657 {
2658 _TIFFfreeExt(tif, origdata);
2660 }
2662 {
2664 {
2665 uint8_t *ma;
2666 int64_t *mb;
2668 ma = (uint8_t *)origdata;
2669 mb = data;
2671 *mb++ = (int64_t)(*ma++);
2672 }
2673 break;
2675 {
2676 int8_t *ma;
2677 int64_t *mb;
2679 ma = (int8_t *)origdata;
2680 mb = data;
2682 *mb++ = (int64_t)(*ma++);
2683 }
2684 break;
2686 {
2687 uint16_t *ma;
2688 int64_t *mb;
2690 ma = (uint16_t *)origdata;
2691 mb = data;
2693 {
2695 TIFFSwabShort(ma);
2696 *mb++ = (int64_t)(*ma++);
2697 }
2698 }
2699 break;
2701 {
2702 int16_t *ma;
2703 int64_t *mb;
2705 ma = (int16_t *)origdata;
2706 mb = data;
2708 {
2711 *mb++ = (int64_t)(*ma++);
2712 }
2713 }
2714 break;
2716 {
2717 uint32_t *ma;
2718 int64_t *mb;
2720 ma = (uint32_t *)origdata;
2721 mb = data;
2723 {
2725 TIFFSwabLong(ma);
2726 *mb++ = (int64_t)(*ma++);
2727 }
2728 }
2729 break;
2731 {
2732 int32_t *ma;
2733 int64_t *mb;
2735 ma = (int32_t *)origdata;
2736 mb = data;
2738 {
2741 *mb++ = (int64_t)(*ma++);
2742 }
2743 }
2744 break;
2745 }
2746 _TIFFfreeExt(tif, origdata);
2749}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySlongArray()
|
static |
Definition at line 2263 of file tif_dirread.c.
2264{
2267 void *origdata;
2270 {
2279 break;
2280 default:
2282 }
2285 {
2286 *value = 0;
2288 }
2290 {
2292 {
2297 {
2302 {
2303 _TIFFfreeExt(tif, origdata);
2305 }
2306 m++;
2307 }
2310 }
2316 }
2319 {
2320 _TIFFfreeExt(tif, origdata);
2322 }
2324 {
2326 {
2327 uint8_t *ma;
2328 int32_t *mb;
2330 ma = (uint8_t *)origdata;
2331 mb = data;
2333 *mb++ = (int32_t)(*ma++);
2334 }
2335 break;
2337 {
2338 int8_t *ma;
2339 int32_t *mb;
2341 ma = (int8_t *)origdata;
2342 mb = data;
2344 *mb++ = (int32_t)(*ma++);
2345 }
2346 break;
2348 {
2349 uint16_t *ma;
2350 int32_t *mb;
2352 ma = (uint16_t *)origdata;
2353 mb = data;
2355 {
2357 TIFFSwabShort(ma);
2358 *mb++ = (int32_t)(*ma++);
2359 }
2360 }
2361 break;
2363 {
2364 int16_t *ma;
2365 int32_t *mb;
2367 ma = (int16_t *)origdata;
2368 mb = data;
2370 {
2373 *mb++ = (int32_t)(*ma++);
2374 }
2375 }
2376 break;
2378 {
2379 uint64_t *ma;
2380 int32_t *mb;
2382 ma = (uint64_t *)origdata;
2383 mb = data;
2385 {
2387 TIFFSwabLong8(ma);
2390 break;
2391 *mb++ = (int32_t)(*ma++);
2392 }
2393 }
2394 break;
2396 {
2397 int64_t *ma;
2398 int32_t *mb;
2400 ma = (int64_t *)origdata;
2401 mb = data;
2403 {
2408 break;
2409 *mb++ = (int32_t)(*ma++);
2410 }
2411 }
2412 break;
2413 }
2414 _TIFFfreeExt(tif, origdata);
2416 {
2419 }
2422}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySshort()
|
static |
Definition at line 572 of file tif_dirread.c.
573{
578 {
580 {
585 }
587 {
592 }
594 {
602 }
607 {
615 }
617 {
625 }
627 {
637 }
639 {
649 }
650 default:
652 }
653} /*-- TIFFReadDirEntrySshort() --*/
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32_t value)
Definition: tif_dirread.c:3738
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32_t value)
Definition: tif_dirread.c:3747
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64_t value)
Definition: tif_dirread.c:3765
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64_t value)
Definition: tif_dirread.c:3756
static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16_t value)
Definition: tif_dirread.c:3729
Referenced by TIFFFetchNormalTag().
◆ TIFFReadDirEntrySshortArray()
|
static |
Definition at line 1925 of file tif_dirread.c.
1926{
1929 void *origdata;
1932 {
1941 break;
1942 default:
1944 }
1947 {
1948 *value = 0;
1950 }
1952 {
1954 {
1959 {
1964 {
1965 _TIFFfreeExt(tif, origdata);
1967 }
1968 m++;
1969 }
1972 }
1978 }
1981 {
1982 _TIFFfreeExt(tif, origdata);
1984 }
1986 {
1988 {
1989 uint8_t *ma;
1990 int16_t *mb;
1992 ma = (uint8_t *)origdata;
1993 mb = data;
1995 *mb++ = (int16_t)(*ma++);
1996 }
1997 break;
1999 {
2000 int8_t *ma;
2001 int16_t *mb;
2003 ma = (int8_t *)origdata;
2004 mb = data;
2006 *mb++ = (int16_t)(*ma++);
2007 }
2008 break;
2010 {
2011 uint32_t *ma;
2012 int16_t *mb;
2014 ma = (uint32_t *)origdata;
2015 mb = data;
2017 {
2019 TIFFSwabLong(ma);
2022 break;
2023 *mb++ = (int16_t)(*ma++);
2024 }
2025 }
2026 break;
2028 {
2029 int32_t *ma;
2030 int16_t *mb;
2032 ma = (int32_t *)origdata;
2033 mb = data;
2035 {
2040 break;
2041 *mb++ = (int16_t)(*ma++);
2042 }
2043 }
2044 break;
2046 {
2047 uint64_t *ma;
2048 int16_t *mb;
2050 ma = (uint64_t *)origdata;
2051 mb = data;
2053 {
2055 TIFFSwabLong8(ma);
2058 break;
2059 *mb++ = (int16_t)(*ma++);
2060 }
2061 }
2062 break;
2064 {
2065 int64_t *ma;
2066 int16_t *mb;
2068 ma = (int64_t *)origdata;
2069 mb = data;
2071 {
2076 break;
2077 *mb++ = (int16_t)(*ma++);
2078 }
2079 }
2080 break;
2081 }
2082 _TIFFfreeExt(tif, origdata);
2084 {
2087 }
2090}
Referenced by TIFFFetchNormalTag().
◆ TIFFReadEXIFDirectory()
Definition at line 5462 of file tif_dirread.c.
5463{
5465}
int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff, const TIFFFieldArray *infoarray)
Definition: tif_dirread.c:5278
◆ TIFFReadGPSDirectory()
Definition at line 5470 of file tif_dirread.c.
5471{
5473}
◆ TIFFReadUInt64()
◆ TryChopUpUncompressedBigTiff()
Definition at line 7937 of file tif_dirread.c.
7938{
7940 uint32_t rowblock;
7941 uint64_t rowblockbytes;
7943 uint64_t stripsize;
7944 uint32_t rowblocksperstrip;
7945 uint32_t rowsperstrip;
7946 uint64_t stripbytes;
7947 uint32_t nstrips;
7948
7949 stripsize = TIFFStripSize64(tif);
7950
7954 TIFF_STRIPCHOP);
7955 assert(stripsize > 0x7FFFFFFFUL);
7956
7957 /* On a newly created file, just re-opened to be filled, we */
7958 /* don't want strip chop to trigger as it is going to cause issues */
7959 /* later ( StripOffsets and StripByteCounts improperly filled) . */
7961 return;
7962
7964 rowblock = td->td_ycbcrsubsampling[1];
7965 else
7966 rowblock = 1;
7967 rowblockbytes = TIFFVStripSize64(tif, rowblock);
7968 if (rowblockbytes == 0 || rowblockbytes > 0x7FFFFFFFUL)
7969 {
7970 /* In case of file with gigantic width */
7971 return;
7972 }
7973
7974 /* Check that the strips are contiguous and of the expected size */
7976 {
7978 {
7980 TIFFVStripSize64(tif,
7982 {
7983 return;
7984 }
7985 }
7986 else
7987 {
7989 {
7990 return;
7991 }
7995 {
7996 return;
7997 }
7998 }
7999 }
8000
8001 /* Aim for 512 MB strips (that will still be manageable by 32 bit builds */
8002 rowblocksperstrip = (uint32_t)(512 * 1024 * 1024 / rowblockbytes);
8003 if (rowblocksperstrip == 0)
8004 rowblocksperstrip = 1;
8005 rowsperstrip = rowblocksperstrip * rowblock;
8006 stripbytes = rowblocksperstrip * rowblockbytes;
8007 assert(stripbytes <= 0x7FFFFFFFUL);
8008
8009 if (rowsperstrip == 0)
8010 return;
8012 if (nstrips == 0)
8013 return;
8014
8015 /* If we are going to allocate a lot of memory, make sure that the */
8016 /* file is as big as needed */
8018 {
8021 uint64_t last_bytecount =
8023 if (last_offset > filesize || last_bytecount > filesize - last_offset)
8024 {
8025 return;
8026 }
8027 }
8028
8029 allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
8030}
Referenced by TIFFReadDirectory().
