diff options
Diffstat (limited to 'tiff/libtiff/tif_dirread.c')
-rw-r--r-- | tiff/libtiff/tif_dirread.c | 2034 |
1 files changed, 1017 insertions, 1017 deletions
diff --git a/tiff/libtiff/tif_dirread.c b/tiff/libtiff/tif_dirread.c index ba127ca9..d84147a0 100644 --- a/tiff/libtiff/tif_dirread.c +++ b/tiff/libtiff/tif_dirread.c @@ -34,23 +34,19 @@ * TIFFReadDirectory, so as to eliminate current possibly repetitive lookup. */ +#include "tiffconf.h" #include "tiffiop.h" #include <float.h> #include <stdlib.h> -#define FAILED_FII ((uint32) -1) - -/* - * Largest 64-bit signed integer value. - */ -#define TIFF_INT64_MAX ((int64)(TIFF_UINT64_MAX >> 1)) +#define FAILED_FII ((uint32_t) -1) #ifdef HAVE_IEEEFP # define TIFFCvtIEEEFloatToNative(tif, n, fp) # define TIFFCvtIEEEDoubleToNative(tif, n, dp) #else -extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*); -extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*); +extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32_t, float*); +extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32_t, double*); #endif enum TIFFReadDirEntryErr { @@ -64,126 +60,126 @@ enum TIFFReadDirEntryErr { TIFFReadDirEntryErrAlloc = 7, }; -static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8_t* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16_t* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32_t* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64_t* value); static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value); static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, void** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64_t* value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32_t* count, uint32_t desttypesize, void** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64_t** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64_t** value); static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEntry* direntry, float** value); static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64_t** value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16_t* value); #if 0 static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFDirEntry* direntry, double* value); #endif -static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value); -static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8* value); -static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value); -static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16* value); -static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value); -static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64* value); +static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8_t* value); +static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8_t* value); +static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16_t* value); +static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16_t* value); +static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32_t* value); +static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32_t* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64_t* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64_t* value); static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF* tif, TIFFDirEntry* direntry, double* value); static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF* tif, TIFFDirEntry* direntry, double* value); static void TIFFReadDirEntryCheckedFloat(TIFF* tif, TIFFDirEntry* direntry, float* value); static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF* tif, TIFFDirEntry* direntry, double* value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongLong8(uint64 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong(uint32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong8(uint64 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongSlong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sshort(int16 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong(int32 value); -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong8(int64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlong8Long8(uint64 value); - -static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF* tif, uint64 offset, tmsize_t size, void* dest); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongLong8(uint64_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong(uint32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong8(uint64_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongSlong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sbyte(int8_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sshort(int16_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong(int32_t value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong8(int64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlong8Long8(uint64_t value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF* tif, uint64_t offset, tmsize_t size, void* dest); static void TIFFReadDirEntryOutputErr(TIFF* tif, enum TIFFReadDirEntryErr err, const char* module, const char* tagname, int recover); -static void TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16 dircount); -static TIFFDirEntry* TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16 dircount, uint16 tagid); -static void TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii); +static void TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16_t dircount); +static TIFFDirEntry* TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16_t dircount, uint16_t tagid); +static void TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16_t tagid, uint32_t* fii); -static int EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount); +static int EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16_t dircount); static void MissingRequired(TIFF*, const char*); -static int TIFFCheckDirOffset(TIFF* tif, uint64 diroff); -static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32); -static uint16 TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, uint64* nextdiroff); +static int TIFFCheckDirOffset(TIFF* tif, uint64_t diroff); +static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32_t); +static uint16_t TIFFFetchDirectory(TIFF* tif, uint64_t diroff, TIFFDirEntry** pdir, uint64_t* nextdiroff); static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*, int recover); -static int TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp); +static int TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32_t nstrips, uint64_t** lpp); static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*); static void ChopUpSingleUncompressedStrip(TIFF*); static void TryChopUpUncompressedBigTiff(TIFF*); -static uint64 TIFFReadUInt64(const uint8 *value); -static int _TIFFGetMaxColorChannels(uint16 photometric); +static uint64_t TIFFReadUInt64(const uint8_t *value); +static int _TIFFGetMaxColorChannels(uint16_t photometric); static int _TIFFFillStrilesInternal( TIFF *tif, int loadStripByteCount ); typedef union _UInt64Aligned_t { double d; - uint64 l; - uint32 i[2]; - uint16 s[4]; - uint8 c[8]; + uint64_t l; + uint32_t i[2]; + uint16_t s[4]; + uint8_t c[8]; } UInt64Aligned_t; /* - Unaligned safe copy of a uint64 value from an octet array. + Unaligned safe copy of a uint64_t value from an octet array. */ -static uint64 TIFFReadUInt64(const uint8 *value) +static uint64_t TIFFReadUInt64(const uint8_t *value) { UInt64Aligned_t result; @@ -199,7 +195,7 @@ static uint64 TIFFReadUInt64(const uint8 *value) return result.l; } -static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8_t* value) { enum TIFFReadDirEntryErr err; if (direntry->tdir_count!=1) @@ -212,76 +208,76 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* di return(TIFFReadDirEntryErrOk); case TIFF_SBYTE: { - int8 m; + int8_t m; TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeByteSbyte(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SHORT: { - uint16 m; + uint16_t m; TIFFReadDirEntryCheckedShort(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeByteShort(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SSHORT: { - int16 m; + int16_t m; TIFFReadDirEntryCheckedSshort(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeByteSshort(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG: { - uint32 m; + uint32_t m; TIFFReadDirEntryCheckedLong(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeByteLong(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG: { - int32 m; + int32_t m; TIFFReadDirEntryCheckedSlong(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeByteSlong(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: { - uint64 m; + uint64_t m; err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeByteLong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG8: { - int64 m; + int64_t m; err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeByteSlong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint8)m; + *value=(uint8_t)m; return(TIFFReadDirEntryErrOk); } default: @@ -289,7 +285,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* di } } -static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16_t* value) { enum TIFFReadDirEntryErr err; if (direntry->tdir_count!=1) @@ -298,19 +294,19 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* d { case TIFF_BYTE: { - uint8 m; + uint8_t m; TIFFReadDirEntryCheckedByte(tif,direntry,&m); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SBYTE: { - int8 m; + int8_t m; TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeShortSbyte(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SHORT: @@ -318,56 +314,56 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* d return(TIFFReadDirEntryErrOk); case TIFF_SSHORT: { - int16 m; + int16_t m; TIFFReadDirEntryCheckedSshort(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeShortSshort(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG: { - uint32 m; + uint32_t m; TIFFReadDirEntryCheckedLong(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeShortLong(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG: { - int32 m; + int32_t m; TIFFReadDirEntryCheckedSlong(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeShortSlong(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: { - uint64 m; + uint64_t m; err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeShortLong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG8: { - int64 m; + int64_t m; err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeShortSlong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint16)m; + *value=(uint16_t)m; return(TIFFReadDirEntryErrOk); } default: @@ -375,7 +371,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* d } } -static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32_t* value) { enum TIFFReadDirEntryErr err; if (direntry->tdir_count!=1) @@ -384,36 +380,36 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* di { case TIFF_BYTE: { - uint8 m; + uint8_t m; TIFFReadDirEntryCheckedByte(tif,direntry,&m); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SBYTE: { - int8 m; + int8_t m; TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeLongSbyte(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SHORT: { - uint16 m; + uint16_t m; TIFFReadDirEntryCheckedShort(tif,direntry,&m); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SSHORT: { - int16 m; + int16_t m; TIFFReadDirEntryCheckedSshort(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeLongSshort(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG: @@ -421,36 +417,36 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* di return(TIFFReadDirEntryErrOk); case TIFF_SLONG: { - int32 m; + int32_t m; TIFFReadDirEntryCheckedSlong(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeLongSlong(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: { - uint64 m; + uint64_t m; err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeLongLong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG8: { - int64 m; + int64_t m; err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeLongSlong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint32)m; + *value=(uint32_t)m; return(TIFFReadDirEntryErrOk); } default: @@ -458,7 +454,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* di } } -static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64_t* value) { enum TIFFReadDirEntryErr err; if (direntry->tdir_count!=1) @@ -467,53 +463,53 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* d { case TIFF_BYTE: { - uint8 m; + uint8_t m; TIFFReadDirEntryCheckedByte(tif,direntry,&m); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SBYTE: { - int8 m; + int8_t m; TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeLong8Sbyte(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SHORT: { - uint16 m; + uint16_t m; TIFFReadDirEntryCheckedShort(tif,direntry,&m); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SSHORT: { - int16 m; + int16_t m; TIFFReadDirEntryCheckedSshort(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeLong8Sshort(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG: { - uint32 m; + uint32_t m; TIFFReadDirEntryCheckedLong(tif,direntry,&m); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG: { - int32 m; + int32_t m; TIFFReadDirEntryCheckedSlong(tif,direntry,&m); err=TIFFReadDirEntryCheckRangeLong8Slong(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: @@ -521,14 +517,14 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* d return(err); case TIFF_SLONG8: { - int64 m; + int64_t m; err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); err=TIFFReadDirEntryCheckRangeLong8Slong8(m); if (err!=TIFFReadDirEntryErrOk) return(err); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } default: @@ -545,49 +541,49 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* d { case TIFF_BYTE: { - uint8 m; + uint8_t m; TIFFReadDirEntryCheckedByte(tif,direntry,&m); *value=(float)m; return(TIFFReadDirEntryErrOk); } case TIFF_SBYTE: { - int8 m; + int8_t m; TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); *value=(float)m; return(TIFFReadDirEntryErrOk); } case TIFF_SHORT: { - uint16 m; + uint16_t m; TIFFReadDirEntryCheckedShort(tif,direntry,&m); *value=(float)m; return(TIFFReadDirEntryErrOk); } case TIFF_SSHORT: { - int16 m; + int16_t m; TIFFReadDirEntryCheckedSshort(tif,direntry,&m); *value=(float)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG: { - uint32 m; + uint32_t m; TIFFReadDirEntryCheckedLong(tif,direntry,&m); *value=(float)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG: { - int32 m; + int32_t m; TIFFReadDirEntryCheckedSlong(tif,direntry,&m); *value=(float)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: { - uint64 m; + uint64_t m; err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); @@ -605,7 +601,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* d } case TIFF_SLONG8: { - int64 m; + int64_t m; err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); @@ -658,49 +654,49 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* { case TIFF_BYTE: { - uint8 m; + uint8_t m; TIFFReadDirEntryCheckedByte(tif,direntry,&m); *value=(double)m; return(TIFFReadDirEntryErrOk); } case TIFF_SBYTE: { - int8 m; + int8_t m; TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); *value=(double)m; return(TIFFReadDirEntryErrOk); } case TIFF_SHORT: { - uint16 m; + uint16_t m; TIFFReadDirEntryCheckedShort(tif,direntry,&m); *value=(double)m; return(TIFFReadDirEntryErrOk); } case TIFF_SSHORT: { - int16 m; + int16_t m; TIFFReadDirEntryCheckedSshort(tif,direntry,&m); *value=(double)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG: { - uint32 m; + uint32_t m; TIFFReadDirEntryCheckedLong(tif,direntry,&m); *value=(double)m; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG: { - int32 m; + int32_t m; TIFFReadDirEntryCheckedSlong(tif,direntry,&m); *value=(double)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: { - uint64 m; + uint64_t m; err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); @@ -718,7 +714,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* } case TIFF_SLONG8: { - int64 m; + int64_t m; err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) return(err); @@ -746,7 +742,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* } } -static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64_t* value) { enum TIFFReadDirEntryErr err; if (direntry->tdir_count!=1) @@ -756,9 +752,9 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* di case TIFF_LONG: case TIFF_IFD: { - uint32 m; + uint32_t m; TIFFReadDirEntryCheckedLong(tif,direntry,&m); - *value=(uint64)m; + *value=(uint64_t)m; return(TIFFReadDirEntryErrOk); } case TIFF_LONG8: @@ -776,7 +772,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* di #define MAX_THRESHOLD (THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * INITIAL_THRESHOLD) static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc( - TIFF* tif, uint64 offset, tmsize_t size, void** pdest) + TIFF* tif, uint64_t offset, tmsize_t size, void** pdest) { #if SIZEOF_SIZE_T == 8 tmsize_t threshold = INITIAL_THRESHOLD; @@ -807,15 +803,15 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc( } #endif - new_dest = (uint8*) _TIFFrealloc( + new_dest = (uint8_t*) _TIFFrealloc( *pdest, already_read + to_read); if( new_dest == NULL ) { TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Failed to allocate memory for %s " - "(%ld elements of %ld bytes each)", + "(%"TIFF_SSIZE_FORMAT" elements of %"TIFF_SSIZE_FORMAT" bytes each)", "TIFFReadDirEntryArray", - (long) 1, (long) (already_read + to_read)); + (tmsize_t) 1, already_read + to_read); return TIFFReadDirEntryErrAlloc; } *pdest = new_dest; @@ -831,13 +827,13 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc( } static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit( - TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, - void** value, uint64 maxcount) + TIFF* tif, TIFFDirEntry* direntry, uint32_t* count, uint32_t desttypesize, + void** value, uint64_t maxcount) { int typesize; - uint32 datasize; + uint32_t datasize; void* data; - uint64 target_count64; + uint64_t target_count64; int original_datasize_clamped; typesize=TIFFDataWidth(direntry->tdir_type); @@ -862,16 +858,16 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit( * in either the current data type or the dest data type. This also * avoids problems with overflow of tmsize_t on 32bit systems. */ - if ((uint64)(2147483647/typesize)<target_count64) + if ((uint64_t)(2147483647 / typesize) < target_count64) return(TIFFReadDirEntryErrSizesan); - if ((uint64)(2147483647/desttypesize)<target_count64) + if ((uint64_t)(2147483647 / desttypesize) < target_count64) return(TIFFReadDirEntryErrSizesan); - *count=(uint32)target_count64; + *count=(uint32_t)target_count64; datasize=(*count)*typesize; assert((tmsize_t)datasize>0); - if( isMapped(tif) && datasize > (uint64)tif->tif_size ) + if( isMapped(tif) && datasize > (uint64_t)tif->tif_size ) return TIFFReadDirEntryErrIo; if( !isMapped(tif) && @@ -888,18 +884,20 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit( } if (!(tif->tif_flags&TIFF_BIGTIFF)) { - if (original_datasize_clamped<=4) + /* Only the condition on original_datasize_clamped. The second + * one is implied, but Coverity Scan cannot see it. */ + if (original_datasize_clamped<=4 && datasize <= 4 ) _TIFFmemcpy(data,&direntry->tdir_offset,datasize); else { enum TIFFReadDirEntryErr err; - uint32 offset = direntry->tdir_offset.toff_long; + uint32_t offset = direntry->tdir_offset.toff_long; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); if( isMapped(tif) ) - err=TIFFReadDirEntryData(tif,(uint64)offset,(tmsize_t)datasize,data); + err=TIFFReadDirEntryData(tif, (uint64_t)offset, (tmsize_t)datasize, data); else - err=TIFFReadDirEntryDataAndRealloc(tif,(uint64)offset,(tmsize_t)datasize,&data); + err=TIFFReadDirEntryDataAndRealloc(tif, (uint64_t)offset, (tmsize_t)datasize, &data); if (err!=TIFFReadDirEntryErrOk) { _TIFFfree(data); @@ -909,18 +907,19 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit( } else { - if (original_datasize_clamped<=8) + /* See above comment for the Classic TIFF case */ + if (original_datasize_clamped<=8 && datasize <= 8 ) _TIFFmemcpy(data,&direntry->tdir_offset,datasize); else { enum TIFFReadDirEntryErr err; - uint64 offset = direntry->tdir_offset.toff_long8; + uint64_t offset = direntry->tdir_offset.toff_long8; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong8(&offset); if( isMapped(tif) ) - err=TIFFReadDirEntryData(tif,(uint64)offset,(tmsize_t)datasize,data); + err=TIFFReadDirEntryData(tif, (uint64_t)offset, (tmsize_t)datasize, data); else - err=TIFFReadDirEntryDataAndRealloc(tif,(uint64)offset,(tmsize_t)datasize,&data); + err=TIFFReadDirEntryDataAndRealloc(tif, (uint64_t)offset, (tmsize_t)datasize, &data); if (err!=TIFFReadDirEntryErrOk) { _TIFFfree(data); @@ -932,18 +931,18 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryArrayWithLimit( return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, void** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32_t* count, uint32_t desttypesize, void** value) { return TIFFReadDirEntryArrayWithLimit(tif, direntry, count, - desttypesize, value, ~((uint64)0)); + desttypesize, value, ~((uint64_t)0)); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - uint8* data; + uint8_t* data; switch (direntry->tdir_type) { case TIFF_ASCII: @@ -971,13 +970,13 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr case TIFF_ASCII: case TIFF_UNDEFINED: case TIFF_BYTE: - *value=(uint8*)origdata; + *value=(uint8_t*)origdata; return(TIFFReadDirEntryErrOk); case TIFF_SBYTE: { - int8* m; - uint32 n; - m=(int8*)origdata; + int8_t* m; + uint32_t n; + m=(int8_t*)origdata; for (n=0; n<count; n++) { err=TIFFReadDirEntryCheckRangeByteSbyte(*m); @@ -988,11 +987,11 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr } m++; } - *value=(uint8*)origdata; + *value=(uint8_t*)origdata; return(TIFFReadDirEntryErrOk); } } - data=(uint8*)_TIFFmalloc(count); + data=(uint8_t*)_TIFFmalloc(count); if (data==0) { _TIFFfree(origdata); @@ -1002,10 +1001,10 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr { case TIFF_SHORT: { - uint16* ma; - uint8* mb; - uint32 n; - ma=(uint16*)origdata; + uint16_t* ma; + uint8_t* mb; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1014,34 +1013,34 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr err=TIFFReadDirEntryCheckRangeByteShort(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint8)(*ma++); + *mb++=(uint8_t)(*ma++); } } break; case TIFF_SSHORT: { - int16* ma; - uint8* mb; - uint32 n; - ma=(int16*)origdata; + int16_t* ma; + uint8_t* mb; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); + TIFFSwabShort((uint16_t*)ma); err=TIFFReadDirEntryCheckRangeByteSshort(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint8)(*ma++); + *mb++=(uint8_t)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; - uint8* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + uint8_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1050,34 +1049,34 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr err=TIFFReadDirEntryCheckRangeByteLong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint8)(*ma++); + *mb++=(uint8_t)(*ma++); } } break; case TIFF_SLONG: { - int32* ma; - uint8* mb; - uint32 n; - ma=(int32*)origdata; + int32_t* ma; + uint8_t* mb; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); err=TIFFReadDirEntryCheckRangeByteSlong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint8)(*ma++); + *mb++=(uint8_t)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; - uint8* mb; - uint32 n; - ma=(uint64*)origdata; + uint64_t* ma; + uint8_t* mb; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1086,25 +1085,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr err=TIFFReadDirEntryCheckRangeByteLong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint8)(*ma++); + *mb++=(uint8_t)(*ma++); } } break; case TIFF_SLONG8: { - int64* ma; - uint8* mb; - uint32 n; - ma=(int64*)origdata; + int64_t* ma; + uint8_t* mb; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); err=TIFFReadDirEntryCheckRangeByteSlong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint8)(*ma++); + *mb++=(uint8_t)(*ma++); } } break; @@ -1119,12 +1118,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntr return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - int8* data; + int8_t* data; switch (direntry->tdir_type) { case TIFF_UNDEFINED: @@ -1151,9 +1150,9 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt case TIFF_UNDEFINED: case TIFF_BYTE: { - uint8* m; - uint32 n; - m=(uint8*)origdata; + uint8_t* m; + uint32_t n; + m=(uint8_t*)origdata; for (n=0; n<count; n++) { err=TIFFReadDirEntryCheckRangeSbyteByte(*m); @@ -1164,14 +1163,14 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt } m++; } - *value=(int8*)origdata; + *value=(int8_t*)origdata; return(TIFFReadDirEntryErrOk); } case TIFF_SBYTE: - *value=(int8*)origdata; + *value=(int8_t*)origdata; return(TIFFReadDirEntryErrOk); } - data=(int8*)_TIFFmalloc(count); + data=(int8_t*)_TIFFmalloc(count); if (data==0) { _TIFFfree(origdata); @@ -1181,10 +1180,10 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt { case TIFF_SHORT: { - uint16* ma; - int8* mb; - uint32 n; - ma=(uint16*)origdata; + uint16_t* ma; + int8_t* mb; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1193,34 +1192,34 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt err=TIFFReadDirEntryCheckRangeSbyteShort(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int8)(*ma++); + *mb++=(int8_t)(*ma++); } } break; case TIFF_SSHORT: { - int16* ma; - int8* mb; - uint32 n; - ma=(int16*)origdata; + int16_t* ma; + int8_t* mb; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); + TIFFSwabShort((uint16_t*)ma); err=TIFFReadDirEntryCheckRangeSbyteSshort(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int8)(*ma++); + *mb++=(int8_t)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; - int8* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + int8_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1229,34 +1228,34 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt err=TIFFReadDirEntryCheckRangeSbyteLong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int8)(*ma++); + *mb++=(int8_t)(*ma++); } } break; case TIFF_SLONG: { - int32* ma; - int8* mb; - uint32 n; - ma=(int32*)origdata; + int32_t* ma; + int8_t* mb; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); err=TIFFReadDirEntryCheckRangeSbyteSlong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int8)(*ma++); + *mb++=(int8_t)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; - int8* mb; - uint32 n; - ma=(uint64*)origdata; + uint64_t* ma; + int8_t* mb; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1265,25 +1264,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt err=TIFFReadDirEntryCheckRangeSbyteLong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int8)(*ma++); + *mb++=(int8_t)(*ma++); } } break; case TIFF_SLONG8: { - int64* ma; - int8* mb; - uint32 n; - ma=(int64*)origdata; + int64_t* ma; + int8_t* mb; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); err=TIFFReadDirEntryCheckRangeSbyteSlong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int8)(*ma++); + *mb++=(int8_t)(*ma++); } } break; @@ -1298,12 +1297,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEnt return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - uint16* data; + uint16_t* data; switch (direntry->tdir_type) { case TIFF_BYTE: @@ -1327,19 +1326,19 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEnt switch (direntry->tdir_type) { case TIFF_SHORT: - *value=(uint16*)origdata; + *value=(uint16_t*)origdata; if (tif->tif_flags&TIFF_SWAB) TIFFSwabArrayOfShort(*value,count); return(TIFFReadDirEntryErrOk); case TIFF_SSHORT: { - int16* m; - uint32 n; - m=(int16*)origdata; + int16_t* m; + uint32_t n; + m=(int16_t*)origdata; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)m); + TIFFSwabShort((uint16_t*)m); err=TIFFReadDirEntryCheckRangeShortSshort(*m); if (err!=TIFFReadDirEntryErrOk) { @@ -1348,11 +1347,11 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEnt } m++; } - *value=(uint16*)origdata; + *value=(uint16_t*)origdata; return(TIFFReadDirEntryErrOk); } } - data=(uint16*)_TIFFmalloc(count*2); + data=(uint16_t*)_TIFFmalloc(count * 2); if (data==0) { _TIFFfree(origdata); @@ -1362,37 +1361,37 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEnt { case TIFF_BYTE: { - uint8* ma; - uint16* mb; - uint32 n; - ma=(uint8*)origdata; + uint8_t* ma; + uint16_t* mb; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(uint16)(*ma++); + *mb++=(uint16_t)(*ma++); } break; case TIFF_SBYTE: { - int8* ma; - uint16* mb; - uint32 n; - ma=(int8*)origdata; + int8_t* ma; + uint16_t* mb; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) { err=TIFFReadDirEntryCheckRangeShortSbyte(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint16)(*ma++); + *mb++=(uint16_t)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; - uint16* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + uint16_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1401,34 +1400,34 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEnt err=TIFFReadDirEntryCheckRangeShortLong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint16)(*ma++); + *mb++=(uint16_t)(*ma++); } } break; case TIFF_SLONG: { - int32* ma; - uint16* mb; - uint32 n; - ma=(int32*)origdata; + int32_t* ma; + uint16_t* mb; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); err=TIFFReadDirEntryCheckRangeShortSlong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint16)(*ma++); + *mb++=(uint16_t)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; - uint16* mb; - uint32 n; - ma=(uint64*)origdata; + uint64_t* ma; + uint16_t* mb; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1437,25 +1436,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEnt err=TIFFReadDirEntryCheckRangeShortLong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint16)(*ma++); + *mb++=(uint16_t)(*ma++); } } break; case TIFF_SLONG8: { - int64* ma; - uint16* mb; - uint32 n; - ma=(int64*)origdata; + int64_t* ma; + uint16_t* mb; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); err=TIFFReadDirEntryCheckRangeShortSlong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint16)(*ma++); + *mb++=(uint16_t)(*ma++); } } break; @@ -1470,12 +1469,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEnt return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - int16* data; + int16_t* data; switch (direntry->tdir_type) { case TIFF_BYTE: @@ -1500,9 +1499,9 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEn { case TIFF_SHORT: { - uint16* m; - uint32 n; - m=(uint16*)origdata; + uint16_t* m; + uint32_t n; + m=(uint16_t*)origdata; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) @@ -1515,16 +1514,16 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEn } m++; } - *value=(int16*)origdata; + *value=(int16_t*)origdata; return(TIFFReadDirEntryErrOk); } case TIFF_SSHORT: - *value=(int16*)origdata; + *value=(int16_t*)origdata; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfShort((uint16*)(*value),count); + TIFFSwabArrayOfShort((uint16_t*)(*value), count); return(TIFFReadDirEntryErrOk); } - data=(int16*)_TIFFmalloc(count*2); + data=(int16_t*)_TIFFmalloc(count * 2); if (data==0) { _TIFFfree(origdata); @@ -1534,32 +1533,32 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEn { case TIFF_BYTE: { - uint8* ma; - int16* mb; - uint32 n; - ma=(uint8*)origdata; + uint8_t* ma; + int16_t* mb; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(int16)(*ma++); + *mb++=(int16_t)(*ma++); } break; case TIFF_SBYTE: { - int8* ma; - int16* mb; - uint32 n; - ma=(int8*)origdata; + int8_t* ma; + int16_t* mb; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(int16)(*ma++); + *mb++=(int16_t)(*ma++); } break; case TIFF_LONG: { - uint32* ma; - int16* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + int16_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1568,34 +1567,34 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEn err=TIFFReadDirEntryCheckRangeSshortLong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int16)(*ma++); + *mb++=(int16_t)(*ma++); } } break; case TIFF_SLONG: { - int32* ma; - int16* mb; - uint32 n; - ma=(int32*)origdata; + int32_t* ma; + int16_t* mb; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); err=TIFFReadDirEntryCheckRangeSshortSlong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int16)(*ma++); + *mb++=(int16_t)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; - int16* mb; - uint32 n; - ma=(uint64*)origdata; + uint64_t* ma; + int16_t* mb; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1604,25 +1603,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEn err=TIFFReadDirEntryCheckRangeSshortLong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int16)(*ma++); + *mb++=(int16_t)(*ma++); } } break; case TIFF_SLONG8: { - int64* ma; - int16* mb; - uint32 n; - ma=(int64*)origdata; + int64_t* ma; + int16_t* mb; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); err=TIFFReadDirEntryCheckRangeSshortSlong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int16)(*ma++); + *mb++=(int16_t)(*ma++); } } break; @@ -1637,12 +1636,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEn return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - uint32* data; + uint32_t* data; switch (direntry->tdir_type) { case TIFF_BYTE: @@ -1666,19 +1665,19 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntr switch (direntry->tdir_type) { case TIFF_LONG: - *value=(uint32*)origdata; + *value=(uint32_t*)origdata; if (tif->tif_flags&TIFF_SWAB) TIFFSwabArrayOfLong(*value,count); return(TIFFReadDirEntryErrOk); case TIFF_SLONG: { - int32* m; - uint32 n; - m=(int32*)origdata; + int32_t* m; + uint32_t n; + m=(int32_t*)origdata; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)m); + TIFFSwabLong((uint32_t*)m); err=TIFFReadDirEntryCheckRangeLongSlong(*m); if (err!=TIFFReadDirEntryErrOk) { @@ -1687,11 +1686,11 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntr } m++; } - *value=(uint32*)origdata; + *value=(uint32_t*)origdata; return(TIFFReadDirEntryErrOk); } } - data=(uint32*)_TIFFmalloc(count*4); + data=(uint32_t*)_TIFFmalloc(count * 4); if (data==0) { _TIFFfree(origdata); @@ -1701,70 +1700,70 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntr { case TIFF_BYTE: { - uint8* ma; - uint32* mb; - uint32 n; - ma=(uint8*)origdata; + uint8_t* ma; + uint32_t* mb; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(uint32)(*ma++); + *mb++=(uint32_t)(*ma++); } break; case TIFF_SBYTE: { - int8* ma; - uint32* mb; - uint32 n; - ma=(int8*)origdata; + int8_t* ma; + uint32_t* mb; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) { err=TIFFReadDirEntryCheckRangeLongSbyte(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint32)(*ma++); + *mb++=(uint32_t)(*ma++); } } break; case TIFF_SHORT: { - uint16* ma; - uint32* mb; - uint32 n; - ma=(uint16*)origdata; + uint16_t* ma; + uint32_t* mb; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabShort(ma); - *mb++=(uint32)(*ma++); + *mb++=(uint32_t)(*ma++); } } break; case TIFF_SSHORT: { - int16* ma; - uint32* mb; - uint32 n; - ma=(int16*)origdata; + int16_t* ma; + uint32_t* mb; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); + TIFFSwabShort((uint16_t*)ma); err=TIFFReadDirEntryCheckRangeLongSshort(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint32)(*ma++); + *mb++=(uint32_t)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; - uint32* mb; - uint32 n; - ma=(uint64*)origdata; + uint64_t* ma; + uint32_t* mb; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1773,25 +1772,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntr err=TIFFReadDirEntryCheckRangeLongLong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint32)(*ma++); + *mb++=(uint32_t)(*ma++); } } break; case TIFF_SLONG8: { - int64* ma; - uint32* mb; - uint32 n; - ma=(int64*)origdata; + int64_t* ma; + uint32_t* mb; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); err=TIFFReadDirEntryCheckRangeLongSlong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint32)(*ma++); + *mb++=(uint32_t)(*ma++); } } break; @@ -1806,12 +1805,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntr return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - int32* data; + int32_t* data; switch (direntry->tdir_type) { case TIFF_BYTE: @@ -1836,13 +1835,13 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEnt { case TIFF_LONG: { - uint32* m; - uint32 n; - m=(uint32*)origdata; + uint32_t* m; + uint32_t n; + m=(uint32_t*)origdata; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)m); + TIFFSwabLong((uint32_t*)m); err=TIFFReadDirEntryCheckRangeSlongLong(*m); if (err!=TIFFReadDirEntryErrOk) { @@ -1851,16 +1850,16 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEnt } m++; } - *value=(int32*)origdata; + *value=(int32_t*)origdata; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG: - *value=(int32*)origdata; + *value=(int32_t*)origdata; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfLong((uint32*)(*value),count); + TIFFSwabArrayOfLong((uint32_t*)(*value), count); return(TIFFReadDirEntryErrOk); } - data=(int32*)_TIFFmalloc(count*4); + data=(int32_t*)_TIFFmalloc(count * 4); if (data==0) { _TIFFfree(origdata); @@ -1870,62 +1869,62 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEnt { case TIFF_BYTE: { - uint8* ma; - int32* mb; - uint32 n; - ma=(uint8*)origdata; + uint8_t* ma; + int32_t* mb; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(int32)(*ma++); + *mb++=(int32_t)(*ma++); } break; case TIFF_SBYTE: { - int8* ma; - int32* mb; - uint32 n; - ma=(int8*)origdata; + int8_t* ma; + int32_t* mb; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(int32)(*ma++); + *mb++=(int32_t)(*ma++); } break; case TIFF_SHORT: { - uint16* ma; - int32* mb; - uint32 n; - ma=(uint16*)origdata; + uint16_t* ma; + int32_t* mb; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabShort(ma); - *mb++=(int32)(*ma++); + *mb++=(int32_t)(*ma++); } } break; case TIFF_SSHORT: { - int16* ma; - int32* mb; - uint32 n; - ma=(int16*)origdata; + int16_t* ma; + int32_t* mb; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); - *mb++=(int32)(*ma++); + TIFFSwabShort((uint16_t*)ma); + *mb++=(int32_t)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; - int32* mb; - uint32 n; - ma=(uint64*)origdata; + uint64_t* ma; + int32_t* mb; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -1934,25 +1933,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEnt err=TIFFReadDirEntryCheckRangeSlongLong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int32)(*ma++); + *mb++=(int32_t)(*ma++); } } break; case TIFF_SLONG8: { - int64* ma; - int32* mb; - uint32 n; - ma=(int64*)origdata; + int64_t* ma; + int32_t* mb; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); err=TIFFReadDirEntryCheckRangeSlongSlong8(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(int32)(*ma++); + *mb++=(int32_t)(*ma++); } } break; @@ -1968,12 +1967,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEnt } static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit( - TIFF* tif, TIFFDirEntry* direntry, uint64** value, uint64 maxcount) + TIFF* tif, TIFFDirEntry* direntry, uint64_t** value, uint64_t maxcount) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - uint64* data; + uint64_t* data; switch (direntry->tdir_type) { case TIFF_BYTE: @@ -1997,19 +1996,19 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit( switch (direntry->tdir_type) { case TIFF_LONG8: - *value=(uint64*)origdata; + *value=(uint64_t*)origdata; if (tif->tif_flags&TIFF_SWAB) TIFFSwabArrayOfLong8(*value,count); return(TIFFReadDirEntryErrOk); case TIFF_SLONG8: { - int64* m; - uint32 n; - m=(int64*)origdata; + int64_t* m; + uint32_t n; + m=(int64_t*)origdata; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)m); + TIFFSwabLong8((uint64_t*)m); err=TIFFReadDirEntryCheckRangeLong8Slong8(*m); if (err!=TIFFReadDirEntryErrOk) { @@ -2018,11 +2017,11 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit( } m++; } - *value=(uint64*)origdata; + *value=(uint64_t*)origdata; return(TIFFReadDirEntryErrOk); } } - data=(uint64*)_TIFFmalloc(count*8); + data=(uint64_t*)_TIFFmalloc(count * 8); if (data==0) { _TIFFfree(origdata); @@ -2032,94 +2031,94 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit( { case TIFF_BYTE: { - uint8* ma; - uint64* mb; - uint32 n; - ma=(uint8*)origdata; + uint8_t* ma; + uint64_t* mb; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } break; case TIFF_SBYTE: { - int8* ma; - uint64* mb; - uint32 n; - ma=(int8*)origdata; + int8_t* ma; + uint64_t* mb; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) { err=TIFFReadDirEntryCheckRangeLong8Sbyte(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } } break; case TIFF_SHORT: { - uint16* ma; - uint64* mb; - uint32 n; - ma=(uint16*)origdata; + uint16_t* ma; + uint64_t* mb; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabShort(ma); - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } } break; case TIFF_SSHORT: { - int16* ma; - uint64* mb; - uint32 n; - ma=(int16*)origdata; + int16_t* ma; + uint64_t* mb; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); + TIFFSwabShort((uint16_t*)ma); err=TIFFReadDirEntryCheckRangeLong8Sshort(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; - uint64* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + uint64_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } } break; case TIFF_SLONG: { - int32* ma; - uint64* mb; - uint32 n; - ma=(int32*)origdata; + int32_t* ma; + uint64_t* mb; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); err=TIFFReadDirEntryCheckRangeLong8Slong(*ma); if (err!=TIFFReadDirEntryErrOk) break; - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } } break; @@ -2134,17 +2133,17 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8ArrayWithLimit( return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64_t** value) { - return TIFFReadDirEntryLong8ArrayWithLimit(tif, direntry, value, ~((uint64)0)); + return TIFFReadDirEntryLong8ArrayWithLimit(tif, direntry, value, ~((uint64_t)0)); } -static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - int64* data; + int64_t* data; switch (direntry->tdir_type) { case TIFF_BYTE: @@ -2169,9 +2168,9 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEn { case TIFF_LONG8: { - uint64* m; - uint32 n; - m=(uint64*)origdata; + uint64_t* m; + uint32_t n; + m=(uint64_t*)origdata; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) @@ -2184,16 +2183,16 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEn } m++; } - *value=(int64*)origdata; + *value=(int64_t*)origdata; return(TIFFReadDirEntryErrOk); } case TIFF_SLONG8: - *value=(int64*)origdata; + *value=(int64_t*)origdata; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfLong8((uint64*)(*value),count); + TIFFSwabArrayOfLong8((uint64_t*)(*value), count); return(TIFFReadDirEntryErrOk); } - data=(int64*)_TIFFmalloc(count*8); + data=(int64_t*)_TIFFmalloc(count * 8); if (data==0) { _TIFFfree(origdata); @@ -2203,83 +2202,83 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEn { case TIFF_BYTE: { - uint8* ma; - int64* mb; - uint32 n; - ma=(uint8*)origdata; + uint8_t* ma; + int64_t* mb; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(int64)(*ma++); + *mb++=(int64_t)(*ma++); } break; case TIFF_SBYTE: { - int8* ma; - int64* mb; - uint32 n; - ma=(int8*)origdata; + int8_t* ma; + int64_t* mb; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) - *mb++=(int64)(*ma++); + *mb++=(int64_t)(*ma++); } break; case TIFF_SHORT: { - uint16* ma; - int64* mb; - uint32 n; - ma=(uint16*)origdata; + uint16_t* ma; + int64_t* mb; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabShort(ma); - *mb++=(int64)(*ma++); + *mb++=(int64_t)(*ma++); } } break; case TIFF_SSHORT: { - int16* ma; - int64* mb; - uint32 n; - ma=(int16*)origdata; + int16_t* ma; + int64_t* mb; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); - *mb++=(int64)(*ma++); + TIFFSwabShort((uint16_t*)ma); + *mb++=(int64_t)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; - int64* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + int64_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); - *mb++=(int64)(*ma++); + *mb++=(int64_t)(*ma++); } } break; case TIFF_SLONG: { - int32* ma; - int64* mb; - uint32 n; - ma=(int32*)origdata; + int32_t* ma; + int64_t* mb; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); - *mb++=(int64)(*ma++); + TIFFSwabLong((uint32_t*)ma); + *mb++=(int64_t)(*ma++); } } break; @@ -2292,7 +2291,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEn static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEntry* direntry, float** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; float* data; switch (direntry->tdir_type) @@ -2323,7 +2322,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt { case TIFF_FLOAT: if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfLong((uint32*)origdata,count); + TIFFSwabArrayOfLong((uint32_t*)origdata, count); TIFFCvtIEEEDoubleToNative(tif,count,(float*)origdata); *value=(float*)origdata; return(TIFFReadDirEntryErrOk); @@ -2338,10 +2337,10 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt { case TIFF_BYTE: { - uint8* ma; + uint8_t* ma; float* mb; - uint32 n; - ma=(uint8*)origdata; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) *mb++=(float)(*ma++); @@ -2349,10 +2348,10 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt break; case TIFF_SBYTE: { - int8* ma; + int8_t* ma; float* mb; - uint32 n; - ma=(int8*)origdata; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) *mb++=(float)(*ma++); @@ -2360,10 +2359,10 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt break; case TIFF_SHORT: { - uint16* ma; + uint16_t* ma; float* mb; - uint32 n; - ma=(uint16*)origdata; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2375,25 +2374,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt break; case TIFF_SSHORT: { - int16* ma; + int16_t* ma; float* mb; - uint32 n; - ma=(int16*)origdata; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); + TIFFSwabShort((uint16_t*)ma); *mb++=(float)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; + uint32_t* ma; float* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2405,25 +2404,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt break; case TIFF_SLONG: { - int32* ma; + int32_t* ma; float* mb; - uint32 n; - ma=(int32*)origdata; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); *mb++=(float)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; + uint64_t* ma; float* mb; - uint32 n; - ma=(uint64*)origdata; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2444,27 +2443,27 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt break; case TIFF_SLONG8: { - int64* ma; + int64_t* ma; float* mb; - uint32 n; - ma=(int64*)origdata; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); *mb++=(float)(*ma++); } } break; case TIFF_RATIONAL: { - uint32* ma; - uint32 maa; - uint32 mab; + uint32_t* ma; + uint32_t maa; + uint32_t mab; float* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2483,18 +2482,18 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt break; case TIFF_SRATIONAL: { - uint32* ma; - int32 maa; - uint32 mab; + uint32_t* ma; + int32_t maa; + uint32_t mab; float* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); - maa=*(int32*)ma; + maa=*(int32_t*)ma; ma++; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); @@ -2510,9 +2509,9 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEnt { double* ma; float* mb; - uint32 n; + uint32_t n; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfLong8((uint64*)origdata,count); + TIFFSwabArrayOfLong8((uint64_t*)origdata, count); TIFFCvtIEEEDoubleToNative(tif,count,(double*)origdata); ma=(double*)origdata; mb=data; @@ -2537,7 +2536,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; double* data; switch (direntry->tdir_type) @@ -2568,7 +2567,7 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) { case TIFF_DOUBLE: if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfLong8((uint64*)origdata,count); + TIFFSwabArrayOfLong8((uint64_t*)origdata, count); TIFFCvtIEEEDoubleToNative(tif,count,(double*)origdata); *value=(double*)origdata; return(TIFFReadDirEntryErrOk); @@ -2583,10 +2582,10 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) { case TIFF_BYTE: { - uint8* ma; + uint8_t* ma; double* mb; - uint32 n; - ma=(uint8*)origdata; + uint32_t n; + ma=(uint8_t*)origdata; mb=data; for (n=0; n<count; n++) *mb++=(double)(*ma++); @@ -2594,10 +2593,10 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) break; case TIFF_SBYTE: { - int8* ma; + int8_t* ma; double* mb; - uint32 n; - ma=(int8*)origdata; + uint32_t n; + ma=(int8_t*)origdata; mb=data; for (n=0; n<count; n++) *mb++=(double)(*ma++); @@ -2605,10 +2604,10 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) break; case TIFF_SHORT: { - uint16* ma; + uint16_t* ma; double* mb; - uint32 n; - ma=(uint16*)origdata; + uint32_t n; + ma=(uint16_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2620,25 +2619,25 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) break; case TIFF_SSHORT: { - int16* ma; + int16_t* ma; double* mb; - uint32 n; - ma=(int16*)origdata; + uint32_t n; + ma=(int16_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); + TIFFSwabShort((uint16_t*)ma); *mb++=(double)(*ma++); } } break; case TIFF_LONG: { - uint32* ma; + uint32_t* ma; double* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2650,25 +2649,25 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) break; case TIFF_SLONG: { - int32* ma; + int32_t* ma; double* mb; - uint32 n; - ma=(int32*)origdata; + uint32_t n; + ma=(int32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); + TIFFSwabLong((uint32_t*)ma); *mb++=(double)(*ma++); } } break; case TIFF_LONG8: { - uint64* ma; + uint64_t* ma; double* mb; - uint32 n; - ma=(uint64*)origdata; + uint32_t n; + ma=(uint64_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2689,27 +2688,27 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) break; case TIFF_SLONG8: { - int64* ma; + int64_t* ma; double* mb; - uint32 n; - ma=(int64*)origdata; + uint32_t n; + ma=(int64_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); *mb++=(double)(*ma++); } } break; case TIFF_RATIONAL: { - uint32* ma; - uint32 maa; - uint32 mab; + uint32_t* ma; + uint32_t maa; + uint32_t mab; double* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { @@ -2728,18 +2727,18 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) break; case TIFF_SRATIONAL: { - uint32* ma; - int32 maa; - uint32 mab; + uint32_t* ma; + int32_t maa; + uint32_t mab; double* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); - maa=*(int32*)ma; + maa=*(int32_t*)ma; ma++; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); @@ -2755,9 +2754,9 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) { float* ma; double* mb; - uint32 n; + uint32_t n; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabArrayOfLong((uint32*)origdata,count); + TIFFSwabArrayOfLong((uint32_t*)origdata, count); TIFFCvtIEEEFloatToNative(tif,count,(float*)origdata); ma=(float*)origdata; mb=data; @@ -2771,12 +2770,12 @@ TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64_t** value) { enum TIFFReadDirEntryErr err; - uint32 count; + uint32_t count; void* origdata; - uint64* data; + uint64_t* data; switch (direntry->tdir_type) { case TIFF_LONG: @@ -2797,12 +2796,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntr { case TIFF_LONG8: case TIFF_IFD8: - *value=(uint64*)origdata; + *value=(uint64_t*)origdata; if (tif->tif_flags&TIFF_SWAB) TIFFSwabArrayOfLong8(*value,count); return(TIFFReadDirEntryErrOk); } - data=(uint64*)_TIFFmalloc(count*8); + data=(uint64_t*)_TIFFmalloc(count * 8); if (data==0) { _TIFFfree(origdata); @@ -2813,16 +2812,16 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntr case TIFF_LONG: case TIFF_IFD: { - uint32* ma; - uint64* mb; - uint32 n; - ma=(uint32*)origdata; + uint32_t* ma; + uint64_t* mb; + uint32_t n; + ma=(uint32_t*)origdata; mb=data; for (n=0; n<count; n++) { if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(ma); - *mb++=(uint64)(*ma++); + *mb++=(uint64_t)(*ma++); } } break; @@ -2832,13 +2831,13 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntr return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16_t* value) { enum TIFFReadDirEntryErr err; - uint16* m; - uint16* na; - uint16 nb; - if (direntry->tdir_count<(uint64)tif->tif_dir.td_samplesperpixel) + uint16_t* m; + uint16_t* na; + uint16_t nb; + if (direntry->tdir_count<(uint64_t)tif->tif_dir.td_samplesperpixel) return(TIFFReadDirEntryErrCount); err=TIFFReadDirEntryShortArray(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk || m == NULL) @@ -2866,8 +2865,8 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFD enum TIFFReadDirEntryErr err; double* m; double* na; - uint16 nb; - if (direntry->tdir_count<(uint64)tif->tif_dir.td_samplesperpixel) + uint16_t nb; + if (direntry->tdir_count<(uint64_t)tif->tif_dir.td_samplesperpixel) return(TIFFReadDirEntryErrCount); err=TIFFReadDirEntryDoubleArray(tif,direntry,&m); if (err!=TIFFReadDirEntryErrOk) @@ -2890,53 +2889,53 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFD } #endif -static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value) +static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8_t* value) { (void) tif; - *value=*(uint8*)(&direntry->tdir_offset); + *value=*(uint8_t*)(&direntry->tdir_offset); } -static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8* value) +static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8_t* value) { (void) tif; - *value=*(int8*)(&direntry->tdir_offset); + *value=*(int8_t*)(&direntry->tdir_offset); } -static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value) +static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16_t* value) { *value = direntry->tdir_offset.toff_short; - /* *value=*(uint16*)(&direntry->tdir_offset); */ + /* *value=*(uint16_t*)(&direntry->tdir_offset); */ if (tif->tif_flags&TIFF_SWAB) TIFFSwabShort(value); } -static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16* value) +static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16_t* value) { - *value=*(int16*)(&direntry->tdir_offset); + *value=*(int16_t*)(&direntry->tdir_offset); if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)value); + TIFFSwabShort((uint16_t*)value); } -static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value) +static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32_t* value) { - *value=*(uint32*)(&direntry->tdir_offset); + *value=*(uint32_t*)(&direntry->tdir_offset); if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(value); } -static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32* value) +static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32_t* value) { - *value=*(int32*)(&direntry->tdir_offset); + *value=*(int32_t*)(&direntry->tdir_offset); if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)value); + TIFFSwabLong((uint32_t*)value); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64_t* value) { if (!(tif->tif_flags&TIFF_BIGTIFF)) { enum TIFFReadDirEntryErr err; - uint32 offset = direntry->tdir_offset.toff_long; + uint32_t offset = direntry->tdir_offset.toff_long; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); err=TIFFReadDirEntryData(tif,offset,8,value); @@ -2950,12 +2949,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirE return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64* value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64_t* value) { if (!(tif->tif_flags&TIFF_BIGTIFF)) { enum TIFFReadDirEntryErr err; - uint32 offset = direntry->tdir_offset.toff_long; + uint32_t offset = direntry->tdir_offset.toff_long; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); err=TIFFReadDirEntryData(tif,offset,8,value); @@ -2963,9 +2962,9 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDir return(err); } else - *value=*(int64*)(&direntry->tdir_offset); + *value=*(int64_t*)(&direntry->tdir_offset); if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)value); + TIFFSwabLong8((uint64_t*)value); return(TIFFReadDirEntryErrOk); } @@ -2974,12 +2973,12 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF* tif, TIFFD UInt64Aligned_t m; assert(sizeof(double)==8); - assert(sizeof(uint64)==8); - assert(sizeof(uint32)==4); + assert(sizeof(uint64_t) == 8); + assert(sizeof(uint32_t) == 4); if (!(tif->tif_flags&TIFF_BIGTIFF)) { enum TIFFReadDirEntryErr err; - uint32 offset = direntry->tdir_offset.toff_long; + uint32_t offset = direntry->tdir_offset.toff_long; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); err=TIFFReadDirEntryData(tif,offset,8,m.i); @@ -3004,13 +3003,13 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF* tif, TIFF { UInt64Aligned_t m; assert(sizeof(double)==8); - assert(sizeof(uint64)==8); - assert(sizeof(int32)==4); - assert(sizeof(uint32)==4); + assert(sizeof(uint64_t) == 8); + assert(sizeof(int32_t) == 4); + assert(sizeof(uint32_t) == 4); if (!(tif->tif_flags&TIFF_BIGTIFF)) { enum TIFFReadDirEntryErr err; - uint32 offset = direntry->tdir_offset.toff_long; + uint32_t offset = direntry->tdir_offset.toff_long; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); err=TIFFReadDirEntryData(tif,offset,8,m.i); @@ -3024,10 +3023,10 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF* tif, TIFF /* Not completely sure what we should do when m.i[1]==0, but some */ /* sanitizers do not like division by 0.0: */ /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */ - if ((int32)m.i[0]==0 || m.i[1]==0) + if ((int32_t)m.i[0] == 0 || m.i[1] == 0) *value=0.0; else - *value=(double)((int32)m.i[0])/(double)m.i[1]; + *value= (double)((int32_t)m.i[0]) / (double)m.i[1]; return(TIFFReadDirEntryErrOk); } @@ -3036,26 +3035,26 @@ static void TIFFReadDirEntryCheckedFloat(TIFF* tif, TIFFDirEntry* direntry, floa union { float f; - uint32 i; + uint32_t i; } float_union; assert(sizeof(float)==4); - assert(sizeof(uint32)==4); + assert(sizeof(uint32_t) == 4); assert(sizeof(float_union)==4); - float_union.i=*(uint32*)(&direntry->tdir_offset); + float_union.i=*(uint32_t*)(&direntry->tdir_offset); *value=float_union.f; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)value); + TIFFSwabLong((uint32_t*)value); } static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF* tif, TIFFDirEntry* direntry, double* value) { assert(sizeof(double)==8); - assert(sizeof(uint64)==8); + assert(sizeof(uint64_t) == 8); assert(sizeof(UInt64Aligned_t)==8); if (!(tif->tif_flags&TIFF_BIGTIFF)) { enum TIFFReadDirEntryErr err; - uint32 offset = direntry->tdir_offset.toff_long; + uint32_t offset = direntry->tdir_offset.toff_long; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); err=TIFFReadDirEntryData(tif,offset,8,value); @@ -3069,11 +3068,11 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF* tif, TIFFDir *value=uint64_union.d; } if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)value); + TIFFSwabLong8((uint64_t*)value); return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8_t value) { if (value<0) return(TIFFReadDirEntryErrRange); @@ -3081,7 +3080,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16_t value) { if (value>0xFF) return(TIFFReadDirEntryErrRange); @@ -3089,7 +3088,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16_t value) { if ((value<0)||(value>0xFF)) return(TIFFReadDirEntryErrRange); @@ -3097,7 +3096,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32_t value) { if (value>0xFF) return(TIFFReadDirEntryErrRange); @@ -3105,7 +3104,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32_t value) { if ((value<0)||(value>0xFF)) return(TIFFReadDirEntryErrRange); @@ -3113,7 +3112,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64_t value) { if (value>0xFF) return(TIFFReadDirEntryErrRange); @@ -3121,7 +3120,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64_t value) { if ((value<0)||(value>0xFF)) return(TIFFReadDirEntryErrRange); @@ -3129,7 +3128,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8_t value) { if (value>0x7F) return(TIFFReadDirEntryErrRange); @@ -3137,7 +3136,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16_t value) { if (value>0x7F) return(TIFFReadDirEntryErrRange); @@ -3145,7 +3144,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16_t value) { if ((value<-0x80)||(value>0x7F)) return(TIFFReadDirEntryErrRange); @@ -3153,7 +3152,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32_t value) { if (value>0x7F) return(TIFFReadDirEntryErrRange); @@ -3161,7 +3160,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32_t value) { if ((value<-0x80)||(value>0x7F)) return(TIFFReadDirEntryErrRange); @@ -3169,7 +3168,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64_t value) { if (value>0x7F) return(TIFFReadDirEntryErrRange); @@ -3177,7 +3176,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64_t value) { if ((value<-0x80)||(value>0x7F)) return(TIFFReadDirEntryErrRange); @@ -3185,7 +3184,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8_t value) { if (value<0) return(TIFFReadDirEntryErrRange); @@ -3193,7 +3192,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16_t value) { if (value<0) return(TIFFReadDirEntryErrRange); @@ -3201,7 +3200,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32_t value) { if (value>0xFFFF) return(TIFFReadDirEntryErrRange); @@ -3209,7 +3208,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32_t value) { if ((value<0)||(value>0xFFFF)) return(TIFFReadDirEntryErrRange); @@ -3217,7 +3216,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64_t value) { if (value>0xFFFF) return(TIFFReadDirEntryErrRange); @@ -3225,7 +3224,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64_t value) { if ((value<0)||(value>0xFFFF)) return(TIFFReadDirEntryErrRange); @@ -3233,7 +3232,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16_t value) { if (value>0x7FFF) return(TIFFReadDirEntryErrRange); @@ -3241,7 +3240,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 val return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32_t value) { if (value>0x7FFF) return(TIFFReadDirEntryErrRange); @@ -3249,7 +3248,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32_t value) { if ((value<-0x8000)||(value>0x7FFF)) return(TIFFReadDirEntryErrRange); @@ -3257,7 +3256,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 valu return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64_t value) { if (value>0x7FFF) return(TIFFReadDirEntryErrRange); @@ -3265,7 +3264,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 val return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64_t value) { if ((value<-0x8000)||(value>0x7FFF)) return(TIFFReadDirEntryErrRange); @@ -3273,7 +3272,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 val return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8_t value) { if (value<0) return(TIFFReadDirEntryErrRange); @@ -3281,7 +3280,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value) return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16_t value) { if (value<0) return(TIFFReadDirEntryErrRange); @@ -3289,7 +3288,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value return(TIFFReadDirEntryErrOk); } -static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value) +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32_t value) { if (value<0) return(TIFFReadDirEntryErrRange); @@ -3298,25 +3297,25 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value) } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeLongLong8(uint64 value) +TIFFReadDirEntryCheckRangeLongLong8(uint64_t value) { - if (value > TIFF_UINT32_MAX) + if (value > UINT32_MAX) return(TIFFReadDirEntryErrRange); else return(TIFFReadDirEntryErrOk); } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeLongSlong8(int64 value) +TIFFReadDirEntryCheckRangeLongSlong8(int64_t value) { - if ((value < 0) || (value > (int64) TIFF_UINT32_MAX)) + if ((value < 0) || (value > (int64_t) UINT32_MAX)) return(TIFFReadDirEntryErrRange); else return(TIFFReadDirEntryErrOk); } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeSlongLong(uint32 value) +TIFFReadDirEntryCheckRangeSlongLong(uint32_t value) { if (value > 0x7FFFFFFFUL) return(TIFFReadDirEntryErrRange); @@ -3326,7 +3325,7 @@ TIFFReadDirEntryCheckRangeSlongLong(uint32 value) /* Check that the 8-byte unsigned value can fit in a 4-byte unsigned range */ static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeSlongLong8(uint64 value) +TIFFReadDirEntryCheckRangeSlongLong8(uint64_t value) { if (value > 0x7FFFFFFF) return(TIFFReadDirEntryErrRange); @@ -3336,16 +3335,16 @@ TIFFReadDirEntryCheckRangeSlongLong8(uint64 value) /* Check that the 8-byte signed value can fit in a 4-byte signed range */ static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeSlongSlong8(int64 value) +TIFFReadDirEntryCheckRangeSlongSlong8(int64_t value) { - if ((value < 0-((int64) 0x7FFFFFFF+1)) || (value > 0x7FFFFFFF)) + if ((value < 0-((int64_t) 0x7FFFFFFF + 1)) || (value > 0x7FFFFFFF)) return(TIFFReadDirEntryErrRange); else return(TIFFReadDirEntryErrOk); } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value) +TIFFReadDirEntryCheckRangeLong8Sbyte(int8_t value) { if (value < 0) return(TIFFReadDirEntryErrRange); @@ -3354,7 +3353,7 @@ TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value) } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeLong8Sshort(int16 value) +TIFFReadDirEntryCheckRangeLong8Sshort(int16_t value) { if (value < 0) return(TIFFReadDirEntryErrRange); @@ -3363,7 +3362,7 @@ TIFFReadDirEntryCheckRangeLong8Sshort(int16 value) } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeLong8Slong(int32 value) +TIFFReadDirEntryCheckRangeLong8Slong(int32_t value) { if (value < 0) return(TIFFReadDirEntryErrRange); @@ -3372,7 +3371,7 @@ TIFFReadDirEntryCheckRangeLong8Slong(int32 value) } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeLong8Slong8(int64 value) +TIFFReadDirEntryCheckRangeLong8Slong8(int64_t value) { if (value < 0) return(TIFFReadDirEntryErrRange); @@ -3381,16 +3380,16 @@ TIFFReadDirEntryCheckRangeLong8Slong8(int64 value) } static enum TIFFReadDirEntryErr -TIFFReadDirEntryCheckRangeSlong8Long8(uint64 value) +TIFFReadDirEntryCheckRangeSlong8Long8(uint64_t value) { - if (value > TIFF_INT64_MAX) + if (value > INT64_MAX) return(TIFFReadDirEntryErrRange); else return(TIFFReadDirEntryErrOk); } static enum TIFFReadDirEntryErr -TIFFReadDirEntryData(TIFF* tif, uint64 offset, tmsize_t size, void* dest) +TIFFReadDirEntryData(TIFF* tif, uint64_t offset, tmsize_t size, void* dest) { assert(size>0); if (!isMapped(tif)) { @@ -3401,13 +3400,13 @@ TIFFReadDirEntryData(TIFF* tif, uint64 offset, tmsize_t size, void* dest) } else { size_t ma,mb; ma=(size_t)offset; - if( (uint64)ma!=offset || + if((uint64_t)ma != offset || ma > (~(size_t)0) - (size_t)size ) { return TIFFReadDirEntryErrIo; } mb=ma+size; - if (mb > (uint64)tif->tif_size) + if (mb > (uint64_t)tif->tif_size) return(TIFFReadDirEntryErrIo); _TIFFmemcpy(dest,tif->tif_base+ma,size); } @@ -3506,7 +3505,7 @@ static void TIFFReadDirEntryOutputErr(TIFF* tif, enum TIFFReadDirEntryErr err, c * type. 0 is returned if photometric type isn't supported or no default value * is defined by the specification. */ -static int _TIFFGetMaxColorChannels( uint16 photometric ) +static int _TIFFGetMaxColorChannels(uint16_t photometric ) { switch (photometric) { case PHOTOMETRIC_PALETTE: @@ -3545,9 +3544,9 @@ static int ByteCountLooksBad(TIFF* tif) * until the whole image will be written and directory * dumped out. */ - uint64 bytecount = TIFFGetStrileByteCount(tif, 0); - uint64 offset = TIFFGetStrileOffset(tif, 0); - uint64 filesize; + uint64_t bytecount = TIFFGetStrileByteCount(tif, 0); + uint64_t offset = TIFFGetStrileOffset(tif, 0); + uint64_t filesize; if( offset == 0 ) return 0; @@ -3560,9 +3559,9 @@ static int ByteCountLooksBad(TIFF* tif) return 1; if( tif->tif_mode == O_RDONLY ) { - uint64 scanlinesize = TIFFScanlineSize64(tif); + uint64_t scanlinesize = TIFFScanlineSize64(tif); if( tif->tif_dir.td_imagelength > 0 && - scanlinesize > TIFF_UINT64_MAX / tif->tif_dir.td_imagelength ) + scanlinesize > UINT64_MAX / tif->tif_dir.td_imagelength ) { return 1; } @@ -3582,11 +3581,11 @@ TIFFReadDirectory(TIFF* tif) { static const char module[] = "TIFFReadDirectory"; TIFFDirEntry* dir; - uint16 dircount; + uint16_t dircount; TIFFDirEntry* dp; - uint16 di; + uint16_t di; const TIFFField* fip; - uint32 fii=FAILED_FII; + uint32_t fii=FAILED_FII; toff_t nextdiroff; int bitspersample_read = FALSE; int color_channels; @@ -3601,7 +3600,7 @@ TIFFReadDirectory(TIFF* tif) if (!dircount) { TIFFErrorExt(tif->tif_clientdata,module, - "Failed to read directory at offset " TIFF_UINT64_FORMAT,nextdiroff); + "Failed to read directory at offset %" PRIu64, nextdiroff); return 0; } TIFFReadDirectoryCheckOrder(tif,dir,dircount); @@ -3612,11 +3611,11 @@ TIFFReadDirectory(TIFF* tif) */ { TIFFDirEntry* ma; - uint16 mb; + uint16_t mb; for (ma=dir, mb=0; mb<dircount; ma++, mb++) { TIFFDirEntry* na; - uint16 nb; + uint16_t nb; for (na=ma+1, nb=mb+1; nb<dircount; na++, nb++) { if (ma->tdir_tag == na->tdir_tag) { @@ -3673,7 +3672,7 @@ TIFFReadDirectory(TIFF* tif) * this, we accept the tag if one value is supplied with either * count. */ - uint16 value; + uint16_t value; enum TIFFReadDirEntryErr err; err=TIFFReadDirEntryShort(tif,dp,&value); if (err==TIFFReadDirEntryErrCount) @@ -3703,7 +3702,7 @@ TIFFReadDirectory(TIFF* tif) if (fii == FAILED_FII) { TIFFWarningExt(tif->tif_clientdata, module, - "Unknown field with tag %d (0x%x) encountered", + "Unknown field with tag %"PRIu16" (0x%"PRIx16") encountered", dp->tdir_tag,dp->tdir_tag); /* the following knowingly leaks the anonymous field structure */ @@ -3714,7 +3713,7 @@ TIFFReadDirectory(TIFF* tif) 1)) { TIFFWarningExt(tif->tif_clientdata, module, - "Registering anonymous field with tag %d (0x%x) failed", + "Registering anonymous field with tag %"PRIu16" (0x%"PRIx16") failed", dp->tdir_tag, dp->tdir_tag); dp->tdir_ignore = TRUE; @@ -3863,7 +3862,7 @@ TIFFReadDirectory(TIFF* tif) * too. */ { - uint16 value; + uint16_t value; enum TIFFReadDirEntryErr err; err=TIFFReadDirEntryShort(tif,dp,&value); if (err==TIFFReadDirEntryErrCount) @@ -3886,9 +3885,9 @@ TIFFReadDirectory(TIFF* tif) double *data = NULL; enum TIFFReadDirEntryErr err; - uint32 saved_flags; + uint32_t saved_flags; int m; - if (dp->tdir_count != (uint64)tif->tif_dir.td_samplesperpixel) + if (dp->tdir_count != (uint64_t)tif->tif_dir.td_samplesperpixel) err = TIFFReadDirEntryErrCount; else err = TIFFReadDirEntryDoubleArray(tif, dp, &data); @@ -3961,10 +3960,10 @@ TIFFReadDirectory(TIFF* tif) case TIFFTAG_TRANSFERFUNCTION: { enum TIFFReadDirEntryErr err; - uint32 countpersample; - uint32 countrequired; - uint32 incrementpersample; - uint16* value=NULL; + uint32_t countpersample; + uint32_t countrequired; + uint32_t incrementpersample; + uint16_t* value=NULL; /* It would be dangerous to instantiate those tag values */ /* since if td_bitspersample has not yet been read (due to */ /* unordered tags), it could be read afterwards with a */ @@ -3985,13 +3984,13 @@ TIFFReadDirectory(TIFF* tif) { fip = TIFFFieldWithTag(tif,dp->tdir_tag); TIFFWarningExt(tif->tif_clientdata,module, - "Ignoring %s because BitsPerSample=%d>24", + "Ignoring %s because BitsPerSample=%"PRIu16">24", fip ? fip->field_name : "unknown tagname", tif->tif_dir.td_bitspersample); continue; } countpersample=(1U<<tif->tif_dir.td_bitspersample); - if ((dp->tdir_tag==TIFFTAG_TRANSFERFUNCTION)&&(dp->tdir_count==(uint64)countpersample)) + if ((dp->tdir_tag==TIFFTAG_TRANSFERFUNCTION)&&(dp->tdir_count==(uint64_t)countpersample)) { countrequired=countpersample; incrementpersample=0; @@ -4001,7 +4000,7 @@ TIFFReadDirectory(TIFF* tif) countrequired=3*countpersample; incrementpersample=countpersample; } - if (dp->tdir_count!=(uint64)countrequired) + if (dp->tdir_count!=(uint64_t)countrequired) err=TIFFReadDirEntryErrCount; else err=TIFFReadDirEntryShortArray(tif,dp,&value); @@ -4020,8 +4019,8 @@ TIFFReadDirectory(TIFF* tif) /* BEGIN REV 4.0 COMPATIBILITY */ case TIFFTAG_OSUBFILETYPE: { - uint16 valueo; - uint32 value; + uint16_t valueo; + uint32_t value; if (TIFFReadDirEntryShort(tif,dp,&valueo)==TIFFReadDirEntryErrOk) { switch (valueo) @@ -4154,26 +4153,27 @@ TIFFReadDirectory(TIFF* tif) */ color_channels = _TIFFGetMaxColorChannels(tif->tif_dir.td_photometric); if (color_channels && tif->tif_dir.td_samplesperpixel - tif->tif_dir.td_extrasamples > color_channels) { - uint16 old_extrasamples; - uint16 *new_sampleinfo; + uint16_t old_extrasamples; + uint16_t *new_sampleinfo; TIFFWarningExt(tif->tif_clientdata,module, "Sum of Photometric type-related " "color channels and ExtraSamples doesn't match SamplesPerPixel. " "Defining non-color channels as ExtraSamples."); old_extrasamples = tif->tif_dir.td_extrasamples; - tif->tif_dir.td_extrasamples = (uint16) (tif->tif_dir.td_samplesperpixel - color_channels); + tif->tif_dir.td_extrasamples = (uint16_t) (tif->tif_dir.td_samplesperpixel - color_channels); // sampleinfo should contain information relative to these new extra samples - new_sampleinfo = (uint16*) _TIFFcalloc(tif->tif_dir.td_extrasamples, sizeof(uint16)); + new_sampleinfo = (uint16_t*) _TIFFcalloc(tif->tif_dir.td_extrasamples, sizeof(uint16_t)); if (!new_sampleinfo) { TIFFErrorExt(tif->tif_clientdata, module, "Failed to allocate memory for " - "temporary new sampleinfo array (%d 16 bit elements)", + "temporary new sampleinfo array " + "(%"PRIu16" 16 bit elements)", tif->tif_dir.td_extrasamples); goto bad; } - memcpy(new_sampleinfo, tif->tif_dir.td_sampleinfo, old_extrasamples * sizeof(uint16)); + memcpy(new_sampleinfo, tif->tif_dir.td_sampleinfo, old_extrasamples * sizeof(uint16_t)); _TIFFsetShortArray(&tif->tif_dir.td_sampleinfo, new_sampleinfo, tif->tif_dir.td_extrasamples); _TIFFfree(new_sampleinfo); } @@ -4211,7 +4211,7 @@ TIFFReadDirectory(TIFF* tif) if ((tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG && tif->tif_dir.td_nstrips > 1) || (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE && - tif->tif_dir.td_nstrips != (uint32)tif->tif_dir.td_samplesperpixel)) { + tif->tif_dir.td_nstrips != (uint32_t)tif->tif_dir.td_samplesperpixel)) { MissingRequired(tif, "StripByteCounts"); goto bad; } @@ -4268,7 +4268,7 @@ TIFFReadDirectory(TIFF* tif) if (tif->tif_dir.td_bitspersample>=16) tif->tif_dir.td_maxsamplevalue=0xFFFF; else - tif->tif_dir.td_maxsamplevalue = (uint16)((1L<<tif->tif_dir.td_bitspersample)-1); + tif->tif_dir.td_maxsamplevalue = (uint16_t)((1L << tif->tif_dir.td_bitspersample) - 1); } #ifdef STRIPBYTECOUNTSORTED_UNUSED @@ -4278,7 +4278,7 @@ TIFFReadDirectory(TIFF* tif) * function in tif_write.c. */ if (!(tif->tif_flags&TIFF_DEFERSTRILELOAD) && tif->tif_dir.td_nstrips > 1) { - uint32 strip; + uint32_t strip; tif->tif_dir.td_stripbytecountsorted = 1; for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++) { @@ -4333,10 +4333,10 @@ TIFFReadDirectory(TIFF* tif) /* * Reinitialize i/o since we are starting on a new directory. */ - tif->tif_row = (uint32) -1; - tif->tif_curstrip = (uint32) -1; - tif->tif_col = (uint32) -1; - tif->tif_curtile = (uint32) -1; + tif->tif_row = (uint32_t) -1; + tif->tif_curstrip = (uint32_t) -1; + tif->tif_col = (uint32_t) -1; + tif->tif_curtile = (uint32_t) -1; tif->tif_tilesize = (tmsize_t) -1; tif->tif_scanlinesize = TIFFScanlineSize(tif); @@ -4368,11 +4368,11 @@ bad: } static void -TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) +TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16_t dircount) { static const char module[] = "TIFFReadDirectoryCheckOrder"; - uint16 m; - uint16 n; + uint16_t m; + uint16_t n; TIFFDirEntry* o; m=0; for (n=0, o=dir; n<dircount; n++, o++) @@ -4388,10 +4388,10 @@ TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) } static TIFFDirEntry* -TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16 dircount, uint16 tagid) +TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16_t dircount, uint16_t tagid) { TIFFDirEntry* m; - uint16 n; + uint16_t n; (void) tif; for (m=dir, n=0; n<dircount; m++, n++) { @@ -4402,11 +4402,11 @@ TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16 dircount, uint16 } static void -TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii) +TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16_t tagid, uint32_t* fii) { - int32 ma,mb,mc; + int32_t ma,mb,mc; ma=-1; - mc=(int32)tif->tif_nfields; + mc=(int32_t)tif->tif_nfields; while (1) { if (ma+1==mc) @@ -4415,9 +4415,9 @@ TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii) return; } mb=(ma+mc)/2; - if (tif->tif_fields[mb]->field_tag==(uint32)tagid) + if (tif->tif_fields[mb]->field_tag==(uint32_t)tagid) break; - if (tif->tif_fields[mb]->field_tag<(uint32)tagid) + if (tif->tif_fields[mb]->field_tag<(uint32_t)tagid) ma=mb; else mc=mb; @@ -4426,7 +4426,7 @@ TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii) { if (mb==0) break; - if (tif->tif_fields[mb-1]->field_tag!=(uint32)tagid) + if (tif->tif_fields[mb-1]->field_tag!=(uint32_t)tagid) break; mb--; } @@ -4443,18 +4443,18 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, { static const char module[] = "TIFFReadCustomDirectory"; TIFFDirEntry* dir; - uint16 dircount; + uint16_t dircount; TIFFDirEntry* dp; - uint16 di; + uint16_t di; const TIFFField* fip; - uint32 fii; + uint32_t fii; (*tif->tif_cleanup)(tif); /* cleanup any previous compression state */ _TIFFSetupFields(tif, infoarray); dircount=TIFFFetchDirectory(tif,diroff,&dir,NULL); if (!dircount) { TIFFErrorExt(tif->tif_clientdata,module, - "Failed to read custom directory at offset " TIFF_UINT64_FORMAT,diroff); + "Failed to read custom directory at offset %" PRIu64,diroff); return 0; } TIFFFreeDirectory(tif); @@ -4466,14 +4466,14 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, if (fii == FAILED_FII) { TIFFWarningExt(tif->tif_clientdata, module, - "Unknown field with tag %d (0x%x) encountered", + "Unknown field with tag %"PRIu16" (0x%"PRIx16") encountered", dp->tdir_tag, dp->tdir_tag); if (!_TIFFMergeFields(tif, _TIFFCreateAnonField(tif, dp->tdir_tag, (TIFFDataType) dp->tdir_type), 1)) { TIFFWarningExt(tif->tif_clientdata, module, - "Registering anonymous field with tag %d (0x%x) failed", + "Registering anonymous field with tag %"PRIu16" (0x%"PRIx16") failed", dp->tdir_tag, dp->tdir_tag); dp->tdir_ignore = TRUE; } else { @@ -4493,7 +4493,7 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, { fii++; if ((fii==tif->tif_nfields)|| - (tif->tif_fields[fii]->field_tag!=(uint32)dp->tdir_tag)) + (tif->tif_fields[fii]->field_tag!=(uint32_t)dp->tdir_tag)) { fii=0xFFFF; break; @@ -4503,7 +4503,7 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, if (fii==0xFFFF) { TIFFWarningExt(tif->tif_clientdata, module, - "Wrong data type %d for \"%s\"; tag ignored", + "Wrong data type %"PRIu16" for \"%s\"; tag ignored", dp->tdir_type,fip->field_name); dp->tdir_ignore = TRUE; } @@ -4513,11 +4513,11 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, if ((fip->field_readcount!=TIFF_VARIABLE)&& (fip->field_readcount!=TIFF_VARIABLE2)) { - uint32 expected; + uint32_t expected; if (fip->field_readcount==TIFF_SPP) - expected=(uint32)tif->tif_dir.td_samplesperpixel; + expected=(uint32_t)tif->tif_dir.td_samplesperpixel; else - expected=(uint32)fip->field_readcount; + expected=(uint32_t)fip->field_readcount; if (!CheckDirCount(tif,dp,expected)) dp->tdir_ignore = TRUE; } @@ -4565,13 +4565,13 @@ TIFFReadGPSDirectory(TIFF* tif, toff_t diroff) } static int -EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) +EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16_t dircount) { static const char module[] = "EstimateStripByteCounts"; TIFFDirEntry *dp; TIFFDirectory *td = &tif->tif_dir; - uint32 strip; + uint32_t strip; /* Do not try to load stripbytecount as we will compute it */ if( !_TIFFFillStrilesInternal( tif, 0 ) ) @@ -4579,16 +4579,16 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) if (td->td_stripbytecount_p) _TIFFfree(td->td_stripbytecount_p); - td->td_stripbytecount_p = (uint64*) - _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64), + td->td_stripbytecount_p = (uint64_t*) + _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64_t), "for \"StripByteCounts\" array"); if( td->td_stripbytecount_p == NULL ) return -1; if (td->td_compression != COMPRESSION_NONE) { - uint64 space; - uint64 filesize; - uint16 n; + uint64_t space; + uint64_t filesize; + uint16_t n; filesize = TIFFGetFileSize(tif); if (!(tif->tif_flags&TIFF_BIGTIFF)) space=sizeof(TIFFHeaderClassic)+2+dircount*12+4; @@ -4597,18 +4597,18 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) /* calculate amount of space used by indirect values */ for (dp = dir, n = dircount; n > 0; n--, dp++) { - uint32 typewidth; - uint64 datasize; + uint32_t typewidth; + uint64_t datasize; typewidth = TIFFDataWidth((TIFFDataType) dp->tdir_type); if (typewidth == 0) { TIFFErrorExt(tif->tif_clientdata, module, - "Cannot determine size of unknown tag type %d", + "Cannot determine size of unknown tag type %"PRIu16, dp->tdir_type); return -1; } - if( dp->tdir_count > TIFF_UINT64_MAX / typewidth ) + if( dp->tdir_count > UINT64_MAX / typewidth ) return -1; - datasize=(uint64)typewidth*dp->tdir_count; + datasize= (uint64_t)typewidth * dp->tdir_count; if (!(tif->tif_flags&TIFF_BIGTIFF)) { if (datasize<=4) @@ -4619,7 +4619,7 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) if (datasize<=8) datasize=0; } - if( space > TIFF_UINT64_MAX - datasize ) + if( space > UINT64_MAX - datasize ) return -1; space+=datasize; } @@ -4640,7 +4640,7 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) * of data in the strip and trim this number back accordingly. */ strip--; - if (td->td_stripoffset_p[strip] > TIFF_UINT64_MAX - td->td_stripbytecount_p[strip]) + if (td->td_stripoffset_p[strip] > UINT64_MAX - td->td_stripbytecount_p[strip]) return -1; if (td->td_stripoffset_p[strip]+td->td_stripbytecount_p[strip] > filesize) { if( td->td_stripoffset_p[strip] >= filesize ) { @@ -4651,16 +4651,16 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) } } } else if (isTiled(tif)) { - uint64 bytespertile = TIFFTileSize64(tif); + uint64_t bytespertile = TIFFTileSize64(tif); for (strip = 0; strip < td->td_nstrips; strip++) td->td_stripbytecount_p[strip] = bytespertile; } else { - uint64 rowbytes = TIFFScanlineSize64(tif); - uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage; + uint64_t rowbytes = TIFFScanlineSize64(tif); + uint32_t rowsperstrip = td->td_imagelength / td->td_stripsperimage; for (strip = 0; strip < td->td_nstrips; strip++) { - if( rowbytes > 0 && rowsperstrip > TIFF_UINT64_MAX / rowbytes ) + if( rowbytes > 0 && rowsperstrip > UINT64_MAX / rowbytes ) return -1; td->td_stripbytecount_p[strip] = rowbytes * rowsperstrip; } @@ -4688,9 +4688,9 @@ MissingRequired(TIFF* tif, const char* tagname) * seen directories and check every IFD offset against that list. */ static int -TIFFCheckDirOffset(TIFF* tif, uint64 diroff) +TIFFCheckDirOffset(TIFF* tif, uint64_t diroff) { - uint16 n; + uint16_t n; if (diroff == 0) /* no more directories */ return 0; @@ -4708,14 +4708,14 @@ TIFFCheckDirOffset(TIFF* tif, uint64 diroff) tif->tif_dirnumber++; if (tif->tif_dirlist == NULL || tif->tif_dirnumber > tif->tif_dirlistsize) { - uint64* new_dirlist; + uint64_t* new_dirlist; /* * XXX: Reduce memory allocation granularity of the dirlist * array. */ - new_dirlist = (uint64*)_TIFFCheckRealloc(tif, tif->tif_dirlist, - tif->tif_dirnumber, 2 * sizeof(uint64), "for IFD list"); + new_dirlist = (uint64_t*)_TIFFCheckRealloc(tif, tif->tif_dirlist, + tif->tif_dirnumber, 2 * sizeof(uint64_t), "for IFD list"); if (!new_dirlist) return 0; if( tif->tif_dirnumber >= 32768 ) @@ -4735,19 +4735,19 @@ TIFFCheckDirOffset(TIFF* tif, uint64 diroff) * caller is expected to skip/ignore the tag if there is a mismatch. */ static int -CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count) +CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32_t count) { - if ((uint64)count > dir->tdir_count) { + if ((uint64_t)count > dir->tdir_count) { const TIFFField* fip = TIFFFieldWithTag(tif, dir->tdir_tag); TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "incorrect count for field \"%s\" (" TIFF_UINT64_FORMAT ", expecting %u); tag ignored", + "incorrect count for field \"%s\" (%" PRIu64 ", expecting %"PRIu32"); tag ignored", fip ? fip->field_name : "unknown tagname", dir->tdir_count, count); return (0); - } else if ((uint64)count < dir->tdir_count) { + } else if ((uint64_t)count < dir->tdir_count) { const TIFFField* fip = TIFFFieldWithTag(tif, dir->tdir_tag); TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "incorrect count for field \"%s\" (" TIFF_UINT64_FORMAT ", expecting %u); tag trimmed", + "incorrect count for field \"%s\" (%" PRIu64 ", expecting %"PRIu32"); tag trimmed", fip ? fip->field_name : "unknown tagname", dir->tdir_count, count); dir->tdir_count = count; @@ -4761,19 +4761,19 @@ CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count) * nextdiroff variable has been specified, read it too. Function returns a * number of fields in the directory or 0 if failed. */ -static uint16 -TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, - uint64 *nextdiroff) +static uint16_t +TIFFFetchDirectory(TIFF* tif, uint64_t diroff, TIFFDirEntry** pdir, + uint64_t *nextdiroff) { static const char module[] = "TIFFFetchDirectory"; void* origdir; - uint16 dircount16; - uint32 dirsize; + uint16_t dircount16; + uint32_t dirsize; TIFFDirEntry* dir; - uint8* ma; + uint8_t* ma; TIFFDirEntry* mb; - uint16 n; + uint16_t n; assert(pdir); @@ -4789,7 +4789,7 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, } if (!(tif->tif_flags&TIFF_BIGTIFF)) { - if (!ReadOK(tif, &dircount16, sizeof (uint16))) { + if (!ReadOK(tif, &dircount16, sizeof (uint16_t))) { TIFFErrorExt(tif->tif_clientdata, module, "%s: Can not read TIFF directory count", tif->tif_name); @@ -4805,8 +4805,8 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, } dirsize = 12; } else { - uint64 dircount64; - if (!ReadOK(tif, &dircount64, sizeof (uint64))) { + uint64_t dircount64; + if (!ReadOK(tif, &dircount64, sizeof (uint64_t))) { TIFFErrorExt(tif->tif_clientdata, module, "%s: Can not read TIFF directory count", tif->tif_name); @@ -4820,7 +4820,7 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, "Sanity check on directory count failed, this is probably not a valid IFD offset"); return 0; } - dircount16 = (uint16)dircount64; + dircount16 = (uint16_t)dircount64; dirsize = 20; } origdir = _TIFFCheckMalloc(tif, dircount16, @@ -4842,14 +4842,14 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, { if (!(tif->tif_flags&TIFF_BIGTIFF)) { - uint32 nextdiroff32; - if (!ReadOK(tif, &nextdiroff32, sizeof(uint32))) + uint32_t nextdiroff32; + if (!ReadOK(tif, &nextdiroff32, sizeof(uint32_t))) nextdiroff32 = 0; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&nextdiroff32); *nextdiroff=nextdiroff32; } else { - if (!ReadOK(tif, nextdiroff, sizeof(uint64))) + if (!ReadOK(tif, nextdiroff, sizeof(uint64_t))) *nextdiroff = 0; if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong8(nextdiroff); @@ -4858,7 +4858,7 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, } else { tmsize_t m; tmsize_t off; - if (tif->tif_diroff > (uint64)TIFF_INT64_MAX) + if (tif->tif_diroff > (uint64_t)INT64_MAX) { TIFFErrorExt(tif->tif_clientdata,module,"Can not read TIFF directory count"); return(0); @@ -4870,22 +4870,22 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, * otherwise a very high offset may cause an OOB read and * crash the client. Make two comparisons instead of * - * off + sizeof(uint16) > tif->tif_size + * off + sizeof(uint16_t) > tif->tif_size * * to avoid overflow. */ if (!(tif->tif_flags&TIFF_BIGTIFF)) { - m=off+sizeof(uint16); - if ((m<off)||(m<(tmsize_t)sizeof(uint16))||(m>tif->tif_size)) { + m=off+sizeof(uint16_t); + if ((m<off) || (m<(tmsize_t)sizeof(uint16_t)) || (m > tif->tif_size)) { TIFFErrorExt(tif->tif_clientdata, module, "Can not read TIFF directory count"); return 0; } else { _TIFFmemcpy(&dircount16, tif->tif_base + off, - sizeof(uint16)); + sizeof(uint16_t)); } - off += sizeof (uint16); + off += sizeof (uint16_t); if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount16); if (dircount16>4096) @@ -4898,17 +4898,17 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, } else { - uint64 dircount64; - m=off+sizeof(uint64); - if ((m<off)||(m<(tmsize_t)sizeof(uint64))||(m>tif->tif_size)) { + uint64_t dircount64; + m=off+sizeof(uint64_t); + if ((m<off) || (m<(tmsize_t)sizeof(uint64_t)) || (m > tif->tif_size)) { TIFFErrorExt(tif->tif_clientdata, module, "Can not read TIFF directory count"); return 0; } else { _TIFFmemcpy(&dircount64, tif->tif_base + off, - sizeof(uint64)); + sizeof(uint64_t)); } - off += sizeof (uint64); + off += sizeof (uint64_t); if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong8(&dircount64); if (dircount64>4096) @@ -4917,7 +4917,7 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, "Sanity check on directory count failed, this is probably not a valid IFD offset"); return 0; } - dircount16 = (uint16)dircount64; + dircount16 = (uint16_t)dircount64; dirsize = 20; } if (dircount16 == 0 ) @@ -4945,25 +4945,25 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, off += dircount16 * dirsize; if (!(tif->tif_flags&TIFF_BIGTIFF)) { - uint32 nextdiroff32; - m=off+sizeof(uint32); - if ((m<off)||(m<(tmsize_t)sizeof(uint32))||(m>tif->tif_size)) + uint32_t nextdiroff32; + m=off+sizeof(uint32_t); + if ((m<off) || (m<(tmsize_t)sizeof(uint32_t)) || (m > tif->tif_size)) nextdiroff32 = 0; else _TIFFmemcpy(&nextdiroff32, tif->tif_base + off, - sizeof (uint32)); + sizeof (uint32_t)); if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&nextdiroff32); *nextdiroff = nextdiroff32; } else { - m=off+sizeof(uint64); - if ((m<off)||(m<(tmsize_t)sizeof(uint64))||(m>tif->tif_size)) + m=off+sizeof(uint64_t); + if ((m<off) || (m<(tmsize_t)sizeof(uint64_t)) || (m > tif->tif_size)) *nextdiroff = 0; else _TIFFmemcpy(nextdiroff, tif->tif_base + off, - sizeof (uint64)); + sizeof (uint64_t)); if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong8(nextdiroff); } @@ -4977,37 +4977,37 @@ TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, _TIFFfree(origdir); return 0; } - ma=(uint8*)origdir; + ma=(uint8_t*)origdir; mb=dir; for (n=0; n<dircount16; n++) { mb->tdir_ignore = FALSE; if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); - mb->tdir_tag=*(uint16*)ma; - ma+=sizeof(uint16); + TIFFSwabShort((uint16_t*)ma); + mb->tdir_tag=*(uint16_t*)ma; + ma+=sizeof(uint16_t); if (tif->tif_flags&TIFF_SWAB) - TIFFSwabShort((uint16*)ma); - mb->tdir_type=*(uint16*)ma; - ma+=sizeof(uint16); + TIFFSwabShort((uint16_t*)ma); + mb->tdir_type=*(uint16_t*)ma; + ma+=sizeof(uint16_t); if (!(tif->tif_flags&TIFF_BIGTIFF)) { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong((uint32*)ma); - mb->tdir_count=(uint64)(*(uint32*)ma); - ma+=sizeof(uint32); + TIFFSwabLong((uint32_t*)ma); + mb->tdir_count=(uint64_t)(*(uint32_t*)ma); + ma+=sizeof(uint32_t); mb->tdir_offset.toff_long8=0; - *(uint32*)(&mb->tdir_offset)=*(uint32*)ma; - ma+=sizeof(uint32); + *(uint32_t*)(&mb->tdir_offset)=*(uint32_t*)ma; + ma+=sizeof(uint32_t); } else { if (tif->tif_flags&TIFF_SWAB) - TIFFSwabLong8((uint64*)ma); + TIFFSwabLong8((uint64_t*)ma); mb->tdir_count=TIFFReadUInt64(ma); - ma+=sizeof(uint64); + ma+=sizeof(uint64_t); mb->tdir_offset.toff_long8=TIFFReadUInt64(ma); - ma+=sizeof(uint64); + ma+=sizeof(uint64_t); } mb++; } @@ -5024,13 +5024,13 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) { static const char module[] = "TIFFFetchNormalTag"; enum TIFFReadDirEntryErr err; - uint32 fii; + uint32_t fii; const TIFFField* fip = NULL; TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii); if( fii == FAILED_FII ) { TIFFErrorExt(tif->tif_clientdata, "TIFFFetchNormalTag", - "No definition found for tag %d", + "No definition found for tag %"PRIu16, dp->tdir_tag); return 0; } @@ -5045,17 +5045,17 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_ASCII: { - uint8* data; + uint8_t* data; assert(fip->field_passcount==0); err=TIFFReadDirEntryByteArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { - uint32 mb = 0; + uint32_t mb = 0; int n; if (data != NULL) { - uint8* ma = data; - while (mb<(uint32)dp->tdir_count) + uint8_t* ma = data; + while (mb<(uint32_t)dp->tdir_count) { if (*ma==0) break; @@ -5063,24 +5063,24 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) mb++; } } - if (mb+1<(uint32)dp->tdir_count) + if (mb+1<(uint32_t)dp->tdir_count) TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" contains null byte in value; value incorrectly truncated during reading due to implementation limitations",fip->field_name); - else if (mb+1>(uint32)dp->tdir_count) + else if (mb+1>(uint32_t)dp->tdir_count) { - uint8* o; + uint8_t* o; TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte",fip->field_name); - if ((uint32)dp->tdir_count+1!=dp->tdir_count+1) + if ((uint32_t)dp->tdir_count + 1 != dp->tdir_count + 1) o=NULL; else - o=_TIFFmalloc((uint32)dp->tdir_count+1); + o=_TIFFmalloc((uint32_t)dp->tdir_count + 1); if (o==NULL) { if (data!=NULL) _TIFFfree(data); return(0); } - _TIFFmemcpy(o,data,(uint32)dp->tdir_count); - o[(uint32)dp->tdir_count]=0; + _TIFFmemcpy(o,data,(uint32_t)dp->tdir_count); + o[(uint32_t)dp->tdir_count]=0; if (data!=0) _TIFFfree(data); data=o; @@ -5095,7 +5095,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_UINT8: { - uint8 data=0; + uint8_t data=0; assert(fip->field_readcount==1); assert(fip->field_passcount==0); err=TIFFReadDirEntryByte(tif,dp,&data); @@ -5108,7 +5108,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_UINT16: { - uint16 data; + uint16_t data; assert(fip->field_readcount==1); assert(fip->field_passcount==0); err=TIFFReadDirEntryShort(tif,dp,&data); @@ -5121,7 +5121,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_UINT32: { - uint32 data; + uint32_t data; assert(fip->field_readcount==1); assert(fip->field_passcount==0); err=TIFFReadDirEntryLong(tif,dp,&data); @@ -5134,7 +5134,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_UINT64: { - uint64 data; + uint64_t data; assert(fip->field_readcount==1); assert(fip->field_passcount==0); err=TIFFReadDirEntryLong8(tif,dp,&data); @@ -5173,7 +5173,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_IFD8: { - uint64 data; + uint64_t data; assert(fip->field_readcount==1); assert(fip->field_passcount==0); err=TIFFReadDirEntryIfd8(tif,dp,&data); @@ -5186,13 +5186,13 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_UINT16_PAIR: { - uint16* data; + uint16_t* data; assert(fip->field_readcount==2); assert(fip->field_passcount==0); if (dp->tdir_count!=2) { TIFFWarningExt(tif->tif_clientdata,module, - "incorrect count for field \"%s\", expected 2, got %d", - fip->field_name,(int)dp->tdir_count); + "incorrect count for field \"%s\", expected 2, got %"PRIu64, + fip->field_name, dp->tdir_count); return(0); } err=TIFFReadDirEntryShortArray(tif,dp,&data); @@ -5209,13 +5209,13 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C0_UINT8: { - uint8* data; + uint8_t* data; assert(fip->field_readcount>=1); assert(fip->field_passcount==0); - if (dp->tdir_count!=(uint64)fip->field_readcount) { + if (dp->tdir_count!=(uint64_t)fip->field_readcount) { TIFFWarningExt(tif->tif_clientdata,module, - "incorrect count for field \"%s\", expected %d, got %d", - fip->field_name,(int) fip->field_readcount, (int)dp->tdir_count); + "incorrect count for field \"%s\", expected %d, got %"PRIu64, + fip->field_name,(int) fip->field_readcount, dp->tdir_count); return 0; } else @@ -5235,10 +5235,10 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C0_UINT16: { - uint16* data; + uint16_t* data; assert(fip->field_readcount>=1); assert(fip->field_passcount==0); - if (dp->tdir_count!=(uint64)fip->field_readcount) + if (dp->tdir_count!=(uint64_t)fip->field_readcount) /* corrupt file */; else { @@ -5257,10 +5257,10 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C0_UINT32: { - uint32* data; + uint32_t* data; assert(fip->field_readcount>=1); assert(fip->field_passcount==0); - if (dp->tdir_count!=(uint64)fip->field_readcount) + if (dp->tdir_count!=(uint64_t)fip->field_readcount) /* corrupt file */; else { @@ -5282,7 +5282,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) float* data; assert(fip->field_readcount>=1); assert(fip->field_passcount==0); - if (dp->tdir_count!=(uint64)fip->field_readcount) + if (dp->tdir_count!=(uint64_t)fip->field_readcount) /* corrupt file */; else { @@ -5305,7 +5305,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) double* data; assert(fip->field_readcount>=1); assert(fip->field_passcount==0); - if (dp->tdir_count!=(uint64)fip->field_readcount) + if (dp->tdir_count!=(uint64_t)fip->field_readcount) /* corrupt file */; else { @@ -5324,7 +5324,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C16_ASCII: { - uint8* data; + uint8_t* data; assert(fip->field_readcount==TIFF_VARIABLE); assert(fip->field_passcount==1); if (dp->tdir_count>0xFFFF) @@ -5340,7 +5340,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte. Forcing it to be null",fip->field_name); data[dp->tdir_count-1] = '\0'; } - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5351,7 +5351,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C16_UINT8: { - uint8* data; + uint8_t* data; assert(fip->field_readcount==TIFF_VARIABLE); assert(fip->field_passcount==1); if (dp->tdir_count>0xFFFF) @@ -5362,7 +5362,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5373,7 +5373,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C16_UINT16: { - uint16* data; + uint16_t* data; assert(fip->field_readcount==TIFF_VARIABLE); assert(fip->field_passcount==1); if (dp->tdir_count>0xFFFF) @@ -5384,7 +5384,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5395,7 +5395,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C16_UINT32: { - uint32* data; + uint32_t* data; assert(fip->field_readcount==TIFF_VARIABLE); assert(fip->field_passcount==1); if (dp->tdir_count>0xFFFF) @@ -5406,7 +5406,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5417,7 +5417,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C16_UINT64: { - uint64* data; + uint64_t* data; assert(fip->field_readcount==TIFF_VARIABLE); assert(fip->field_passcount==1); if (dp->tdir_count>0xFFFF) @@ -5428,7 +5428,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5450,7 +5450,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5472,7 +5472,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5483,7 +5483,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C16_IFD8: { - uint64* data; + uint64_t* data; assert(fip->field_readcount==TIFF_VARIABLE); assert(fip->field_passcount==1); if (dp->tdir_count>0xFFFF) @@ -5494,7 +5494,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint16_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5505,7 +5505,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_ASCII: { - uint8* data; + uint8_t* data; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntryByteArray(tif,dp,&data); @@ -5517,7 +5517,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte. Forcing it to be null",fip->field_name); data[dp->tdir_count-1] = '\0'; } - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5527,14 +5527,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_UINT8: { - uint8* data; + uint8_t* data; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntryByteArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5544,14 +5544,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_SINT8: { - int8* data = NULL; + int8_t* data = NULL; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntrySbyteArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5561,14 +5561,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_UINT16: { - uint16* data; + uint16_t* data; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntryShortArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5578,14 +5578,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_SINT16: { - int16* data = NULL; + int16_t* data = NULL; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntrySshortArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5595,14 +5595,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_UINT32: { - uint32* data; + uint32_t* data; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntryLongArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5612,14 +5612,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_SINT32: { - int32* data = NULL; + int32_t* data = NULL; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntrySlongArray(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5629,14 +5629,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_UINT64: { - uint64* data; + uint64_t* data; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntryLong8Array(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5646,14 +5646,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_SINT64: { - int64* data = NULL; + int64_t* data = NULL; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntrySlong8Array(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5670,7 +5670,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5687,7 +5687,7 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5697,14 +5697,14 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) break; case TIFF_SETGET_C32_IFD8: { - uint64* data; + uint64_t* data; assert(fip->field_readcount==TIFF_VARIABLE2); assert(fip->field_passcount==1); err=TIFFReadDirEntryIfd8Array(tif,dp,&data); if (err==TIFFReadDirEntryErrOk) { int m; - m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + m=TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count), data); if (data!=0) _TIFFfree(data); if (!m) @@ -5729,11 +5729,11 @@ TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) * While this routine says "strips", in fact it's also used for tiles. */ static int -TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp) +TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32_t nstrips, uint64_t** lpp) { static const char module[] = "TIFFFetchStripThing"; enum TIFFReadDirEntryErr err; - uint64* data; + uint64_t* data; err=TIFFReadDirEntryLong8ArrayWithLimit(tif,dir,&data,nstrips); if (err!=TIFFReadDirEntryErrOk) { @@ -5741,14 +5741,14 @@ TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp) TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0); return(0); } - if (dir->tdir_count<(uint64)nstrips) + if (dir->tdir_count<(uint64_t)nstrips) { - uint64* resizeddata; + uint64_t* resizeddata; const TIFFField* fip = TIFFFieldWithTag(tif,dir->tdir_tag); const char* pszMax = getenv("LIBTIFF_STRILE_ARRAY_MAX_RESIZE_COUNT"); - uint32 max_nstrips = 1000000; + uint32_t max_nstrips = 1000000; if( pszMax ) - max_nstrips = (uint32) atoi(pszMax); + max_nstrips = (uint32_t) atoi(pszMax); TIFFReadDirEntryOutputErr(tif,TIFFReadDirEntryErrCount, module, fip ? fip->field_name : "unknown tagname", @@ -5760,13 +5760,13 @@ TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp) return(0); } - resizeddata=(uint64*)_TIFFCheckMalloc(tif,nstrips,sizeof(uint64),"for strip array"); + resizeddata=(uint64_t*)_TIFFCheckMalloc(tif, nstrips, sizeof(uint64_t), "for strip array"); if (resizeddata==0) { _TIFFfree(data); return(0); } - _TIFFmemcpy(resizeddata,data,(uint32)dir->tdir_count*sizeof(uint64)); - _TIFFmemset(resizeddata+(uint32)dir->tdir_count,0,(nstrips-(uint32)dir->tdir_count)*sizeof(uint64)); + _TIFFmemcpy(resizeddata,data, (uint32_t)dir->tdir_count * sizeof(uint64_t)); + _TIFFmemset(resizeddata+(uint32_t)dir->tdir_count, 0, (nstrips - (uint32_t)dir->tdir_count) * sizeof(uint64_t)); _TIFFfree(data); data=resizeddata; } @@ -5785,8 +5785,8 @@ TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir) UInt64Aligned_t m; m.l=0; assert(sizeof(double)==8); - assert(sizeof(uint64)==8); - assert(sizeof(uint32)==4); + assert(sizeof(uint64_t) == 8); + assert(sizeof(uint32_t) == 4); if (dir->tdir_count!=1) err=TIFFReadDirEntryErrCount; else if (dir->tdir_type!=TIFF_RATIONAL) @@ -5795,8 +5795,8 @@ TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir) { if (!(tif->tif_flags&TIFF_BIGTIFF)) { - uint32 offset; - offset=*(uint32*)(&dir->tdir_offset); + uint32_t offset; + offset=*(uint32_t*)(&dir->tdir_offset); if (tif->tif_flags&TIFF_SWAB) TIFFSwabLong(&offset); err=TIFFReadDirEntryData(tif,offset,8,m.i); @@ -5832,32 +5832,32 @@ TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir) } } -static void allocChoppedUpStripArrays(TIFF* tif, uint32 nstrips, - uint64 stripbytes, uint32 rowsperstrip) +static void allocChoppedUpStripArrays(TIFF* tif, uint32_t nstrips, + uint64_t stripbytes, uint32_t rowsperstrip) { TIFFDirectory *td = &tif->tif_dir; - uint64 bytecount; - uint64 offset; - uint64 last_offset; - uint64 last_bytecount; - uint32 i; - uint64 *newcounts; - uint64 *newoffsets; + uint64_t bytecount; + uint64_t offset; + uint64_t last_offset; + uint64_t last_bytecount; + uint32_t i; + uint64_t *newcounts; + uint64_t *newoffsets; offset = TIFFGetStrileOffset(tif, 0); last_offset = TIFFGetStrileOffset(tif, td->td_nstrips-1); last_bytecount = TIFFGetStrileByteCount(tif, td->td_nstrips-1); - if( last_offset > TIFF_UINT64_MAX - last_bytecount || + if( last_offset > UINT64_MAX - last_bytecount || last_offset + last_bytecount < offset ) { return; } bytecount = last_offset + last_bytecount - offset; - newcounts = (uint64*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64), - "for chopped \"StripByteCounts\" array"); - newoffsets = (uint64*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64), - "for chopped \"StripOffsets\" array"); + newcounts = (uint64_t*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64_t), + "for chopped \"StripByteCounts\" array"); + newoffsets = (uint64_t*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint64_t), + "for chopped \"StripOffsets\" array"); if (newcounts == NULL || newoffsets == NULL) { /* * Unable to allocate new strip information, give up and use @@ -5911,13 +5911,13 @@ static void ChopUpSingleUncompressedStrip(TIFF* tif) { register TIFFDirectory *td = &tif->tif_dir; - uint64 bytecount; - uint64 offset; - uint32 rowblock; - uint64 rowblockbytes; - uint64 stripbytes; - uint32 nstrips; - uint32 rowsperstrip; + uint64_t bytecount; + uint64_t offset; + uint32_t rowblock; + uint64_t rowblockbytes; + uint64_t stripbytes; + uint32_t nstrips; + uint32_t rowsperstrip; bytecount = TIFFGetStrileByteCount(tif, 0); /* On a newly created file, just re-opened to be filled, we */ @@ -5941,8 +5941,8 @@ ChopUpSingleUncompressedStrip(TIFF* tif) stripbytes = rowblockbytes; rowsperstrip = rowblock; } else if (rowblockbytes > 0 ) { - uint32 rowblocksperstrip; - rowblocksperstrip = (uint32) (STRIP_SIZE_DEFAULT / rowblockbytes); + uint32_t rowblocksperstrip; + rowblocksperstrip = (uint32_t) (STRIP_SIZE_DEFAULT / rowblockbytes); rowsperstrip = rowblocksperstrip * rowblock; stripbytes = rowblocksperstrip * rowblockbytes; } @@ -5981,14 +5981,14 @@ ChopUpSingleUncompressedStrip(TIFF* tif) static void TryChopUpUncompressedBigTiff( TIFF* tif ) { TIFFDirectory *td = &tif->tif_dir; - uint32 rowblock; - uint64 rowblockbytes; - uint32 i; - uint64 stripsize; - uint32 rowblocksperstrip; - uint32 rowsperstrip; - uint64 stripbytes; - uint32 nstrips; + uint32_t rowblock; + uint64_t rowblockbytes; + uint32_t i; + uint64_t stripsize; + uint32_t rowblocksperstrip; + uint32_t rowsperstrip; + uint64_t stripbytes; + uint32_t nstrips; stripsize = TIFFStripSize64(tif); @@ -6041,7 +6041,7 @@ static void TryChopUpUncompressedBigTiff( TIFF* tif ) } /* Aim for 512 MB strips (that will still be manageable by 32 bit builds */ - rowblocksperstrip = (uint32) (512 * 1024 * 1024 / rowblockbytes); + rowblocksperstrip = (uint32_t) (512 * 1024 * 1024 / rowblockbytes); if( rowblocksperstrip == 0 ) rowblocksperstrip = 1; rowsperstrip = rowblocksperstrip * rowblock; @@ -6057,9 +6057,9 @@ static void TryChopUpUncompressedBigTiff( TIFF* tif ) if( tif->tif_mode == O_RDONLY && nstrips > 1000000 ) { - uint64 last_offset = TIFFGetStrileOffset(tif, td->td_nstrips-1); - uint64 filesize = TIFFGetFileSize(tif); - uint64 last_bytecount = TIFFGetStrileByteCount(tif, td->td_nstrips-1); + uint64_t last_offset = TIFFGetStrileOffset(tif, td->td_nstrips - 1); + uint64_t filesize = TIFFGetFileSize(tif); + uint64_t last_bytecount = TIFFGetStrileByteCount(tif, td->td_nstrips - 1); if( last_offset > filesize || last_bytecount > filesize - last_offset ) { @@ -6072,7 +6072,7 @@ static void TryChopUpUncompressedBigTiff( TIFF* tif ) TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW -static uint64 _TIFFUnsanitizedAddUInt64AndInt(uint64 a, int b) +static uint64_t _TIFFUnsanitizedAddUInt64AndInt(uint64_t a, int b) { return a + b; } @@ -6082,8 +6082,8 @@ static uint64 _TIFFUnsanitizedAddUInt64AndInt(uint64 a, int b) * 4096 byte page size. */ static -int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, - int strile, uint64* panVals ) +int _TIFFPartialReadStripArray(TIFF* tif, TIFFDirEntry* dirent, + int strile, uint64_t* panVals ) { static const char module[] = "_TIFFPartialReadStripArray"; #define IO_CACHE_PAGE_SIZE 4096 @@ -6091,37 +6091,37 @@ int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, size_t sizeofval; const int bSwab = (tif->tif_flags & TIFF_SWAB) != 0; int sizeofvalint; - uint64 nBaseOffset; - uint64 nOffset; - uint64 nOffsetStartPage; - uint64 nOffsetEndPage; + uint64_t nBaseOffset; + uint64_t nOffset; + uint64_t nOffsetStartPage; + uint64_t nOffsetEndPage; tmsize_t nToRead; tmsize_t nRead; - uint64 nLastStripOffset; + uint64_t nLastStripOffset; int iStartBefore; int i; - const uint32 arraySize = tif->tif_dir.td_stripoffsetbyteallocsize; + const uint32_t arraySize = tif->tif_dir.td_stripoffsetbyteallocsize; unsigned char buffer[2 * IO_CACHE_PAGE_SIZE]; assert( dirent->tdir_count > 4 ); if( dirent->tdir_type == TIFF_SHORT ) { - sizeofval = sizeof(uint16); + sizeofval = sizeof(uint16_t); } else if( dirent->tdir_type == TIFF_LONG ) { - sizeofval = sizeof(uint32); + sizeofval = sizeof(uint32_t); } else if( dirent->tdir_type == TIFF_LONG8 ) { - sizeofval = sizeof(uint64); + sizeofval = sizeof(uint64_t); } else if( dirent->tdir_type == TIFF_SLONG8 ) { /* Non conformant but used by some images as in */ /* https://github.com/OSGeo/gdal/issues/2165 */ - sizeofval = sizeof(int64); + sizeofval = sizeof(int64_t); } else { @@ -6134,20 +6134,20 @@ int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, if( tif->tif_flags&TIFF_BIGTIFF ) { - uint64 offset = dirent->tdir_offset.toff_long8; + uint64_t offset = dirent->tdir_offset.toff_long8; if( bSwab ) TIFFSwabLong8(&offset); nBaseOffset = offset; } else { - uint32 offset = dirent->tdir_offset.toff_long; + uint32_t offset = dirent->tdir_offset.toff_long; if( bSwab ) TIFFSwabLong(&offset); nBaseOffset = offset; } /* To avoid later unsigned integer overflows */ - if( nBaseOffset > (uint64)TIFF_INT64_MAX ) + if( nBaseOffset > (uint64_t)INT64_MAX ) { TIFFErrorExt(tif->tif_clientdata, module, "Cannot read offset/size for strile %d", strile); @@ -6191,13 +6191,13 @@ int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, if( strile + iStartBefore < 0 ) iStartBefore = -strile; for( i = iStartBefore; - (uint32)(strile + i) < arraySize && + (uint32_t)(strile + i) < arraySize && _TIFFUnsanitizedAddUInt64AndInt(nOffset, (i + 1) * sizeofvalint) <= nOffsetEndPage; ++i ) { if( dirent->tdir_type == TIFF_SHORT ) { - uint16 val; + uint16_t val; memcpy(&val, buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint, sizeof(val)); @@ -6207,7 +6207,7 @@ int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, } else if( dirent->tdir_type == TIFF_LONG ) { - uint32 val; + uint32_t val; memcpy(&val, buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint, sizeof(val)); @@ -6217,7 +6217,7 @@ int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, } else if( dirent->tdir_type == TIFF_LONG8 ) { - uint64 val; + uint64_t val; memcpy(&val, buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint, sizeof(val)); @@ -6228,22 +6228,22 @@ int _TIFFPartialReadStripArray( TIFF* tif, TIFFDirEntry* dirent, else /* if( dirent->tdir_type == TIFF_SLONG8 ) */ { /* Non conformant data type */ - int64 val; + int64_t val; memcpy(&val, buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint, sizeof(val)); if( bSwab ) - TIFFSwabLong8((uint64*) &val); - panVals[strile + i] = (uint64) val; + TIFFSwabLong8((uint64_t*) &val); + panVals[strile + i] = (uint64_t) val; } } return 1; } static int _TIFFFetchStrileValue(TIFF* tif, - uint32 strile, + uint32_t strile, TIFFDirEntry* dirent, - uint64** parray) + uint64_t** parray) { static const char module[] = "_TIFFFetchStrileValue"; TIFFDirectory *td = &tif->tif_dir; @@ -6253,20 +6253,20 @@ static int _TIFFFetchStrileValue(TIFF* tif, } if( strile >= td->td_stripoffsetbyteallocsize ) { - uint32 nStripArrayAllocBefore = td->td_stripoffsetbyteallocsize; - uint32 nStripArrayAllocNew; - uint64 nArraySize64; + uint32_t nStripArrayAllocBefore = td->td_stripoffsetbyteallocsize; + uint32_t nStripArrayAllocNew; + uint64_t nArraySize64; size_t nArraySize; - uint64* offsetArray; - uint64* bytecountArray; + uint64_t* offsetArray; + uint64_t* bytecountArray; if( strile > 1000000 ) { - uint64 filesize = TIFFGetFileSize(tif); + uint64_t filesize = TIFFGetFileSize(tif); /* Avoid excessive memory allocation attempt */ /* For such a big blockid we need at least a TIFF_LONG per strile */ /* for the offset array. */ - if( strile > filesize / sizeof(uint32) ) + if( strile > filesize / sizeof(uint32_t) ) { TIFFErrorExt(tif->tif_clientdata, module, "File too short"); return 0; @@ -6288,7 +6288,7 @@ static int _TIFFFetchStrileValue(TIFF* tif, nStripArrayAllocNew = TIFF_MIN(nStripArrayAllocNew, td->td_nstrips); } assert( strile < nStripArrayAllocNew ); - nArraySize64 = (uint64)sizeof(uint64) * nStripArrayAllocNew; + nArraySize64 = (uint64_t)sizeof(uint64_t) * nStripArrayAllocNew; nArraySize = (size_t)(nArraySize64); #if SIZEOF_SIZE_T == 4 if( nArraySize != nArraySize64 ) @@ -6298,9 +6298,9 @@ static int _TIFFFetchStrileValue(TIFF* tif, return 0; } #endif - offsetArray = (uint64*)( + offsetArray = (uint64_t*)( _TIFFrealloc( td->td_stripoffset_p, nArraySize ) ); - bytecountArray = (uint64*)( + bytecountArray = (uint64_t*)( _TIFFrealloc( td->td_stripbytecount_p, nArraySize ) ); if( offsetArray ) td->td_stripoffset_p = offsetArray; @@ -6312,10 +6312,10 @@ static int _TIFFFetchStrileValue(TIFF* tif, /* Initialize new entries to ~0 / -1 */ memset(td->td_stripoffset_p + nStripArrayAllocBefore, 0xFF, - (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) * sizeof(uint64) ); + (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) * sizeof(uint64_t) ); memset(td->td_stripbytecount_p + nStripArrayAllocBefore, 0xFF, - (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) * sizeof(uint64) ); + (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) * sizeof(uint64_t) ); } else { @@ -6343,10 +6343,10 @@ static int _TIFFFetchStrileValue(TIFF* tif, return 1; } -static uint64 _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32 strile, - TIFFDirEntry* dirent, - uint64** parray, - int *pbErr) +static uint64_t _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32_t strile, + TIFFDirEntry* dirent, + uint64_t** parray, + int *pbErr) { TIFFDirectory *td = &tif->tif_dir; if( pbErr ) @@ -6387,13 +6387,13 @@ static uint64 _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32 strile, } /* Return the value of the TileOffsets/StripOffsets array for the specified tile/strile */ -uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile) +uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile) { return TIFFGetStrileOffsetWithErr(tif, strile, NULL); } /* Return the value of the TileOffsets/StripOffsets array for the specified tile/strile */ -uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr) +uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile, int *pbErr) { TIFFDirectory *td = &tif->tif_dir; return _TIFFGetStrileOffsetOrByteCountValue(tif, strile, @@ -6402,13 +6402,13 @@ uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr) } /* Return the value of the TileByteCounts/StripByteCounts array for the specified tile/strile */ -uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile) +uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile) { return TIFFGetStrileByteCountWithErr(tif, strile, NULL); } /* Return the value of the TileByteCounts/StripByteCounts array for the specified tile/strile */ -uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 strile, int *pbErr) +uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile, int *pbErr) { TIFFDirectory *td = &tif->tif_dir; return _TIFFGetStrileOffsetOrByteCountValue(tif, strile, @@ -6468,7 +6468,7 @@ static int _TIFFFillStrilesInternal( TIFF *tif, int loadStripByteCount ) #ifdef STRIPBYTECOUNTSORTED_UNUSED if (tif->tif_dir.td_nstrips > 1 && return_value == 1 ) { - uint32 strip; + uint32_t strip; tif->tif_dir.td_stripbytecountsorted = 1; for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++) { |