Update libtiff to 4.3.0

Changes to libtiff for gpdl.

1) Ensure that libtiff doesn't mess with 'boolean' in GS builds
on Windows. Without this, the jpeg structures used by our JPEG
lib build are different in size when called from gs and libtiff,
resulting in runtime errors.

2) Update libtiff so that it can correctly call into the jpeg
library so that memory operations happen from our pools, not
malloc/free. Slightly horrid in that this is more complex with
OJPEG than JPEG files.

Fix some compiler warnings stemming from libtiff update

Various tweaks for libtiff 4.3.0 to build on Windows

Mainly "importing" tif_config.vc.h and tiffconf.vc.h - the tiff build now
created those with cmake.

Then typedef'ing several C99 ***_t style types.

Finally defining matching C99 PRI* printf formatting macros

1 files changed, 324 insertions, 324 deletions

diff --git a/tiff/libtiff/tif_ojpeg.c b/tiff/libtiff/tif_ojpeg.c
index d9000764c..102f99401 100644
--- a/tiff/libtiff/tif_ojpeg.c
+++ b/tiff/libtiff/tif_ojpeg.c
@@ -141,7 +141,7 @@
  * 	enough so as to not result in significant call overhead. It should be at least a few
  * 	bytes to accommodate some structures (this is verified in asserts), but it would not be
  * 	sensible to make it this small anyway, and it should be at most 64K since it is indexed
- * 	with uint16. We recommend 2K.
+ * 	with uint16_t. We recommend 2K.
  * EGYPTIANWALK: You could also define EGYPTIANWALK here, but it is not used anywhere and has
  * 	absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly.
  */
@@ -258,118 +258,118 @@ typedef struct {
 	TIFFVGetMethod vgetparent;
 	TIFFVSetMethod vsetparent;
 	TIFFPrintMethod printdir;
-	uint64 file_size;
-	uint32 image_width;
-	uint32 image_length;
-	uint32 strile_width;
-	uint32 strile_length;
-	uint32 strile_length_total;
-	uint8 samples_per_pixel;
-	uint8 plane_sample_offset;
-	uint8 samples_per_pixel_per_plane;
-	uint64 jpeg_interchange_format;
-	uint64 jpeg_interchange_format_length;
-	uint8 jpeg_proc;
-	uint8 subsamplingcorrect;
-	uint8 subsamplingcorrect_done;
-	uint8 subsampling_tag;
-	uint8 subsampling_hor;
-	uint8 subsampling_ver;
-	uint8 subsampling_force_desubsampling_inside_decompression;
-	uint8 qtable_offset_count;
-	uint8 dctable_offset_count;
-	uint8 actable_offset_count;
-	uint64 qtable_offset[3];
-	uint64 dctable_offset[3];
-	uint64 actable_offset[3];
-	uint8* qtable[4];
-	uint8* dctable[4];
-	uint8* actable[4];
-	uint16 restart_interval;
-	uint8 restart_index;
-	uint8 sof_log;
-	uint8 sof_marker_id;
-	uint32 sof_x;
-	uint32 sof_y;
-	uint8 sof_c[3];
-	uint8 sof_hv[3];
-	uint8 sof_tq[3];
-	uint8 sos_cs[3];
-	uint8 sos_tda[3];
+	uint64_t file_size;
+	uint32_t image_width;
+	uint32_t image_length;
+	uint32_t strile_width;
+	uint32_t strile_length;
+	uint32_t strile_length_total;
+	uint8_t samples_per_pixel;
+	uint8_t plane_sample_offset;
+	uint8_t samples_per_pixel_per_plane;
+	uint64_t jpeg_interchange_format;
+	uint64_t jpeg_interchange_format_length;
+	uint8_t jpeg_proc;
+	uint8_t subsamplingcorrect;
+	uint8_t subsamplingcorrect_done;
+	uint8_t subsampling_tag;
+	uint8_t subsampling_hor;
+	uint8_t subsampling_ver;
+	uint8_t subsampling_force_desubsampling_inside_decompression;
+	uint8_t qtable_offset_count;
+	uint8_t dctable_offset_count;
+	uint8_t actable_offset_count;
+	uint64_t qtable_offset[3];
+	uint64_t dctable_offset[3];
+	uint64_t actable_offset[3];
+	uint8_t* qtable[4];
+	uint8_t* dctable[4];
+	uint8_t* actable[4];
+	uint16_t restart_interval;
+	uint8_t restart_index;
+	uint8_t sof_log;
+	uint8_t sof_marker_id;
+	uint32_t sof_x;
+	uint32_t sof_y;
+	uint8_t sof_c[3];
+	uint8_t sof_hv[3];
+	uint8_t sof_tq[3];
+	uint8_t sos_cs[3];
+	uint8_t sos_tda[3];
 	struct {
-		uint8 log;
+		uint8_t log;
 		OJPEGStateInBufferSource in_buffer_source;
-		uint32 in_buffer_next_strile;
-		uint64 in_buffer_file_pos;
-		uint64 in_buffer_file_togo;
+		uint32_t in_buffer_next_strile;
+		uint64_t in_buffer_file_pos;
+		uint64_t in_buffer_file_togo;
 	} sos_end[3];
-	uint8 readheader_done;
-	uint8 writeheader_done;
-	uint16 write_cursample;
-	uint32 write_curstrile;
-	uint8 libjpeg_session_active;
-	uint8 libjpeg_jpeg_query_style;
+	uint8_t readheader_done;
+	uint8_t writeheader_done;
+	uint16_t write_cursample;
+	uint32_t write_curstrile;
+	uint8_t libjpeg_session_active;
+	uint8_t libjpeg_jpeg_query_style;
 	jpeg_error_mgr libjpeg_jpeg_error_mgr;
 	jpeg_decompress_struct libjpeg_jpeg_decompress_struct;
 	jpeg_source_mgr libjpeg_jpeg_source_mgr;
-	uint8 subsampling_convert_log;
-	uint32 subsampling_convert_ylinelen;
-	uint32 subsampling_convert_ylines;
-	uint32 subsampling_convert_clinelen;
-	uint32 subsampling_convert_clines;
-	uint32 subsampling_convert_ybuflen;
-	uint32 subsampling_convert_cbuflen;
-	uint32 subsampling_convert_ycbcrbuflen;
-	uint8* subsampling_convert_ycbcrbuf;
-	uint8* subsampling_convert_ybuf;
-	uint8* subsampling_convert_cbbuf;
-	uint8* subsampling_convert_crbuf;
-	uint32 subsampling_convert_ycbcrimagelen;
-	uint8** subsampling_convert_ycbcrimage;
-	uint32 subsampling_convert_clinelenout;
-	uint32 subsampling_convert_state;
-	uint32 bytes_per_line;   /* if the codec outputs subsampled data, a 'line' in bytes_per_line */
-	uint32 lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows     */
+	uint8_t subsampling_convert_log;
+	uint32_t subsampling_convert_ylinelen;
+	uint32_t subsampling_convert_ylines;
+	uint32_t subsampling_convert_clinelen;
+	uint32_t subsampling_convert_clines;
+	uint32_t subsampling_convert_ybuflen;
+	uint32_t subsampling_convert_cbuflen;
+	uint32_t subsampling_convert_ycbcrbuflen;
+	uint8_t* subsampling_convert_ycbcrbuf;
+	uint8_t* subsampling_convert_ybuf;
+	uint8_t* subsampling_convert_cbbuf;
+	uint8_t* subsampling_convert_crbuf;
+	uint32_t subsampling_convert_ycbcrimagelen;
+	uint8_t** subsampling_convert_ycbcrimage;
+	uint32_t subsampling_convert_clinelenout;
+	uint32_t subsampling_convert_state;
+	uint32_t bytes_per_line;   /* if the codec outputs subsampled data, a 'line' in bytes_per_line */
+	uint32_t lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows     */
 	OJPEGStateInBufferSource in_buffer_source;
-	uint32 in_buffer_next_strile;
-	uint32 in_buffer_strile_count;
-	uint64 in_buffer_file_pos;
-	uint8 in_buffer_file_pos_log;
-	uint64 in_buffer_file_togo;
-	uint16 in_buffer_togo;
-	uint8* in_buffer_cur;
-	uint8 in_buffer[OJPEG_BUFFER];
+	uint32_t in_buffer_next_strile;
+	uint32_t in_buffer_strile_count;
+	uint64_t in_buffer_file_pos;
+	uint8_t in_buffer_file_pos_log;
+	uint64_t in_buffer_file_togo;
+	uint16_t in_buffer_togo;
+	uint8_t* in_buffer_cur;
+	uint8_t in_buffer[OJPEG_BUFFER];
 	OJPEGStateOutState out_state;
-	uint8 out_buffer[OJPEG_BUFFER];
-	uint8* skip_buffer;
+	uint8_t out_buffer[OJPEG_BUFFER];
+	uint8_t* skip_buffer;
 #ifdef GS_TIFF_BUILD
 	jpeg_cust_mem_data jmem;
 	jpeg_cust_mem_data *jmem_parent;
 #endif
 } OJPEGState;
 
-static int OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap);
-static int OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap);
+static int OJPEGVGetField(TIFF* tif, uint32_t tag, va_list ap);
+static int OJPEGVSetField(TIFF* tif, uint32_t tag, va_list ap);
 static void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags);
 
 static int OJPEGFixupTags(TIFF* tif);
 static int OJPEGSetupDecode(TIFF* tif);
-static int OJPEGPreDecode(TIFF* tif, uint16 s);
+static int OJPEGPreDecode(TIFF* tif, uint16_t s);
 static int OJPEGPreDecodeSkipRaw(TIFF* tif);
 static int OJPEGPreDecodeSkipScanlines(TIFF* tif);
-static int OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
-static int OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc);
-static int OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc);
-static void OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
+static int OJPEGDecode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s);
+static int OJPEGDecodeRaw(TIFF* tif, uint8_t* buf, tmsize_t cc);
+static int OJPEGDecodeScanlines(TIFF* tif, uint8_t* buf, tmsize_t cc);
+static void OJPEGPostDecode(TIFF* tif, uint8_t* buf, tmsize_t cc);
 static int OJPEGSetupEncode(TIFF* tif);
-static int OJPEGPreEncode(TIFF* tif, uint16 s);
-static int OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
+static int OJPEGPreEncode(TIFF* tif, uint16_t s);
+static int OJPEGEncode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s);
 static int OJPEGPostEncode(TIFF* tif);
 static void OJPEGCleanup(TIFF* tif);
 
 static void OJPEGSubsamplingCorrect(TIFF* tif);
 static int OJPEGReadHeaderInfo(TIFF* tif);
-static int OJPEGReadSecondarySos(TIFF* tif, uint16 s);
+static int OJPEGReadSecondarySos(TIFF* tif, uint16_t s);
 static int OJPEGWriteHeaderInfo(TIFF* tif);
 static void OJPEGLibjpegSessionAbort(TIFF* tif);
 
@@ -377,45 +377,45 @@ static int OJPEGReadHeaderInfoSec(TIFF* tif);
 static int OJPEGReadHeaderInfoSecStreamDri(TIFF* tif);
 static int OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif);
 static int OJPEGReadHeaderInfoSecStreamDht(TIFF* tif);
-static int OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id);
+static int OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8_t marker_id);
 static int OJPEGReadHeaderInfoSecStreamSos(TIFF* tif);
 static int OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif);
 static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif);
 static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif);
 
 static int OJPEGReadBufferFill(OJPEGState* sp);
-static int OJPEGReadByte(OJPEGState* sp, uint8* byte);
-static int OJPEGReadBytePeek(OJPEGState* sp, uint8* byte);
+static int OJPEGReadByte(OJPEGState* sp, uint8_t* byte);
+static int OJPEGReadBytePeek(OJPEGState* sp, uint8_t* byte);
 static void OJPEGReadByteAdvance(OJPEGState* sp);
-static int OJPEGReadWord(OJPEGState* sp, uint16* word);
-static int OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem);
-static void OJPEGReadSkip(OJPEGState* sp, uint16 len);
-
-static int OJPEGWriteStream(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
-static void OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
-static void OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
-static void OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len);
-static int OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len);
-static void OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len);
+static int OJPEGReadWord(OJPEGState* sp, uint16_t* word);
+static int OJPEGReadBlock(OJPEGState* sp, uint16_t len, void* mem);
+static void OJPEGReadSkip(OJPEGState* sp, uint16_t len);
+
+static int OJPEGWriteStream(TIFF* tif, void** mem, uint32_t* len);
+static void OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32_t* len);
+static void OJPEGWriteStreamQTable(TIFF* tif, uint8_t table_index, void** mem, uint32_t* len);
+static void OJPEGWriteStreamDcTable(TIFF* tif, uint8_t table_index, void** mem, uint32_t* len);
+static void OJPEGWriteStreamAcTable(TIFF* tif, uint8_t table_index, void** mem, uint32_t* len);
+static void OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32_t* len);
+static void OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32_t* len);
+static void OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32_t* len);
+static int OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32_t* len);
+static void OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32_t* len);
+static void OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32_t* len);
 
 #ifdef LIBJPEG_ENCAP_EXTERNAL
 extern int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
-extern int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
+extern int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8_t require_image);
 extern int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
-extern int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
-extern int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
+extern int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32_t max_lines);
+extern int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32_t max_lines);
 extern void jpeg_encap_unwind(TIFF* tif);
 #else
 static int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* j);
-static int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
+static int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8_t require_image);
 static int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
-static int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
-static int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
+static int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32_t max_lines);
+static int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32_t max_lines);
 static void jpeg_encap_unwind(TIFF* tif);
 #endif
 
@@ -473,7 +473,7 @@ TIFFInitOJPEG(TIFF* tif, int scheme)
 	tif->tif_encodestrip=OJPEGEncode;  
 	tif->tif_encodetile=OJPEGEncode;  
 	tif->tif_cleanup=OJPEGCleanup;
-	tif->tif_data=(uint8*)sp;
+	tif->tif_data=(uint8_t*)sp;
 	/* tif tag methods */
 	sp->vgetparent=tif->tif_tagmethods.vgetfield;
 	tif->tif_tagmethods.vgetfield=OJPEGVGetField;
@@ -492,40 +492,40 @@ TIFFInitOJPEG(TIFF* tif, int scheme)
 }
 
 static int
-OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
+OJPEGVGetField(TIFF* tif, uint32_t tag, va_list ap)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	switch(tag)
 	{
 		case TIFFTAG_JPEGIFOFFSET:
-			*va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format;
+			*va_arg(ap, uint64_t*)=(uint64_t)sp->jpeg_interchange_format;
 			break;
 		case TIFFTAG_JPEGIFBYTECOUNT:
-			*va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format_length;
+			*va_arg(ap, uint64_t*)=(uint64_t)sp->jpeg_interchange_format_length;
 			break;
 		case TIFFTAG_YCBCRSUBSAMPLING:
 			if (sp->subsamplingcorrect_done==0)
 				OJPEGSubsamplingCorrect(tif);
-			*va_arg(ap,uint16*)=(uint16)sp->subsampling_hor;
-			*va_arg(ap,uint16*)=(uint16)sp->subsampling_ver;
+			*va_arg(ap, uint16_t*)=(uint16_t)sp->subsampling_hor;
+			*va_arg(ap, uint16_t*)=(uint16_t)sp->subsampling_ver;
 			break;
 		case TIFFTAG_JPEGQTABLES:
-			*va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count;
+			*va_arg(ap, uint32_t*)=(uint32_t)sp->qtable_offset_count;
 			*va_arg(ap,const void**)=(const void*)sp->qtable_offset;
 			break;
 		case TIFFTAG_JPEGDCTABLES:
-			*va_arg(ap,uint32*)=(uint32)sp->dctable_offset_count;
+			*va_arg(ap, uint32_t*)=(uint32_t)sp->dctable_offset_count;
 			*va_arg(ap,const void**)=(const void*)sp->dctable_offset;
 			break;
 		case TIFFTAG_JPEGACTABLES:
-			*va_arg(ap,uint32*)=(uint32)sp->actable_offset_count;
+			*va_arg(ap, uint32_t*)=(uint32_t)sp->actable_offset_count;
 			*va_arg(ap,const void**)=(const void*)sp->actable_offset;
 			break;
 		case TIFFTAG_JPEGPROC:
-			*va_arg(ap,uint16*)=(uint16)sp->jpeg_proc;
+			*va_arg(ap, uint16_t*)=(uint16_t)sp->jpeg_proc;
 			break;
 		case TIFFTAG_JPEGRESTARTINTERVAL:
-			*va_arg(ap,uint16*)=sp->restart_interval;
+			*va_arg(ap, uint16_t*)=sp->restart_interval;
 			break;
 		default:
 			return (*sp->vgetparent)(tif,tag,ap);
@@ -534,32 +534,32 @@ OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
 }
 
 static int
-OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
+OJPEGVSetField(TIFF* tif, uint32_t tag, va_list ap)
 {
 	static const char module[]="OJPEGVSetField";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint32 ma;
-	uint64* mb;
-	uint32 n;
+	uint32_t ma;
+	uint64_t* mb;
+	uint32_t n;
 	const TIFFField* fip;
 
 	switch(tag)
 	{
 		case TIFFTAG_JPEGIFOFFSET:
-			sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
+			sp->jpeg_interchange_format=(uint64_t)va_arg(ap, uint64_t);
 			break;
 		case TIFFTAG_JPEGIFBYTECOUNT:
-			sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
+			sp->jpeg_interchange_format_length=(uint64_t)va_arg(ap, uint64_t);
 			break;
 		case TIFFTAG_YCBCRSUBSAMPLING:
 			sp->subsampling_tag=1;
-			sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap);
-			sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap);
+			sp->subsampling_hor=(uint8_t)va_arg(ap, uint16_vap);
+			sp->subsampling_ver=(uint8_t)va_arg(ap, uint16_vap);
 			tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor;
 			tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver;
 			break;
 		case TIFFTAG_JPEGQTABLES:
-			ma=(uint32)va_arg(ap,uint32);
+			ma=(uint32_t)va_arg(ap, uint32_t);
 			if (ma!=0)
 			{
 				if (ma>3)
@@ -567,14 +567,14 @@ OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
 					TIFFErrorExt(tif->tif_clientdata,module,"JpegQTables tag has incorrect count");
 					return(0);
 				}
-				sp->qtable_offset_count=(uint8)ma;
-				mb=(uint64*)va_arg(ap,uint64*);
+				sp->qtable_offset_count=(uint8_t)ma;
+				mb=(uint64_t*)va_arg(ap, uint64_t*);
 				for (n=0; n<ma; n++)
 					sp->qtable_offset[n]=mb[n];
 			}
 			break;
 		case TIFFTAG_JPEGDCTABLES:
-			ma=(uint32)va_arg(ap,uint32);
+			ma=(uint32_t)va_arg(ap, uint32_t);
 			if (ma!=0)
 			{
 				if (ma>3)
@@ -582,14 +582,14 @@ OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
 					TIFFErrorExt(tif->tif_clientdata,module,"JpegDcTables tag has incorrect count");
 					return(0);
 				}
-				sp->dctable_offset_count=(uint8)ma;
-				mb=(uint64*)va_arg(ap,uint64*);
+				sp->dctable_offset_count=(uint8_t)ma;
+				mb=(uint64_t*)va_arg(ap, uint64_t*);
 				for (n=0; n<ma; n++)
 					sp->dctable_offset[n]=mb[n];
 			}
 			break;
 		case TIFFTAG_JPEGACTABLES:
-			ma=(uint32)va_arg(ap,uint32);
+			ma=(uint32_t)va_arg(ap, uint32_t);
 			if (ma!=0)
 			{
 				if (ma>3)
@@ -597,17 +597,17 @@ OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
 					TIFFErrorExt(tif->tif_clientdata,module,"JpegAcTables tag has incorrect count");
 					return(0);
 				}
-				sp->actable_offset_count=(uint8)ma;
-				mb=(uint64*)va_arg(ap,uint64*);
+				sp->actable_offset_count=(uint8_t)ma;
+				mb=(uint64_t*)va_arg(ap, uint64_t*);
 				for (n=0; n<ma; n++)
 					sp->actable_offset[n]=mb[n];
 			}
 			break;
 		case TIFFTAG_JPEGPROC:
-			sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
+			sp->jpeg_proc=(uint8_t)va_arg(ap, uint16_vap);
 			break;
 		case TIFFTAG_JPEGRESTARTINTERVAL:
-			sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
+			sp->restart_interval=(uint16_t)va_arg(ap, uint16_vap);
 			break;
 		default:
 			return (*sp->vsetparent)(tif,tag,ap);
@@ -624,38 +624,38 @@ static void
 OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
+	uint8_t m;
 	(void)flags;
 	assert(sp!=NULL);
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
-		fprintf(fd,"  JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format);  
+		fprintf(fd,"  JpegInterchangeFormat: %" PRIu64 "\n",(uint64_t)sp->jpeg_interchange_format);
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
-		fprintf(fd,"  JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length);  
+		fprintf(fd,"  JpegInterchangeFormatLength: %" PRIu64 "\n",(uint64_t)sp->jpeg_interchange_format_length);
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES))
 	{
 		fprintf(fd,"  JpegQTables:");
 		for (m=0; m<sp->qtable_offset_count; m++)
-			fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]);
+			fprintf(fd," %" PRIu64,(uint64_t)sp->qtable_offset[m]);
 		fprintf(fd,"\n");
 	}
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES))
 	{
 		fprintf(fd,"  JpegDcTables:");
 		for (m=0; m<sp->dctable_offset_count; m++)
-			fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]);
+			fprintf(fd," %" PRIu64,(uint64_t)sp->dctable_offset[m]);
 		fprintf(fd,"\n");
 	}
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES))
 	{
 		fprintf(fd,"  JpegAcTables:");
 		for (m=0; m<sp->actable_offset_count; m++)
-			fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]);
+			fprintf(fd," %" PRIu64,(uint64_t)sp->actable_offset[m]);
 		fprintf(fd,"\n");
 	}
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC))
-		fprintf(fd,"  JpegProc: %u\n",(unsigned int)sp->jpeg_proc);
+		fprintf(fd,"  JpegProc: %"PRIu8"\n", sp->jpeg_proc);
 	if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL))
-		fprintf(fd,"  JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval);
+		fprintf(fd,"  JpegRestartInterval: %"PRIu16"\n", sp->restart_interval);
 	if (sp->printdir)
 		(*sp->printdir)(tif, fd, flags);
 }
@@ -676,10 +676,10 @@ OJPEGSetupDecode(TIFF* tif)
 }
 
 static int
-OJPEGPreDecode(TIFF* tif, uint16 s)
+OJPEGPreDecode(TIFF* tif, uint16_t s)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint32 m;
+	uint32_t m;
 	if (sp->subsamplingcorrect_done==0)
 		OJPEGSubsamplingCorrect(tif);
 	if (sp->readheader_done==0)
@@ -704,7 +704,7 @@ OJPEGPreDecode(TIFF* tif, uint16 s)
 	}
 	if (sp->writeheader_done==0)
 	{
-		sp->plane_sample_offset=(uint8)s;
+		sp->plane_sample_offset=(uint8_t)s;
 		sp->write_cursample=s;
 		sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
 		if ((sp->in_buffer_file_pos_log==0) ||
@@ -743,7 +743,7 @@ static int
 OJPEGPreDecodeSkipRaw(TIFF* tif)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint32 m;
+	uint32_t m;
 	m=sp->lines_per_strile;
 	if (sp->subsampling_convert_state!=0)
 	{
@@ -778,7 +778,7 @@ OJPEGPreDecodeSkipScanlines(TIFF* tif)
 {
 	static const char module[]="OJPEGPreDecodeSkipScanlines";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint32 m;
+	uint32_t m;
 	if (sp->skip_buffer==NULL)
 	{
 		sp->skip_buffer=_TIFFmalloc(sp->bytes_per_line);
@@ -797,7 +797,7 @@ OJPEGPreDecodeSkipScanlines(TIFF* tif)
 }
 
 static int
-OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
+OJPEGDecode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s)
 {
         static const char module[]="OJPEGDecode";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
@@ -825,19 +825,19 @@ OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 }
 
 static int
-OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc)
+OJPEGDecodeRaw(TIFF* tif, uint8_t* buf, tmsize_t cc)
 {
 	static const char module[]="OJPEGDecodeRaw";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8* m;
+	uint8_t* m;
 	tmsize_t n;
-	uint8* oy;
-	uint8* ocb;
-	uint8* ocr;
-	uint8* p;
-	uint32 q;
-	uint8* r;
-	uint8 sx,sy;
+	uint8_t* oy;
+	uint8_t* ocb;
+	uint8_t* ocr;
+	uint8_t* p;
+	uint32_t q;
+	uint8_t* r;
+	uint8_t sx,sy;
 	if (cc%sp->bytes_per_line!=0)
 	{
 		TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
@@ -883,11 +883,11 @@ OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc)
 }
 
 static int
-OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc)
+OJPEGDecodeScanlines(TIFF* tif, uint8_t* buf, tmsize_t cc)
 {
 	static const char module[]="OJPEGDecodeScanlines";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8* m;
+	uint8_t* m;
 	tmsize_t n;
 	if (cc%sp->bytes_per_line!=0)
 	{
@@ -908,7 +908,7 @@ OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc)
 }
 
 static void
-OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc)
+OJPEGPostDecode(TIFF* tif, uint8_t* buf, tmsize_t cc)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	(void)buf;
@@ -931,7 +931,7 @@ OJPEGSetupEncode(TIFF* tif)
 }
 
 static int
-OJPEGPreEncode(TIFF* tif, uint16 s)
+OJPEGPreEncode(TIFF* tif, uint16_t s)
 {
 	static const char module[]="OJPEGPreEncode";
 	(void)s;
@@ -940,7 +940,7 @@ OJPEGPreEncode(TIFF* tif, uint16 s)
 }
 
 static int
-OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
+OJPEGEncode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s)
 {
 	static const char module[]="OJPEGEncode";
 	(void)buf;
@@ -1010,8 +1010,8 @@ OJPEGSubsamplingCorrect(TIFF* tif)
 {
 	static const char module[]="OJPEGSubsamplingCorrect";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 mh;
-	uint8 mv;
+	uint8_t mh;
+	uint8_t mv;
         
 	assert(sp->subsamplingcorrect_done==0);
 	if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) &&
@@ -1039,21 +1039,21 @@ OJPEGSubsamplingCorrect(TIFF* tif)
 		if (((sp->subsampling_hor!=mh) || (sp->subsampling_ver!=mv)) && (sp->subsampling_force_desubsampling_inside_decompression==0))
 		{
 			if (sp->subsampling_tag==0)
-				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data [%d,%d] does not match default values [2,2]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver);
+				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data [%"PRIu8",%"PRIu8"] does not match default values [2,2]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver);
 			else
-				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data [%d,%d] does not match subsampling tag values [%d,%d]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver,mh,mv);
+				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data [%"PRIu8",%"PRIu8"] does not match subsampling tag values [%"PRIu8",%"PRIu8"]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver,mh,mv);
 		}
 		if (sp->subsampling_force_desubsampling_inside_decompression!=0)
 		{
 			if (sp->subsampling_tag==0)
 				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data does not match default values [2,2] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression");
 			else
-				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data does not match subsampling tag values [%d,%d] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression",mh,mv);
+				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data does not match subsampling tag values [%"PRIu8",%"PRIu8"] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression",mh,mv);
 		}
 		if (sp->subsampling_force_desubsampling_inside_decompression==0)
 		{
 			if (sp->subsampling_hor<sp->subsampling_ver)
-				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling values [%d,%d] are not allowed in TIFF",sp->subsampling_hor,sp->subsampling_ver);
+				TIFFWarningExt(tif->tif_clientdata,module,"Subsampling values [%"PRIu8",%"PRIu8"] are not allowed in TIFF",sp->subsampling_hor,sp->subsampling_ver);
 		}
 	}
 	sp->subsamplingcorrect_done=1;
@@ -1077,7 +1077,7 @@ OJPEGReadHeaderInfo(TIFF* tif)
 	{
 		sp->strile_width=sp->image_width;
 		sp->strile_length=tif->tif_dir.td_rowsperstrip;
-                if( sp->strile_length == (uint32)-1 )
+                if( sp->strile_length == (uint32_t)-1 )
                     sp->strile_length = sp->image_length;
 		sp->strile_length_total=sp->image_length;
 	}
@@ -1093,7 +1093,7 @@ OJPEGReadHeaderInfo(TIFF* tif)
 	{
 		if (tif->tif_dir.td_samplesperpixel!=3)
 		{
-			TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel);
+			TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %"PRIu8" not supported for this compression scheme",sp->samples_per_pixel);
 			return(0);
 		}
 		sp->samples_per_pixel=3;
@@ -1116,7 +1116,7 @@ OJPEGReadHeaderInfo(TIFF* tif)
 			TIFFErrorExt(tif->tif_clientdata,module,"Incompatible vertical subsampling and image strip/tile length");
 			return(0);
 		}
-		sp->restart_interval=(uint16)(((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8))*(sp->strile_length/(sp->subsampling_ver*8)));
+		sp->restart_interval=(uint16_t)(((sp->strile_width + sp->subsampling_hor * 8 - 1) / (sp->subsampling_hor * 8)) * (sp->strile_length / (sp->subsampling_ver * 8)));
 	}
 	if (OJPEGReadHeaderInfoSec(tif)==0)
 		return(0);
@@ -1130,15 +1130,15 @@ OJPEGReadHeaderInfo(TIFF* tif)
 }
 
 static int
-OJPEGReadSecondarySos(TIFF* tif, uint16 s)
+OJPEGReadSecondarySos(TIFF* tif, uint16_t s)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
+	uint8_t m;
 	assert(s>0);
 	assert(s<3);
 	assert(sp->sos_end[0].log!=0);
 	assert(sp->sos_end[s].log==0);
-	sp->plane_sample_offset=(uint8)(s-1);
+	sp->plane_sample_offset=(uint8_t)(s - 1);
 	while(sp->sos_end[sp->plane_sample_offset].log==0)
 		sp->plane_sample_offset--;
 	sp->in_buffer_source=sp->sos_end[sp->plane_sample_offset].in_buffer_source;
@@ -1269,8 +1269,8 @@ OJPEGWriteHeaderInfo(TIFF* tif)
 {
 	static const char module[]="OJPEGWriteHeaderInfo";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8** m;
-	uint32 n;
+	uint8_t** m;
+	uint32_t n;
 	/* if a previous attempt failed, don't try again */
 	if (sp->libjpeg_session_active != 0) 
 		return 0;
@@ -1337,16 +1337,16 @@ OJPEGWriteHeaderInfo(TIFF* tif)
 			sp->subsampling_convert_cbbuf=sp->subsampling_convert_ybuf+sp->subsampling_convert_ybuflen;
 			sp->subsampling_convert_crbuf=sp->subsampling_convert_cbbuf+sp->subsampling_convert_cbuflen;
 			sp->subsampling_convert_ycbcrimagelen=3+sp->subsampling_convert_ylines+2*sp->subsampling_convert_clines;
-			sp->subsampling_convert_ycbcrimage=_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen*sizeof(uint8*));
+			sp->subsampling_convert_ycbcrimage=_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen*sizeof(uint8_t*));
 			if (sp->subsampling_convert_ycbcrimage==0)
 			{
 				TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 				return(0);
 			}
 			m=sp->subsampling_convert_ycbcrimage;
-			*m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3);
-			*m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines);
-			*m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines+sp->subsampling_convert_clines);
+			*m++=(uint8_t*)(sp->subsampling_convert_ycbcrimage + 3);
+			*m++=(uint8_t*)(sp->subsampling_convert_ycbcrimage + 3 + sp->subsampling_convert_ylines);
+			*m++=(uint8_t*)(sp->subsampling_convert_ycbcrimage + 3 + sp->subsampling_convert_ylines + sp->subsampling_convert_clines);
 			for (n=0; n<sp->subsampling_convert_ylines; n++)
 				*m++=sp->subsampling_convert_ybuf+n*sp->subsampling_convert_ylinelen;
 			for (n=0; n<sp->subsampling_convert_clines; n++)
@@ -1373,8 +1373,8 @@ OJPEGWriteHeaderInfo(TIFF* tif)
 		return(0);
         if(sp->libjpeg_jpeg_decompress_struct.image_width != sp->strile_width ) {
             TIFFErrorExt(tif->tif_clientdata,module,
-                         "jpeg_start_decompress() returned image_width = %d, "
-                         "expected %d",
+                         "jpeg_start_decompress() returned image_width = %u, "
+                         "expected %"PRIu32,
                          sp->libjpeg_jpeg_decompress_struct.image_width,
                          sp->strile_width);
             return 0;
@@ -1383,7 +1383,7 @@ OJPEGWriteHeaderInfo(TIFF* tif)
            sp->libjpeg_jpeg_decompress_struct.max_v_samp_factor != sp->subsampling_ver) {
             TIFFErrorExt(tif->tif_clientdata,module,
                          "jpeg_start_decompress() returned max_h_samp_factor = %d "
-                         "and max_v_samp_factor = %d, expected %d and %d",
+                         "and max_v_samp_factor = %d, expected %"PRIu8" and %"PRIu8,
                          sp->libjpeg_jpeg_decompress_struct.max_h_samp_factor,
                          sp->libjpeg_jpeg_decompress_struct.max_v_samp_factor,
                          sp->subsampling_hor,
@@ -1409,9 +1409,9 @@ OJPEGReadHeaderInfoSec(TIFF* tif)
 {
 	static const char module[]="OJPEGReadHeaderInfoSec";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
-	uint16 n;
-	uint8 o;
+	uint8_t m;
+	uint16_t n;
+	uint8_t o;
 	if (sp->file_size==0)
 		sp->file_size=TIFFGetFileSize(tif);
 	if (sp->jpeg_interchange_format!=0)
@@ -1424,7 +1424,7 @@ OJPEGReadHeaderInfoSec(TIFF* tif)
 		else
 		{
 			if ((sp->jpeg_interchange_format_length==0) ||
-                            (sp->jpeg_interchange_format > TIFF_UINT64_MAX - sp->jpeg_interchange_format_length) ||
+                            (sp->jpeg_interchange_format > UINT64_MAX - sp->jpeg_interchange_format_length) ||
                             (sp->jpeg_interchange_format+sp->jpeg_interchange_format_length>sp->file_size))
 				sp->jpeg_interchange_format_length=sp->file_size-sp->jpeg_interchange_format;
 		}
@@ -1508,7 +1508,7 @@ OJPEGReadHeaderInfoSec(TIFF* tif)
 					return(0);
 				break;
 			default:
-				TIFFErrorExt(tif->tif_clientdata,module,"Unknown marker type %d in JPEG data",m);
+				TIFFErrorExt(tif->tif_clientdata,module,"Unknown marker type %"PRIu8" in JPEG data", m);
 				return(0);
 		}
 	} while(m!=JPEG_MARKER_SOS);
@@ -1544,7 +1544,7 @@ OJPEGReadHeaderInfoSecStreamDri(TIFF* tif)
            occurred so far */
 	static const char module[]="OJPEGReadHeaderInfoSecStreamDri";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint16 m;
+	uint16_t m;
 	if (OJPEGReadWord(sp,&m)==0)
 		return(0);
 	if (m!=4)
@@ -1564,10 +1564,10 @@ OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
 	/* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
 	static const char module[]="OJPEGReadHeaderInfoSecStreamDqt";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint16 m;
-	uint32 na;
-	uint8* nb;
-	uint8 o;
+	uint16_t m;
+	uint32_t na;
+	uint8_t* nb;
+	uint8_t o;
 	if (OJPEGReadWord(sp,&m)==0)
 		return(0);
 	if (m<=2)
@@ -1588,23 +1588,23 @@ OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
 				TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
 				return(0);
 			}
-			na=sizeof(uint32)+69;
+			na= sizeof(uint32_t) + 69;
 			nb=_TIFFmalloc(na);
 			if (nb==0)
 			{
 				TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 				return(0);
 			}
-			*(uint32*)nb=na;
-			nb[sizeof(uint32)]=255;
-			nb[sizeof(uint32)+1]=JPEG_MARKER_DQT;
-			nb[sizeof(uint32)+2]=0;
-			nb[sizeof(uint32)+3]=67;
-			if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) {
+			*(uint32_t*)nb=na;
+			nb[sizeof(uint32_t)]=255;
+			nb[sizeof(uint32_t) + 1]=JPEG_MARKER_DQT;
+			nb[sizeof(uint32_t) + 2]=0;
+			nb[sizeof(uint32_t) + 3]=67;
+			if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32_t) + 4]) == 0) {
 				_TIFFfree(nb);
 				return(0);
 			}
-			o=nb[sizeof(uint32)+4]&15;
+			o= nb[sizeof(uint32_t) + 4] & 15;
 			if (3<o)
 			{
 				TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
@@ -1627,10 +1627,10 @@ OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
 	/* TODO: the following assumes there is only one table in this marker... but i'm not quite sure that assumption is guaranteed correct */
 	static const char module[]="OJPEGReadHeaderInfoSecStreamDht";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint16 m;
-	uint32 na;
-	uint8* nb;
-	uint8 o;
+	uint16_t m;
+	uint32_t na;
+	uint8_t* nb;
+	uint8_t o;
 	if (OJPEGReadWord(sp,&m)==0)
 		return(0);
 	if (m<=2)
@@ -1645,23 +1645,23 @@ OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
 	}
 	else
 	{
-		na=sizeof(uint32)+2+m;
+		na= sizeof(uint32_t) + 2 + m;
 		nb=_TIFFmalloc(na);
 		if (nb==0)
 		{
 			TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 			return(0);
 		}
-		*(uint32*)nb=na;
-		nb[sizeof(uint32)]=255;
-		nb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
-		nb[sizeof(uint32)+2]=(m>>8);
-		nb[sizeof(uint32)+3]=(m&255);
-		if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0) {
+		*(uint32_t*)nb=na;
+		nb[sizeof(uint32_t)]=255;
+		nb[sizeof(uint32_t) + 1]=JPEG_MARKER_DHT;
+		nb[sizeof(uint32_t) + 2]=(m >> 8);
+		nb[sizeof(uint32_t) + 3]=(m & 255);
+		if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32_t) + 4]) == 0) {
                         _TIFFfree(nb);
 			return(0);
                 }
-		o=nb[sizeof(uint32)+4];
+		o=nb[sizeof(uint32_t) + 4];
 		if ((o&240)==0)
 		{
 			if (3<o)
@@ -1698,16 +1698,16 @@ OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
 }
 
 static int
-OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
+OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8_t marker_id)
 {
 	/* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
 	static const char module[]="OJPEGReadHeaderInfoSecStreamSof";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint16 m;
-	uint16 n;
-	uint8 o;
-	uint16 p;
-	uint16 q;
+	uint16_t m;
+	uint16_t n;
+	uint8_t o;
+	uint16_t p;
+	uint16_t q;
 	if (sp->sof_log!=0)
 	{
 		TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
@@ -1757,7 +1757,7 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
 		/* Y: Number of lines */
 		if (OJPEGReadWord(sp,&p)==0)
 			return(0);
-		if (((uint32)p<sp->image_length) && ((uint32)p<sp->strile_length_total))
+		if (((uint32_t)p < sp->image_length) && ((uint32_t)p < sp->strile_length_total))
 		{
 			TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height");
 			return(0);
@@ -1766,12 +1766,12 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
 		/* X: Number of samples per line */
 		if (OJPEGReadWord(sp,&p)==0)
 			return(0);
-		if (((uint32)p<sp->image_width) && ((uint32)p<sp->strile_width))
+		if (((uint32_t)p < sp->image_width) && ((uint32_t)p < sp->strile_width))
 		{
 			TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
 			return(0);
 		}
-		if ((uint32)p>sp->strile_width)
+		if ((uint32_t)p > sp->strile_width)
 		{
 			TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data image width exceeds expected image width");
 			return(0);
@@ -1855,9 +1855,9 @@ OJPEGReadHeaderInfoSecStreamSos(TIFF* tif)
 	/* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
 	static const char module[]="OJPEGReadHeaderInfoSecStreamSos";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint16 m;
-	uint8 n;
-	uint8 o;
+	uint16_t m;
+	uint8_t n;
+	uint8_t o;
 	assert(sp->subsamplingcorrect==0);
 	if (sp->sof_log==0)
 	{
@@ -1902,11 +1902,11 @@ OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
 {
 	static const char module[]="OJPEGReadHeaderInfoSecTablesQTable";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
-	uint8 n;
-	uint32 oa;
-	uint8* ob;
-	uint32 p;
+	uint8_t m;
+	uint8_t n;
+	uint32_t oa;
+	uint8_t* ob;
+	uint32_t p;
 	if (sp->qtable_offset[0]==0)
 	{
 		TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
@@ -1925,21 +1925,21 @@ OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
 					return(0);
 				}
 			}
-			oa=sizeof(uint32)+69;
+			oa= sizeof(uint32_t) + 69;
 			ob=_TIFFmalloc(oa);
 			if (ob==0)
 			{
 				TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 				return(0);
 			}
-			*(uint32*)ob=oa;
-			ob[sizeof(uint32)]=255;
-			ob[sizeof(uint32)+1]=JPEG_MARKER_DQT;
-			ob[sizeof(uint32)+2]=0;
-			ob[sizeof(uint32)+3]=67;
-			ob[sizeof(uint32)+4]=m;
+			*(uint32_t*)ob=oa;
+			ob[sizeof(uint32_t)]=255;
+			ob[sizeof(uint32_t) + 1]=JPEG_MARKER_DQT;
+			ob[sizeof(uint32_t) + 2]=0;
+			ob[sizeof(uint32_t) + 3]=67;
+			ob[sizeof(uint32_t) + 4]=m;
 			TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET); 
-			p=(uint32)TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
+			p=(uint32_t)TIFFReadFile(tif, &ob[sizeof(uint32_t) + 5], 64);
 			if (p!=64)
                         {
                                 _TIFFfree(ob);
@@ -1961,13 +1961,13 @@ OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif)
 {
 	static const char module[]="OJPEGReadHeaderInfoSecTablesDcTable";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
-	uint8 n;
-	uint8 o[16];
-	uint32 p;
-	uint32 q;
-	uint32 ra;
-	uint8* rb;
+	uint8_t m;
+	uint8_t n;
+	uint8_t o[16];
+	uint32_t p;
+	uint32_t q;
+	uint32_t ra;
+	uint8_t* rb;
 	if (sp->dctable_offset[0]==0)
 	{
 		TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
@@ -1987,28 +1987,28 @@ OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif)
 				}
 			}
 			TIFFSeekFile(tif,sp->dctable_offset[m],SEEK_SET);
-			p=(uint32)TIFFReadFile(tif,o,16);
+			p=(uint32_t)TIFFReadFile(tif, o, 16);
 			if (p!=16)
 				return(0);
 			q=0;
 			for (n=0; n<16; n++)
 				q+=o[n];
-			ra=sizeof(uint32)+21+q;
+			ra= sizeof(uint32_t) + 21 + q;
 			rb=_TIFFmalloc(ra);
 			if (rb==0)
 			{
 				TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 				return(0);
 			}
-			*(uint32*)rb=ra;
-			rb[sizeof(uint32)]=255;
-			rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
-			rb[sizeof(uint32)+2]=(uint8)((19+q)>>8);
-			rb[sizeof(uint32)+3]=((19+q)&255);
-			rb[sizeof(uint32)+4]=m;
+			*(uint32_t*)rb=ra;
+			rb[sizeof(uint32_t)]=255;
+			rb[sizeof(uint32_t) + 1]=JPEG_MARKER_DHT;
+			rb[sizeof(uint32_t) + 2]=(uint8_t)((19 + q) >> 8);
+			rb[sizeof(uint32_t) + 3]=((19 + q) & 255);
+			rb[sizeof(uint32_t) + 4]=m;
 			for (n=0; n<16; n++)
-				rb[sizeof(uint32)+5+n]=o[n];
-			p=(uint32)TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
+				rb[sizeof(uint32_t) + 5 + n]=o[n];
+			p=(uint32_t)TIFFReadFile(tif, &(rb[sizeof(uint32_t) + 21]), q);
 			if (p!=q)
                         {
                                 _TIFFfree(rb);
@@ -2030,13 +2030,13 @@ OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
 {
 	static const char module[]="OJPEGReadHeaderInfoSecTablesAcTable";
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
-	uint8 n;
-	uint8 o[16];
-	uint32 p;
-	uint32 q;
-	uint32 ra;
-	uint8* rb;
+	uint8_t m;
+	uint8_t n;
+	uint8_t o[16];
+	uint32_t p;
+	uint32_t q;
+	uint32_t ra;
+	uint8_t* rb;
 	if (sp->actable_offset[0]==0)
 	{
 		TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
@@ -2056,28 +2056,28 @@ OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
 				}
 			}
 			TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);  
-			p=(uint32)TIFFReadFile(tif,o,16);
+			p=(uint32_t)TIFFReadFile(tif, o, 16);
 			if (p!=16)
 				return(0);
 			q=0;
 			for (n=0; n<16; n++)
 				q+=o[n];
-			ra=sizeof(uint32)+21+q;
+			ra= sizeof(uint32_t) + 21 + q;
 			rb=_TIFFmalloc(ra);
 			if (rb==0)
 			{
 				TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 				return(0);
 			}
-			*(uint32*)rb=ra;
-			rb[sizeof(uint32)]=255;
-			rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
-			rb[sizeof(uint32)+2]=(uint8)((19+q)>>8);
-			rb[sizeof(uint32)+3]=((19+q)&255);
-			rb[sizeof(uint32)+4]=(16|m);
+			*(uint32_t*)rb=ra;
+			rb[sizeof(uint32_t)]=255;
+			rb[sizeof(uint32_t) + 1]=JPEG_MARKER_DHT;
+			rb[sizeof(uint32_t) + 2]=(uint8_t)((19 + q) >> 8);
+			rb[sizeof(uint32_t) + 3]=((19 + q) & 255);
+			rb[sizeof(uint32_t) + 4]=(16 | m);
 			for (n=0; n<16; n++)
-				rb[sizeof(uint32)+5+n]=o[n];
-			p=(uint32)TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
+				rb[sizeof(uint32_t) + 5 + n]=o[n];
+			p=(uint32_t)TIFFReadFile(tif, &(rb[sizeof(uint32_t) + 21]), q);
 			if (p!=q)
                         {
                                 _TIFFfree(rb);
@@ -2097,7 +2097,7 @@ OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
 static int
 OJPEGReadBufferFill(OJPEGState* sp)
 {
-	uint16 m;
+	uint16_t m;
 	tmsize_t n;
 	/* TODO: double-check: when subsamplingcorrect is set, no call to TIFFErrorExt or TIFFWarningExt should be made
 	 * in any other case, seek or read errors should be passed through */
@@ -2111,16 +2111,16 @@ OJPEGReadBufferFill(OJPEGState* sp)
 				sp->in_buffer_file_pos_log=1;
 			}
 			m=OJPEG_BUFFER;
-			if ((uint64)m>sp->in_buffer_file_togo)
-				m=(uint16)sp->in_buffer_file_togo;
+			if ((uint64_t)m > sp->in_buffer_file_togo)
+				m=(uint16_t)sp->in_buffer_file_togo;
 			n=TIFFReadFile(sp->tif,sp->in_buffer,(tmsize_t)m);
 			if (n==0)
 				return(0);
 			assert(n>0);
 			assert(n<=OJPEG_BUFFER);
 			assert(n<65536);
-			assert((uint64)n<=sp->in_buffer_file_togo);
-			m=(uint16)n;
+			assert((uint64_t)n <= sp->in_buffer_file_togo);
+			m=(uint16_t)n;
 			sp->in_buffer_togo=m;
 			sp->in_buffer_cur=sp->in_buffer;
 			sp->in_buffer_file_togo-=m;
@@ -2152,7 +2152,7 @@ OJPEGReadBufferFill(OJPEGState* sp)
 						return 0;
 					if (sp->in_buffer_file_pos!=0)
 					{
-						uint64 bytecount = TIFFGetStrileByteCountWithErr(sp->tif, sp->in_buffer_next_strile, &err);
+						uint64_t bytecount = TIFFGetStrileByteCountWithErr(sp->tif, sp->in_buffer_next_strile, &err);
 						if( err )
 							return 0;
 						if (sp->in_buffer_file_pos>=sp->file_size)
@@ -2164,7 +2164,7 @@ OJPEGReadBufferFill(OJPEGState* sp)
 							sp->in_buffer_file_togo=bytecount;
 							if (sp->in_buffer_file_togo==0)
 								sp->in_buffer_file_pos=0;
-							else if (sp->in_buffer_file_pos > TIFF_UINT64_MAX - sp->in_buffer_file_togo || 
+							else if (sp->in_buffer_file_pos > UINT64_MAX - sp->in_buffer_file_togo ||
                                                                 sp->in_buffer_file_pos+sp->in_buffer_file_togo>sp->file_size)
 								sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
 						}
@@ -2180,7 +2180,7 @@ OJPEGReadBufferFill(OJPEGState* sp)
 }
 
 static int
-OJPEGReadByte(OJPEGState* sp, uint8* byte)
+OJPEGReadByte(OJPEGState* sp, uint8_t* byte)
 {
 	if (sp->in_buffer_togo==0)
 	{
@@ -2195,7 +2195,7 @@ OJPEGReadByte(OJPEGState* sp, uint8* byte)
 }
 
 static int
-OJPEGReadBytePeek(OJPEGState* sp, uint8* byte)
+OJPEGReadBytePeek(OJPEGState* sp, uint8_t* byte)
 {
 	if (sp->in_buffer_togo==0)
 	{
@@ -2216,9 +2216,9 @@ OJPEGReadByteAdvance(OJPEGState* sp)
 }
 
 static int
-OJPEGReadWord(OJPEGState* sp, uint16* word)
+OJPEGReadWord(OJPEGState* sp, uint16_t* word)
 {
-	uint8 m;
+	uint8_t m;
 	if (OJPEGReadByte(sp,&m)==0)
 		return(0);
 	*word=(m<<8);
@@ -2229,11 +2229,11 @@ OJPEGReadWord(OJPEGState* sp, uint16* word)
 }
 
 static int
-OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
+OJPEGReadBlock(OJPEGState* sp, uint16_t len, void* mem)
 {
-	uint16 mlen;
-	uint8* mmem;
-	uint16 n;
+	uint16_t mlen;
+	uint8_t* mmem;
+	uint16_t n;
 	assert(len>0);
 	mlen=len;
 	mmem=mem;
@@ -2258,10 +2258,10 @@ OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
 }
 
 static void
-OJPEGReadSkip(OJPEGState* sp, uint16 len)
+OJPEGReadSkip(OJPEGState* sp, uint16_t len)
 {
-	uint16 m;
-	uint16 n;
+	uint16_t m;
+	uint16_t n;
 	m=len;
 	n=m;
 	if (n>sp->in_buffer_togo)
@@ -2273,8 +2273,8 @@ OJPEGReadSkip(OJPEGState* sp, uint16 len)
 	{
 		assert(sp->in_buffer_togo==0);
 		n=m;
-		if ((uint64)n>sp->in_buffer_file_togo)
-			n=(uint16)sp->in_buffer_file_togo;
+		if ((uint64_t)n > sp->in_buffer_file_togo)
+			n=(uint16_t)sp->in_buffer_file_togo;
 		sp->in_buffer_file_pos+=n;
 		sp->in_buffer_file_togo-=n;
 		sp->in_buffer_file_pos_log=0;
@@ -2288,7 +2288,7 @@ OJPEGReadSkip(OJPEGState* sp, uint16 len)
 }
 
 static int
-OJPEGWriteStream(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStream(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	*len=0;
@@ -2361,7 +2361,7 @@ OJPEGWriteStream(TIFF* tif, void** mem, uint32* len)
 }
 
 static void
-OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	assert(OJPEG_BUFFER>=2);
@@ -2373,43 +2373,43 @@ OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len)
 }
 
 static void
-OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
+OJPEGWriteStreamQTable(TIFF* tif, uint8_t table_index, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	if (sp->qtable[table_index]!=0)
 	{
-		*mem=(void*)(sp->qtable[table_index]+sizeof(uint32));
-		*len=*((uint32*)sp->qtable[table_index])-sizeof(uint32);
+		*mem=(void*)(sp->qtable[table_index]+sizeof(uint32_t));
+		*len= *((uint32_t*)sp->qtable[table_index]) - sizeof(uint32_t);
 	}
 	sp->out_state++;
 }
 
 static void
-OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
+OJPEGWriteStreamDcTable(TIFF* tif, uint8_t table_index, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	if (sp->dctable[table_index]!=0)
 	{
-		*mem=(void*)(sp->dctable[table_index]+sizeof(uint32));
-		*len=*((uint32*)sp->dctable[table_index])-sizeof(uint32);
+		*mem=(void*)(sp->dctable[table_index]+sizeof(uint32_t));
+		*len= *((uint32_t*)sp->dctable[table_index]) - sizeof(uint32_t);
 	}
 	sp->out_state++;
 }
 
 static void
-OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
+OJPEGWriteStreamAcTable(TIFF* tif, uint8_t table_index, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	if (sp->actable[table_index]!=0)
 	{
-		*mem=(void*)(sp->actable[table_index]+sizeof(uint32));
-		*len=*((uint32*)sp->actable[table_index])-sizeof(uint32);
+		*mem=(void*)(sp->actable[table_index]+sizeof(uint32_t));
+		*len= *((uint32_t*)sp->actable[table_index]) - sizeof(uint32_t);
 	}
 	sp->out_state++;
 }
 
 static void
-OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	assert(OJPEG_BUFFER>=6);
@@ -2428,10 +2428,10 @@ OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len)
 }
 
 static void
-OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
+	uint8_t m;
 	assert(OJPEG_BUFFER>=2+8+sp->samples_per_pixel_per_plane*3);
 	assert(255>=8+sp->samples_per_pixel_per_plane*3);
 	sp->out_buffer[0]=255;
@@ -2442,10 +2442,10 @@ OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
 	/* P */
 	sp->out_buffer[4]=8;
 	/* Y */
-	sp->out_buffer[5]=(uint8)(sp->sof_y>>8);
+	sp->out_buffer[5]=(uint8_t)(sp->sof_y >> 8);
 	sp->out_buffer[6]=(sp->sof_y&255);
 	/* X */
-	sp->out_buffer[7]=(uint8)(sp->sof_x>>8);
+	sp->out_buffer[7]=(uint8_t)(sp->sof_x >> 8);
 	sp->out_buffer[8]=(sp->sof_x&255);
 	/* Nf */
 	sp->out_buffer[9]=sp->samples_per_pixel_per_plane;
@@ -2464,10 +2464,10 @@ OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
 }
 
 static void
-OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
-	uint8 m;
+	uint8_t m;
 	assert(OJPEG_BUFFER>=2+6+sp->samples_per_pixel_per_plane*2);
 	assert(255>=6+sp->samples_per_pixel_per_plane*2);
 	sp->out_buffer[0]=255;
@@ -2496,7 +2496,7 @@ OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len)
 }
 
 static int
-OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	if (sp->in_buffer_togo==0)
@@ -2529,7 +2529,7 @@ OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
 }
 
 static void
-OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	assert(OJPEG_BUFFER>=2);
@@ -2544,7 +2544,7 @@ OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len)
 }
 
 static void
-OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len)
+OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32_t* len)
 {
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	assert(OJPEG_BUFFER>=2);
@@ -2569,7 +2569,7 @@ jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
 
 #ifndef LIBJPEG_ENCAP_EXTERNAL
 static int
-jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image)
+jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8_t require_image)
 {
 	if( SETJMP(sp->exit_jmpbuf) )
 		return 0;
@@ -2595,7 +2595,7 @@ jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
 
 #ifndef LIBJPEG_ENCAP_EXTERNAL
 static int
-jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines)
+jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32_t max_lines)
 {
 	if( SETJMP(sp->exit_jmpbuf) )
 		return 0;
@@ -2608,7 +2608,7 @@ jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* s
 
 #ifndef LIBJPEG_ENCAP_EXTERNAL
 static int
-jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines)
+jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32_t max_lines)
 {
 	if( SETJMP(sp->exit_jmpbuf) )
 		return 0;
@@ -2659,7 +2659,7 @@ OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo)
         TIFF *tif = TIFF_FROM_CINFO(cinfo);
 	OJPEGState* sp=(OJPEGState*)tif->tif_data;
 	void* mem=0;
-	uint32 len=0U;
+	uint32_t len=0U;
 	if (OJPEGWriteStream(tif,&mem,&len)==0)
 	{
 		TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");