Merge branch 4.x

3rdparty/libjpeg-turbo/CMakeLists.txt

@@ -16,7 +16,7 @@ endif()
 message(STATUS "libjpeg-turbo: VERSION = ${VERSION}, BUILD = ${BUILD}")
 
 math(EXPR BITS "${CMAKE_SIZEOF_VOID_P} * 8")
-string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} CMAKE_SYSTEM_PROCESSOR_LC)
+string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" CMAKE_SYSTEM_PROCESSOR_LC)
 
 if(CMAKE_SYSTEM_PROCESSOR_LC MATCHES "x86_64" OR
   CMAKE_SYSTEM_PROCESSOR_LC MATCHES "amd64" OR

3rdparty/libjpeg/jcarith.c

@@ -1,7 +1,7 @@
 /*
  * jcarith.c
  *
- * Developed 1997-2019 by Guido Vollbeding.
+ * Developed 1997-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -361,7 +361,7 @@ emit_restart (j_compress_ptr cinfo, int restart_num)
  */
 
 METHODDEF(boolean)
-encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   unsigned char *st;
@@ -450,7 +450,7 @@ encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   const int * natural_order;
@@ -557,7 +557,7 @@ encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   unsigned char *st;
@@ -592,7 +592,7 @@ encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   const int * natural_order;
@@ -691,7 +691,7 @@ encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   const int * natural_order;

3rdparty/libjpeg/jccoefct.c

@@ -2,7 +2,7 @@
  * jccoefct.c
  *
  * Copyright (C) 1994-1997, Thomas G. Lane.
- * Modified 2003-2011 by Guido Vollbeding.
+ * Modified 2003-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -36,16 +36,14 @@ typedef struct {
   struct jpeg_c_coef_controller pub; /* public fields */
 
   JDIMENSION iMCU_row_num;	/* iMCU row # within image */
-  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  JDIMENSION MCU_ctr;		/* counts MCUs processed in current row */
   int MCU_vert_offset;		/* counts MCU rows within iMCU row */
   int MCU_rows_per_iMCU_row;	/* number of such rows needed */
 
   /* For single-pass compression, it's sufficient to buffer just one MCU
-   * (although this may prove a bit slow in practice).  We allocate a
+   * (although this may prove a bit slow in practice).
-   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+   * We append a workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks,
-   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
+   * and reuse it for each MCU constructed and sent.
-   * it's not really very big; this is to keep the module interfaces unchanged
-   * when a large coefficient buffer is necessary.)
    * In multi-pass modes, this array points to the current MCU's blocks
    * within the virtual arrays.
    */
@@ -53,6 +51,9 @@ typedef struct {
 
   /* In multi-pass modes, we need a virtual block array for each component. */
   jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+
+  /* Workspace for single-pass compression (omitted otherwise). */
+  JBLOCK blk_buffer[C_MAX_BLOCKS_IN_MCU];
 } my_coef_controller;
 
 typedef my_coef_controller * my_coef_ptr;
@@ -88,7 +89,7 @@ start_iMCU_row (j_compress_ptr cinfo)
       coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
   }
 
-  coef->mcu_ctr = 0;
+  coef->MCU_ctr = 0;
   coef->MCU_vert_offset = 0;
 }
 
@@ -125,7 +126,6 @@ start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
 #endif
   default:
     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    break;
   }
 }
 
@@ -147,59 +147,56 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   JDIMENSION MCU_col_num;	/* index of current MCU within row */
   JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
   JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
-  int blkn, bi, ci, yindex, yoffset, blockcnt;
+  int ci, xindex, yindex, yoffset, blockcnt;
-  JDIMENSION ypos, xpos;
+  JBLOCKROW blkp;
+  JSAMPARRAY input_ptr;
+  JDIMENSION xpos;
   jpeg_component_info *compptr;
   forward_DCT_ptr forward_DCT;
 
   /* Loop to write as much as one whole iMCU row */
   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
        yoffset++) {
-    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
 	 MCU_col_num++) {
       /* Determine where data comes from in input_buf and do the DCT thing.
-       * Each call on forward_DCT processes a horizontal row of DCT blocks
+       * Each call on forward_DCT processes a horizontal row of DCT blocks as
-       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+       * wide as an MCU.  Dummy blocks at the right or bottom edge are filled in
-       * sequentially.  Dummy blocks at the right or bottom edge are filled in
        * specially.  The data in them does not matter for image reconstruction,
        * so we fill them with values that will encode to the smallest amount of
        * data, viz: all zeroes in the AC entries, DC entries equal to previous
        * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
        */
-      blkn = 0;
+      blkp = coef->blk_buffer;	/* pointer to current DCT block within MCU */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 	compptr = cinfo->cur_comp_info[ci];
 	forward_DCT = cinfo->fdct->forward_DCT[compptr->component_index];
+	input_ptr = input_buf[compptr->component_index] +
+	  yoffset * compptr->DCT_v_scaled_size;
+	/* ypos == (yoffset + yindex) * compptr->DCT_v_scaled_size */
 	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
 						: compptr->last_col_width;
 	xpos = MCU_col_num * compptr->MCU_sample_width;
-	ypos = yoffset * compptr->DCT_v_scaled_size;
-	/* ypos == (yoffset+yindex) * DCTSIZE */
 	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
 	  if (coef->iMCU_row_num < last_iMCU_row ||
-	      yoffset+yindex < compptr->last_row_height) {
+	      yoffset + yindex < compptr->last_row_height) {
-	    (*forward_DCT) (cinfo, compptr,
+	    (*forward_DCT) (cinfo, compptr, input_ptr, blkp,
-			    input_buf[compptr->component_index],
+			    xpos, (JDIMENSION) blockcnt);
-			    coef->MCU_buffer[blkn],
+	    input_ptr += compptr->DCT_v_scaled_size;
-			    ypos, xpos, (JDIMENSION) blockcnt);
+	    blkp += blockcnt;
-	    if (blockcnt < compptr->MCU_width) {
+	    /* Dummy blocks at right edge */
-	      /* Create some dummy blocks at the right edge of the image. */
+	    if ((xindex = compptr->MCU_width - blockcnt) == 0)
-	      FMEMZERO((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+	      continue;
-		       (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
-	      for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
-		coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
-	      }
-	    }
 	  } else {
-	    /* Create a row of dummy blocks at the bottom of the image. */
+	    /* At bottom of image, need a whole row of dummy blocks */
-	    FMEMZERO((void FAR *) coef->MCU_buffer[blkn],
+	    xindex = compptr->MCU_width;
-		     compptr->MCU_width * SIZEOF(JBLOCK));
-	    for (bi = 0; bi < compptr->MCU_width; bi++) {
-	      coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
-	    }
 	  }
-	  blkn += compptr->MCU_width;
+	  /* Fill in any dummy blocks needed in this row */
-	  ypos += compptr->DCT_v_scaled_size;
+	  MEMZERO(blkp, xindex * SIZEOF(JBLOCK));
+	  do {
+	    blkp[0][0] = blkp[-1][0];
+	    blkp++;
+	  } while (--xindex);
 	}
       }
       /* Try to write the MCU.  In event of a suspension failure, we will
@@ -208,12 +205,12 @@ compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
       if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
 	/* Suspension forced; update state counters and exit */
 	coef->MCU_vert_offset = yoffset;
-	coef->mcu_ctr = MCU_col_num;
+	coef->MCU_ctr = MCU_col_num;
 	return FALSE;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->mcu_ctr = 0;
+    coef->MCU_ctr = 0;
   }
   /* Completed the iMCU row, advance counters for next one */
   coef->iMCU_row_num++;
@@ -256,6 +253,7 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   jpeg_component_info *compptr;
   JBLOCKARRAY buffer;
   JBLOCKROW thisblockrow, lastblockrow;
+  JSAMPARRAY input_ptr;
   forward_DCT_ptr forward_DCT;
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
@@ -280,14 +278,15 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
     if (ndummy > 0)
       ndummy = h_samp_factor - ndummy;
     forward_DCT = cinfo->fdct->forward_DCT[ci];
+    input_ptr = input_buf[ci];
     /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
      * on forward_DCT processes a complete horizontal row of DCT blocks.
      */
     for (block_row = 0; block_row < block_rows; block_row++) {
       thisblockrow = buffer[block_row];
-      (*forward_DCT) (cinfo, compptr, input_buf[ci], thisblockrow,
+      (*forward_DCT) (cinfo, compptr, input_ptr, thisblockrow,
-		      (JDIMENSION) (block_row * compptr->DCT_v_scaled_size),
 		      (JDIMENSION) 0, blocks_across);
+      input_ptr += compptr->DCT_v_scaled_size;
       if (ndummy > 0) {
 	/* Create dummy blocks at the right edge of the image. */
 	thisblockrow += blocks_across; /* => first dummy block */
@@ -303,15 +302,14 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      * of the dummy blocks to match the last real block's DC value.
      * This squeezes a few more bytes out of the resulting file...
      */
-    if (coef->iMCU_row_num == last_iMCU_row) {
+    if (block_row < compptr->v_samp_factor) {
       blocks_across += ndummy;	/* include lower right corner */
       MCUs_across = blocks_across / h_samp_factor;
-      for (block_row = block_rows; block_row < compptr->v_samp_factor;
+      do {
-	   block_row++) {
 	thisblockrow = buffer[block_row];
 	lastblockrow = buffer[block_row-1];
 	FMEMZERO((void FAR *) thisblockrow,
-		 (size_t) (blocks_across * SIZEOF(JBLOCK)));
+		 (size_t) blocks_across * SIZEOF(JBLOCK));
 	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
 	  lastDC = lastblockrow[h_samp_factor-1][0];
 	  for (bi = 0; bi < h_samp_factor; bi++) {
@@ -320,7 +318,7 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 	  thisblockrow += h_samp_factor; /* advance to next MCU in row */
 	  lastblockrow += h_samp_factor;
 	}
-      }
+      } while (++block_row < compptr->v_samp_factor);
     }
   }
   /* NB: compress_output will increment iMCU_row_num if successful.
@@ -347,8 +345,9 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 {
   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
   JDIMENSION MCU_col_num;	/* index of current MCU within row */
-  int blkn, ci, xindex, yindex, yoffset;
+  int ci, xindex, yindex, yoffset;
   JDIMENSION start_col;
+  JBLOCKARRAY blkp;
   JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
   JBLOCKROW buffer_ptr;
   jpeg_component_info *compptr;
@@ -368,30 +367,31 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   /* Loop to process one whole iMCU row */
   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
        yoffset++) {
-    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
 	 MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;			/* index of current DCT block within MCU */
+      blkp = coef->MCU_buffer;	/* pointer to current DCT block within MCU */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 	compptr = cinfo->cur_comp_info[ci];
 	start_col = MCU_col_num * compptr->MCU_width;
 	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  buffer_ptr = buffer[ci][yoffset + yindex] + start_col;
-	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	  xindex = compptr->MCU_width;
-	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  do {
-	  }
+	    *blkp++ = buffer_ptr++;
+	  } while (--xindex);
 	}
       }
       /* Try to write the MCU. */
       if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
 	/* Suspension forced; update state counters and exit */
 	coef->MCU_vert_offset = yoffset;
-	coef->mcu_ctr = MCU_col_num;
+	coef->MCU_ctr = MCU_col_num;
 	return FALSE;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->mcu_ctr = 0;
+    coef->MCU_ctr = 0;
   }
   /* Completed the iMCU row, advance counters for next one */
   coef->iMCU_row_num++;
@@ -411,13 +411,6 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 {
   my_coef_ptr coef;
 
-  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(my_coef_controller));
-  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
-  coef->pub.start_pass = start_pass_coef;
-
-  /* Create the coefficient buffer. */
   if (need_full_buffer) {
 #ifdef FULL_COEF_BUFFER_SUPPORTED
     /* Allocate a full-image virtual array for each component, */
@@ -425,6 +418,9 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
     int ci;
     jpeg_component_info *compptr;
 
+    coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       SIZEOF(my_coef_controller) - SIZEOF(coef->blk_buffer));
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 	 ci++, compptr++) {
       coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
@@ -440,15 +436,21 @@ jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
 #endif
   } else {
     /* We only need a single-MCU buffer. */
-    JBLOCKROW buffer;
+    JBLOCKARRAY blkp;
-    int i;
+    JBLOCKROW buffer_ptr;
+    int bi;
 
-    buffer = (JBLOCKROW)
+    coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
-      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller));
-				  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    blkp = coef->MCU_buffer;
-    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+    buffer_ptr = coef->blk_buffer;
-      coef->MCU_buffer[i] = buffer + i;
+    bi = C_MAX_BLOCKS_IN_MCU;
-    }
+    do {
+      *blkp++ = buffer_ptr++;
+    } while (--bi);
     coef->whole_image[0] = NULL; /* flag for no virtual arrays */
   }
+
+  coef->pub.start_pass = start_pass_coef;
+  cinfo->coef = &coef->pub;
 }

3rdparty/libjpeg/jccolor.c

@@ -2,7 +2,7 @@
  * jccolor.c
  *
  * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2011-2019 by Guido Vollbeding.
+ * Modified 2011-2023 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -40,10 +40,10 @@ typedef my_color_converter * my_cconvert_ptr;
  * Note that the derived conversion coefficients given in some of these
  * documents are imprecise.  The general conversion equations are
  *	Y  = Kr * R + (1 - Kr - Kb) * G + Kb * B
- *	Cb = 0.5 * (B - Y) / (1 - Kb)
+ *	Cb = (B - Y) / (1 - Kb) / K
- *	Cr = 0.5 * (R - Y) / (1 - Kr)
+ *	Cr = (R - Y) / (1 - Kr) / K
  * With Kr = 0.299 and Kb = 0.114 (derived according to SMPTE RP 177-1993
- * from the 1953 FCC NTSC primaries and CIE Illuminant C),
+ * from the 1953 FCC NTSC primaries and CIE Illuminant C), K = 2 for sYCC,
  * the conversion equations to be implemented are therefore
  *	Y  =  0.299 * R + 0.587 * G + 0.114 * B
  *	Cb = -0.168735892 * R - 0.331264108 * G + 0.5 * B + CENTERJSAMPLE
@@ -62,8 +62,8 @@ typedef my_color_converter * my_cconvert_ptr;
  * by precalculating the constants times R,G,B for all possible values.
  * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
  * for 9-bit to 12-bit samples it is still acceptable.  It's not very
- * reasonable for 16-bit samples, but if you want lossless storage you
+ * reasonable for 16-bit samples, but if you want lossless storage
- * shouldn't be changing colorspace anyway.
+ * you shouldn't be changing colorspace anyway.
  * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
  * in the tables to save adding them separately in the inner loop.
  */
@@ -110,16 +110,16 @@ rgb_ycc_start (j_compress_ptr cinfo)
   for (i = 0; i <= MAXJSAMPLE; i++) {
     rgb_ycc_tab[i+R_Y_OFF] = FIX(0.299) * i;
     rgb_ycc_tab[i+G_Y_OFF] = FIX(0.587) * i;
-    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.114) * i   + ONE_HALF;
+    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.114) * i + ONE_HALF;
     rgb_ycc_tab[i+R_CB_OFF] = (- FIX(0.168735892)) * i;
     rgb_ycc_tab[i+G_CB_OFF] = (- FIX(0.331264108)) * i;
     /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
      * This ensures that the maximum output will round to MAXJSAMPLE
      * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
      */
-    rgb_ycc_tab[i+B_CB_OFF] = FIX(0.5) * i    + CBCR_OFFSET + ONE_HALF-1;
+    rgb_ycc_tab[i+B_CB_OFF] = (i << (SCALEBITS-1)) + CBCR_OFFSET + ONE_HALF-1;
 /*  B=>Cb and R=>Cr tables are the same
-    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.5) * i    + CBCR_OFFSET + ONE_HALF-1;
+    rgb_ycc_tab[i+R_CR_OFF] = (i << (SCALEBITS-1)) + CBCR_OFFSET + ONE_HALF-1;
 */
     rgb_ycc_tab[i+G_CR_OFF] = (- FIX(0.418687589)) * i;
     rgb_ycc_tab[i+B_CR_OFF] = (- FIX(0.081312411)) * i;
@@ -190,8 +190,8 @@ rgb_ycc_convert (j_compress_ptr cinfo,
 
 /*
  * Convert some rows of samples to the JPEG colorspace.
- * This version handles RGB->grayscale conversion, which is the same
+ * This version handles RGB->grayscale conversion,
- * as the RGB->Y portion of RGB->YCbCr.
+ * which is the same as the RGB->Y portion of RGB->YCbCr.
  * We assume rgb_ycc_start has been called (we only use the Y tables).
  */
 
@@ -201,7 +201,7 @@ rgb_gray_convert (j_compress_ptr cinfo,
 		  JDIMENSION output_row, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
+  register INT32 y;
   register INT32 * ctab = cconvert->rgb_ycc_tab;
   register JSAMPROW inptr;
   register JSAMPROW outptr;
@@ -212,14 +212,11 @@ rgb_gray_convert (j_compress_ptr cinfo,
     inptr = *input_buf++;
     outptr = output_buf[0][output_row++];
     for (col = 0; col < num_cols; col++) {
-      r = GETJSAMPLE(inptr[RGB_RED]);
+      y  = ctab[R_Y_OFF + GETJSAMPLE(inptr[RGB_RED])];
-      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      y += ctab[G_Y_OFF + GETJSAMPLE(inptr[RGB_GREEN])];
-      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      y += ctab[B_Y_OFF + GETJSAMPLE(inptr[RGB_BLUE])];
       inptr += RGB_PIXELSIZE;
-      /* Y */
+      outptr[col] = (JSAMPLE) (y >> SCALEBITS);
-      outptr[col] = (JSAMPLE)
-		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-		 >> SCALEBITS);
     }
   }
 }

3rdparty/libjpeg/jcdctmgr.c

@@ -2,7 +2,7 @@
  * jcdctmgr.c
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2003-2013 by Guido Vollbeding.
+ * Modified 2003-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -66,15 +66,14 @@ typedef union {
  * Perform forward DCT on one or more blocks of a component.
  *
  * The input samples are taken from the sample_data[] array starting at
- * position start_row/start_col, and moving to the right for any additional
+ * position start_col, and moving to the right for any additional blocks.
- * blocks. The quantized coefficients are returned in coef_blocks[].
+ * The quantized coefficients are returned in coef_blocks[].
  */
 
 METHODDEF(void)
 forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
 	     JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-	     JDIMENSION start_row, JDIMENSION start_col,
+	     JDIMENSION start_col, JDIMENSION num_blocks)
-	     JDIMENSION num_blocks)
 /* This version is used for integer DCT implementations. */
 {
   /* This routine is heavily used, so it's worth coding it tightly. */
@@ -84,8 +83,6 @@ forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
   DCTELEM workspace[DCTSIZE2];	/* work area for FDCT subroutine */
   JDIMENSION bi;
 
-  sample_data += start_row;	/* fold in the vertical offset once */
-
   for (bi = 0; bi < num_blocks; bi++, start_col += compptr->DCT_h_scaled_size) {
     /* Perform the DCT */
     (*do_dct) (workspace, sample_data, start_col);
@@ -136,8 +133,7 @@ forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
 METHODDEF(void)
 forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
 		   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-		   JDIMENSION start_row, JDIMENSION start_col,
+		   JDIMENSION start_col, JDIMENSION num_blocks)
-		   JDIMENSION num_blocks)
 /* This version is used for floating-point DCT implementations. */
 {
   /* This routine is heavily used, so it's worth coding it tightly. */
@@ -147,8 +143,6 @@ forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
   FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
   JDIMENSION bi;
 
-  sample_data += start_row;	/* fold in the vertical offset once */
-
   for (bi = 0; bi < num_blocks; bi++, start_col += compptr->DCT_h_scaled_size) {
     /* Perform the DCT */
     (*do_dct) (workspace, sample_data, start_col);
@@ -347,13 +341,11 @@ start_pass_fdctmgr (j_compress_ptr cinfo)
 #endif
       default:
 	ERREXIT(cinfo, JERR_NOT_COMPILED);
-	break;
       }
       break;
     default:
       ERREXIT2(cinfo, JERR_BAD_DCTSIZE,
 	       compptr->DCT_h_scaled_size, compptr->DCT_v_scaled_size);
-      break;
     }
     qtblno = compptr->quant_tbl_no;
     /* Make sure specified quantization table is present */
@@ -444,7 +436,6 @@ start_pass_fdctmgr (j_compress_ptr cinfo)
 #endif
     default:
       ERREXIT(cinfo, JERR_NOT_COMPILED);
-      break;
     }
   }
 }
@@ -461,17 +452,15 @@ jinit_forward_dct (j_compress_ptr cinfo)
   int ci;
   jpeg_component_info *compptr;
 
-  fdct = (my_fdct_ptr)
+  fdct = (my_fdct_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_fdct_controller));
-				SIZEOF(my_fdct_controller));
   cinfo->fdct = &fdct->pub;
   fdct->pub.start_pass = start_pass_fdctmgr;
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
     /* Allocate a divisor table for each component */
-    compptr->dct_table =
+    compptr->dct_table = (*cinfo->mem->alloc_small)
-      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(divisor_table));
-				  SIZEOF(divisor_table));
   }
 }

3rdparty/libjpeg/jchuff.c

@@ -2,7 +2,7 @@
  * jchuff.c
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2006-2019 by Guido Vollbeding.
+ * Modified 2006-2023 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -26,17 +26,11 @@
 
 
 /* The legal range of a DCT coefficient is
- *  -1024 .. +1023  for 8-bit data;
+ *  -1024 .. +1023  for 8-bit sample data precision;
- * -16384 .. +16383 for 12-bit data.
+ * -16384 .. +16383 for 12-bit sample data precision.
- * Hence the magnitude should always fit in 10 or 14 bits respectively.
+ * Hence the magnitude should always fit in sample data precision + 2 bits.
  */
 
-#if BITS_IN_JSAMPLE == 8
-#define MAX_COEF_BITS 10
-#else
-#define MAX_COEF_BITS 14
-#endif
-
 /* Derived data constructed for each Huffman table */
 
 typedef struct {
@@ -542,11 +536,12 @@ emit_restart_e (huff_entropy_ptr entropy, int restart_num)
  */
 
 METHODDEF(boolean)
-encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   register int temp, temp2;
   register int nbits;
+  int max_coef_bits;
   int blkn, ci, tbl;
   ISHIFT_TEMPS
 
@@ -558,6 +553,9 @@ encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     if (entropy->restarts_to_go == 0)
       emit_restart_e(entropy, entropy->next_restart_num);
 
+  /* Since we're encoding a difference, the range limit is twice as much. */
+  max_coef_bits = cinfo->data_precision + 3;
+
   /* Encode the MCU data blocks */
   for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
     ci = cinfo->MCU_membership[blkn];
@@ -569,12 +567,17 @@ encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     temp = IRIGHT_SHIFT((int) (MCU_data[blkn][0][0]), cinfo->Al);
 
     /* DC differences are figured on the point-transformed values. */
-    temp2 = temp - entropy->saved.last_dc_val[ci];
+    if ((temp2 = temp - entropy->saved.last_dc_val[ci]) == 0) {
+      /* Count/emit the Huffman-coded symbol for the number of bits */
+      emit_dc_symbol(entropy, tbl, 0);
+
+      continue;
+    }
+
     entropy->saved.last_dc_val[ci] = temp;
 
     /* Encode the DC coefficient difference per section G.1.2.1 */
-    temp = temp2;
+    if ((temp = temp2) < 0) {
-    if (temp < 0) {
       temp = -temp;		/* temp is abs value of input */
       /* For a negative input, want temp2 = bitwise complement of abs(input) */
       /* This code assumes we are on a two's complement machine */
@@ -583,14 +586,10 @@ encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 
     /* Find the number of bits needed for the magnitude of the coefficient */
     nbits = 0;
-    while (temp) {
+    do nbits++;			/* there must be at least one 1 bit */
-      nbits++;
+    while ((temp >>= 1));
-      temp >>= 1;
+    /* Check for out-of-range coefficient values */
-    }
+    if (nbits > max_coef_bits)
-    /* Check for out-of-range coefficient values.
-     * Since we're encoding a difference, the range limit is twice as much.
-     */
-    if (nbits > MAX_COEF_BITS+1)
       ERREXIT(cinfo, JERR_BAD_DCT_COEF);
 
     /* Count/emit the Huffman-coded symbol for the number of bits */
@@ -598,8 +597,7 @@ encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
 
     /* Emit that number of bits of the value, if positive, */
     /* or the complement of its magnitude, if negative. */
-    if (nbits)			/* emit_bits rejects calls with size 0 */
+    emit_bits_e(entropy, (unsigned int) temp2, nbits);
-      emit_bits_e(entropy, (unsigned int) temp2, nbits);
   }
 
   cinfo->dest->next_output_byte = entropy->next_output_byte;
@@ -625,7 +623,7 @@ encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   const int * natural_order;
@@ -633,7 +631,7 @@ encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
   register int temp, temp2;
   register int nbits;
   register int r, k;
-  int Se, Al;
+  int Se, Al, max_coef_bits;
 
   entropy->next_output_byte = cinfo->dest->next_output_byte;
   entropy->free_in_buffer = cinfo->dest->free_in_buffer;
@@ -646,6 +644,7 @@ encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
   Se = cinfo->Se;
   Al = cinfo->Al;
   natural_order = cinfo->natural_order;
+  max_coef_bits = cinfo->data_precision + 2;
 
   /* Encode the MCU data block */
   block = MCU_data[0];
@@ -666,18 +665,23 @@ encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
      */
     if (temp < 0) {
       temp = -temp;		/* temp is abs value of input */
-      temp >>= Al;		/* apply the point transform */
+      /* Apply the point transform, and watch out for case */
+      /* that nonzero coef is zero after point transform. */
+      if ((temp >>= Al) == 0) {
+	r++;
+	continue;
+      }
       /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
       temp2 = ~temp;
     } else {
-      temp >>= Al;		/* apply the point transform */
+      /* Apply the point transform, and watch out for case */
+      /* that nonzero coef is zero after point transform. */
+      if ((temp >>= Al) == 0) {
+	r++;
+	continue;
+      }
       temp2 = temp;
     }
-    /* Watch out for case that nonzero coef is zero after point transform */
-    if (temp == 0) {
-      r++;
-      continue;
-    }
 
     /* Emit any pending EOBRUN */
     if (entropy->EOBRUN > 0)
@@ -689,11 +693,11 @@ encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
     }
 
     /* Find the number of bits needed for the magnitude of the coefficient */
-    nbits = 1;			/* there must be at least one 1 bit */
+    nbits = 0;
-    while ((temp >>= 1))
+    do nbits++;			/* there must be at least one 1 bit */
-      nbits++;
+    while ((temp >>= 1));
     /* Check for out-of-range coefficient values */
-    if (nbits > MAX_COEF_BITS)
+    if (nbits > max_coef_bits)
       ERREXIT(cinfo, JERR_BAD_DCT_COEF);
 
     /* Count/emit Huffman symbol for run length / number of bits */
@@ -736,7 +740,7 @@ encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   int Al, blkn;
@@ -779,7 +783,7 @@ encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   const int * natural_order;
@@ -916,83 +920,89 @@ encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
   register int nbits;
   register int r, k;
   int Se = state->cinfo->lim_Se;
+  int max_coef_bits = state->cinfo->data_precision + 3;
   const int * natural_order = state->cinfo->natural_order;
 
   /* Encode the DC coefficient difference per section F.1.2.1 */
 
-  temp = temp2 = block[0] - last_dc_val;
+  if ((temp = block[0] - last_dc_val) == 0) {
+    /* Emit the Huffman-coded symbol for the number of bits */
+    if (! emit_bits_s(state, dctbl->ehufco[0], dctbl->ehufsi[0]))
+      return FALSE;
+  } else {
+    if ((temp2 = temp) < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      /* For a negative input, want temp2 = bitwise complement of abs(input) */
+      /* This code assumes we are on a two's complement machine */
+      temp2--;
+    }
 
-  if (temp < 0) {
+    /* Find the number of bits needed for the magnitude of the coefficient */
-    temp = -temp;		/* temp is abs value of input */
+    nbits = 0;
-    /* For a negative input, want temp2 = bitwise complement of abs(input) */
+    do nbits++;			/* there must be at least one 1 bit */
-    /* This code assumes we are on a two's complement machine */
+    while ((temp >>= 1));
-    temp2--;
+    /* Check for out-of-range coefficient values.
-  }
+     * Since we're encoding a difference, the range limit is twice as much.
+     */
+    if (nbits > max_coef_bits)
+      ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
 
-  /* Find the number of bits needed for the magnitude of the coefficient */
+    /* Emit the Huffman-coded symbol for the number of bits */
-  nbits = 0;
+    if (! emit_bits_s(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
-  while (temp) {
+      return FALSE;
-    nbits++;
-    temp >>= 1;
-  }
-  /* Check for out-of-range coefficient values.
-   * Since we're encoding a difference, the range limit is twice as much.
-   */
-  if (nbits > MAX_COEF_BITS+1)
-    ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
 
-  /* Emit the Huffman-coded symbol for the number of bits */
+    /* Emit that number of bits of the value, if positive, */
-  if (! emit_bits_s(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
+    /* or the complement of its magnitude, if negative. */
-    return FALSE;
-
-  /* Emit that number of bits of the value, if positive, */
-  /* or the complement of its magnitude, if negative. */
-  if (nbits)			/* emit_bits rejects calls with size 0 */
     if (! emit_bits_s(state, (unsigned int) temp2, nbits))
       return FALSE;
+  }
 
   /* Encode the AC coefficients per section F.1.2.2 */
 
   r = 0;			/* r = run length of zeros */
 
   for (k = 1; k <= Se; k++) {
-    if ((temp2 = block[natural_order[k]]) == 0) {
+    if ((temp = block[natural_order[k]]) == 0) {
       r++;
-    } else {
+      continue;
-      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
-      while (r > 15) {
-	if (! emit_bits_s(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
-	  return FALSE;
-	r -= 16;
-      }
-
-      temp = temp2;
-      if (temp < 0) {
-	temp = -temp;		/* temp is abs value of input */
-	/* This code assumes we are on a two's complement machine */
-	temp2--;
-      }
-
-      /* Find the number of bits needed for the magnitude of the coefficient */
-      nbits = 1;		/* there must be at least one 1 bit */
-      while ((temp >>= 1))
-	nbits++;
-      /* Check for out-of-range coefficient values */
-      if (nbits > MAX_COEF_BITS)
-	ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
-
-      /* Emit Huffman symbol for run length / number of bits */
-      temp = (r << 4) + nbits;
-      if (! emit_bits_s(state, actbl->ehufco[temp], actbl->ehufsi[temp]))
-	return FALSE;
-
-      /* Emit that number of bits of the value, if positive, */
-      /* or the complement of its magnitude, if negative. */
-      if (! emit_bits_s(state, (unsigned int) temp2, nbits))
-	return FALSE;
-
-      r = 0;
     }
+
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+    while (r > 15) {
+      if (! emit_bits_s(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+	return FALSE;
+      r -= 16;
+    }
+
+    if ((temp2 = temp) < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+      /* This code assumes we are on a two's complement machine */
+      temp2--;
+    }
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 0;
+    do nbits++;			/* there must be at least one 1 bit */
+    while ((temp >>= 1));
+    /* Check for out-of-range coefficient values.
+     * Use ">=" instead of ">" so can use the
+     * same one larger limit from DC check here.
+     */
+    if (nbits >= max_coef_bits)
+      ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+
+    /* Emit Huffman symbol for run length / number of bits */
+    temp = (r << 4) + nbits;
+    if (! emit_bits_s(state, actbl->ehufco[temp], actbl->ehufsi[temp]))
+      return FALSE;
+
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    if (! emit_bits_s(state, (unsigned int) temp2, nbits))
+      return FALSE;
+
+    r = 0;			/* reset zero run length */
   }
 
   /* If the last coef(s) were zero, emit an end-of-block code */
@@ -1009,7 +1019,7 @@ encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
  */
 
 METHODDEF(boolean)
-encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_huff (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   working_state state;
@@ -1122,28 +1132,31 @@ htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
   register int nbits;
   register int r, k;
   int Se = cinfo->lim_Se;
+  int max_coef_bits = cinfo->data_precision + 3;
   const int * natural_order = cinfo->natural_order;
 
   /* Encode the DC coefficient difference per section F.1.2.1 */
 
-  temp = block[0] - last_dc_val;
+  if ((temp = block[0] - last_dc_val) == 0) {
-  if (temp < 0)
+    /* Count the Huffman symbol for the number of bits */
-    temp = -temp;
+    dc_counts[0]++;
+  } else {
+    if (temp < 0)
+      temp = -temp;		/* temp is abs value of input */
 
-  /* Find the number of bits needed for the magnitude of the coefficient */
+    /* Find the number of bits needed for the magnitude of the coefficient */
-  nbits = 0;
+    nbits = 0;
-  while (temp) {
+    do nbits++;			/* there must be at least one 1 bit */
-    nbits++;
+    while ((temp >>= 1));
-    temp >>= 1;
+    /* Check for out-of-range coefficient values.
+     * Since we're encoding a difference, the range limit is twice as much.
+     */
+    if (nbits > max_coef_bits)
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+    /* Count the Huffman symbol for the number of bits */
+    dc_counts[nbits]++;
   }
-  /* Check for out-of-range coefficient values.
-   * Since we're encoding a difference, the range limit is twice as much.
-   */
-  if (nbits > MAX_COEF_BITS+1)
-    ERREXIT(cinfo, JERR_BAD_DCT_COEF);
-
-  /* Count the Huffman symbol for the number of bits */
-  dc_counts[nbits]++;
 
   /* Encode the AC coefficients per section F.1.2.2 */
 
@@ -1152,30 +1165,33 @@ htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
   for (k = 1; k <= Se; k++) {
     if ((temp = block[natural_order[k]]) == 0) {
       r++;
-    } else {
+      continue;
-      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
-      while (r > 15) {
-	ac_counts[0xF0]++;
-	r -= 16;
-      }
-
-      /* Find the number of bits needed for the magnitude of the coefficient */
-      if (temp < 0)
-	temp = -temp;
-
-      /* Find the number of bits needed for the magnitude of the coefficient */
-      nbits = 1;		/* there must be at least one 1 bit */
-      while ((temp >>= 1))
-	nbits++;
-      /* Check for out-of-range coefficient values */
-      if (nbits > MAX_COEF_BITS)
-	ERREXIT(cinfo, JERR_BAD_DCT_COEF);
-
-      /* Count Huffman symbol for run length / number of bits */
-      ac_counts[(r << 4) + nbits]++;
-
-      r = 0;
     }
+
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+    while (r > 15) {
+      ac_counts[0xF0]++;
+      r -= 16;
+    }
+
+    if (temp < 0)
+      temp = -temp;		/* temp is abs value of input */
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 0;
+    do nbits++;			/* there must be at least one 1 bit */
+    while ((temp >>= 1));
+    /* Check for out-of-range coefficient values.
+     * Use ">=" instead of ">" so can use the
+     * same one larger limit from DC check here.
+     */
+    if (nbits >= max_coef_bits)
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+    /* Count Huffman symbol for run length / number of bits */
+    ac_counts[(r << 4) + nbits]++;
+
+    r = 0;			/* reset zero run length */
   }
 
   /* If the last coef(s) were zero, emit an end-of-block code */
@@ -1190,7 +1206,7 @@ htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
  */
 
 METHODDEF(boolean)
-encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+encode_mcu_gather (j_compress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   int blkn, ci;

3rdparty/libjpeg/jcmaster.c

@@ -2,7 +2,7 @@
  * jcmaster.c
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2003-2019 by Guido Vollbeding.
+ * Modified 2003-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -429,9 +429,7 @@ per_scan_setup (j_compress_ptr cinfo)
     cinfo->MCUs_per_row = (JDIMENSION)
       jdiv_round_up((long) cinfo->jpeg_width,
 		    (long) (cinfo->max_h_samp_factor * cinfo->block_size));
-    cinfo->MCU_rows_in_scan = (JDIMENSION)
+    cinfo->MCU_rows_in_scan = cinfo->total_iMCU_rows;
-      jdiv_round_up((long) cinfo->jpeg_height,
-		    (long) (cinfo->max_v_samp_factor * cinfo->block_size));
 
     cinfo->blocks_in_MCU = 0;
 

3rdparty/libjpeg/jconfig.h

@@ -1,6 +1,8 @@
-/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 9x or NT. */
+/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 9x or NT.
-/* This file also works for Borland C++ 32-bit (bcc32) on Windows 9x or NT. */
+ * This file also works for Borland/Embarcadero C++ for Win32 or Win64
-/* see jconfig.txt for explanations */
+ * (CLI: bcc32, bcc32c, bcc32x, bcc64; GUI IDE: C++Builder/RAD Studio).
+ * See jconfig.txt for explanations.
+ */
 
 #define HAVE_PROTOTYPES
 #define HAVE_UNSIGNED_CHAR
@@ -28,6 +30,16 @@ typedef unsigned char boolean;
 #endif
 #define HAVE_BOOLEAN		/* prevent jmorecfg.h from redefining it */
 
+/* Define custom RGB color order, prevent jmorecfg.h from redefinition */
+#undef JPEG_HAVE_RGB_CUSTOM
+/* Use Windows custom BGR color order defined in jmorecfg.h */
+#undef JPEG_USE_RGB_CUSTOM
+
+/* Define custom file I/O functions, prevent jinclude.h from redefinition */
+#undef JPEG_HAVE_FILE_IO_CUSTOM
+/* Use Delphi custom file I/O functions defined in jinclude.h */
+#undef JPEG_USE_FILE_IO_CUSTOM
+
 
 #ifdef JPEG_INTERNALS
 
@@ -44,7 +56,7 @@ typedef unsigned char boolean;
 #define TARGA_SUPPORTED		/* Targa image file format */
 
 #define TWO_FILE_COMMANDLINE	/* optional */
-#define USE_SETMODE		/* Microsoft has setmode() */
+#define USE_SETMODE	/* Microsoft/Borland/Embarcadero have setmode() */
 #undef NEED_SIGNAL_CATCHER
 #undef DONT_USE_B_MODE
 #undef PROGRESS_REPORT		/* optional */

3rdparty/libjpeg/jcparam.c

@@ -2,7 +2,7 @@
  * jcparam.c
  *
  * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2003-2019 by Guido Vollbeding.
+ * Modified 2003-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -62,8 +62,9 @@ jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
 
 
 /* These are the sample quantization tables given in JPEG spec section K.1.
- * The spec says that the values given produce "good" quality, and
+ * NOTE: chrominance DC value is changed from 17 to 16 for lossless support.
- * when divided by 2, "very good" quality.
+ * The spec says that the values given produce "good" quality,
+ * and when divided by 2, "very good" quality.
  */
 static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
   16,  11,  10,  16,  24,  40,  51,  61,
@@ -76,7 +77,7 @@ static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
   72,  92,  95,  98, 112, 100, 103,  99
 };
 static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
-  17,  18,  24,  47,  99,  99,  99,  99,
+  16,  18,  24,  47,  99,  99,  99,  99,
   18,  21,  26,  66,  99,  99,  99,  99,
   24,  26,  56,  99,  99,  99,  99,  99,
   47,  66,  99,  99,  99,  99,  99,  99,
@@ -379,11 +380,13 @@ jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
   case JCS_RGB:
     cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
     cinfo->num_components = 3;
-    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0,
+    SET_COMP(0, 0x52 /* 'R' */, 1,1,
+		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
     SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
-    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0,
+    SET_COMP(2, 0x42 /* 'B' */, 1,1,
+		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
     break;
@@ -417,11 +420,13 @@ jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
     cinfo->JFIF_major_version = 2;   /* Set JFIF major version = 2 */
     cinfo->num_components = 3;
     /* Add offset 0x20 to the normal R/G/B component IDs */
-    SET_COMP(0, 0x72 /* 'r' */, 1,1, 0,
+    SET_COMP(0, 0x72 /* 'r' */, 1,1,
+		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
     SET_COMP(1, 0x67 /* 'g' */, 1,1, 0, 0,0);
-    SET_COMP(2, 0x62 /* 'b' */, 1,1, 0,
+    SET_COMP(2, 0x62 /* 'b' */, 1,1,
+		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
 		cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
     break;

3rdparty/libjpeg/jcprepct.c

@@ -2,6 +2,7 @@
  * jcprepct.c
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2003-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -109,7 +110,8 @@ expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
   register int row;
 
   for (row = input_rows; row < output_rows; row++) {
-    jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+    jcopy_sample_rows(image_data + input_rows - 1,
+		      image_data + row,
 		      1, num_cols);
   }
 }
@@ -220,8 +222,8 @@ pre_process_context (j_compress_ptr cinfo,
 	for (ci = 0; ci < cinfo->num_components; ci++) {
 	  int row;
 	  for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
-	    jcopy_sample_rows(prep->color_buf[ci], 0,
+	    jcopy_sample_rows(prep->color_buf[ci],
-			      prep->color_buf[ci], -row,
+			      prep->color_buf[ci] - row,
 			      1, cinfo->image_width);
 	  }
 	}
@@ -277,10 +279,9 @@ create_context_buffer (j_compress_ptr cinfo)
   /* Grab enough space for fake row pointers for all the components;
    * we need five row groups' worth of pointers for each component.
    */
-  fake_buffer = (JSAMPARRAY)
+  fake_buffer = (JSAMPARRAY) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				(cinfo->num_components * 5 * rgroup_height) *
+     (cinfo->num_components * 5 * rgroup_height) * SIZEOF(JSAMPROW));
-				SIZEOF(JSAMPROW));
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
@@ -324,10 +325,9 @@ jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
   if (need_full_buffer)		/* safety check */
     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
 
-  prep = (my_prep_ptr)
+  prep = (my_prep_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_prep_controller));
-				SIZEOF(my_prep_controller));
+  cinfo->prep = &prep->pub;
-  cinfo->prep = (struct jpeg_c_prep_controller *) prep;
   prep->pub.start_pass = start_pass_prep;
 
   /* Allocate the color conversion buffer.

3rdparty/libjpeg/jcsample.c

@@ -2,6 +2,7 @@
  * jcsample.c
  *
  * Copyright (C) 1991-1996, Thomas G. Lane.
+ * Modified 2003-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -200,7 +201,7 @@ fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
 		     JSAMPARRAY input_data, JSAMPARRAY output_data)
 {
   /* Copy the data */
-  jcopy_sample_rows(input_data, 0, output_data, 0,
+  jcopy_sample_rows(input_data, output_data,
 		    cinfo->max_v_samp_factor, cinfo->image_width);
   /* Edge-expand */
   expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width,
@@ -483,10 +484,9 @@ jinit_downsampler (j_compress_ptr cinfo)
   boolean smoothok = TRUE;
   int h_in_group, v_in_group, h_out_group, v_out_group;
 
-  downsample = (my_downsample_ptr)
+  downsample = (my_downsample_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_downsampler));
-				SIZEOF(my_downsampler));
+  cinfo->downsample = &downsample->pub;
-  cinfo->downsample = (struct jpeg_downsampler *) downsample;
   downsample->pub.start_pass = start_pass_downsample;
   downsample->pub.downsample = sep_downsample;
   downsample->pub.need_context_rows = FALSE;

3rdparty/libjpeg/jctrans.c

@@ -2,7 +2,7 @@
  * jctrans.c
  *
  * Copyright (C) 1995-1998, Thomas G. Lane.
- * Modified 2000-2017 by Guido Vollbeding.
+ * Modified 2000-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -224,7 +224,7 @@ typedef struct {
   struct jpeg_c_coef_controller pub; /* public fields */
 
   JDIMENSION iMCU_row_num;	/* iMCU row # within image */
-  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  JDIMENSION MCU_ctr;		/* counts MCUs processed in current row */
   int MCU_vert_offset;		/* counts MCU rows within iMCU row */
   int MCU_rows_per_iMCU_row;	/* number of such rows needed */
 
@@ -232,7 +232,7 @@ typedef struct {
   jvirt_barray_ptr * whole_image;
 
   /* Workspace for constructing dummy blocks at right/bottom edges. */
-  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+  JBLOCK dummy_buffer[C_MAX_BLOCKS_IN_MCU];
 } my_coef_controller;
 
 typedef my_coef_controller * my_coef_ptr;
@@ -257,7 +257,7 @@ start_iMCU_row (j_compress_ptr cinfo)
       coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
   }
 
-  coef->mcu_ctr = 0;
+  coef->MCU_ctr = 0;
   coef->MCU_vert_offset = 0;
 }
 
@@ -315,25 +315,30 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
   /* Loop to process one whole iMCU row */
   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
        yoffset++) {
-    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
 	 MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
       blkn = 0;			/* index of current DCT block within MCU */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 	compptr = cinfo->cur_comp_info[ci];
-	start_col = MCU_col_num * compptr->MCU_width;
 	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
 						: compptr->last_col_width;
+	start_col = MCU_col_num * compptr->MCU_width;
 	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
 	  if (coef->iMCU_row_num < last_iMCU_row ||
-	      yindex+yoffset < compptr->last_row_height) {
+	      yoffset + yindex < compptr->last_row_height) {
 	    /* Fill in pointers to real blocks in this row */
-	    buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	    buffer_ptr = buffer[ci][yoffset + yindex] + start_col;
-	    for (xindex = 0; xindex < blockcnt; xindex++)
+	    xindex = blockcnt;
+	    do {
 	      MCU_buffer[blkn++] = buffer_ptr++;
+	    } while (--xindex);
+	    /* Dummy blocks at right edge */
+	    if ((xindex = compptr->MCU_width - blockcnt) == 0)
+	      continue;
 	  } else {
 	    /* At bottom of image, need a whole row of dummy blocks */
-	    xindex = 0;
+	    xindex = compptr->MCU_width;
 	  }
 	  /* Fill in any dummy blocks needed in this row.
 	   * Dummy blocks are filled in the same way as in jccoefct.c:
@@ -341,23 +346,23 @@ compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
 	   * block's DC value.  The init routine has already zeroed the
 	   * AC entries, so we need only set the DC entries correctly.
 	   */
-	  for (; xindex < compptr->MCU_width; xindex++) {
+	  buffer_ptr = coef->dummy_buffer + blkn;
-	    MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+	  do {
-	    MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+	    buffer_ptr[0][0] = MCU_buffer[blkn-1][0][0];
-	    blkn++;
+	    MCU_buffer[blkn++] = buffer_ptr++;
-	  }
+	  } while (--xindex);
 	}
       }
       /* Try to write the MCU. */
       if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
 	/* Suspension forced; update state counters and exit */
 	coef->MCU_vert_offset = yoffset;
-	coef->mcu_ctr = MCU_col_num;
+	coef->MCU_ctr = MCU_col_num;
 	return FALSE;
       }
     }
     /* Completed an MCU row, but perhaps not an iMCU row */
-    coef->mcu_ctr = 0;
+    coef->MCU_ctr = 0;
   }
   /* Completed the iMCU row, advance counters for next one */
   coef->iMCU_row_num++;
@@ -379,12 +384,9 @@ transencode_coef_controller (j_compress_ptr cinfo,
 			     jvirt_barray_ptr * coef_arrays)
 {
   my_coef_ptr coef;
-  JBLOCKROW buffer;
-  int i;
 
-  coef = (my_coef_ptr)
+  coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller));
-				SIZEOF(my_coef_controller));
   cinfo->coef = &coef->pub;
   coef->pub.start_pass = start_pass_coef;
   coef->pub.compress_data = compress_output;
@@ -392,12 +394,6 @@ transencode_coef_controller (j_compress_ptr cinfo,
   /* Save pointer to virtual arrays */
   coef->whole_image = coef_arrays;
 
-  /* Allocate and pre-zero space for dummy DCT blocks. */
+  /* Pre-zero space for dummy DCT blocks */
-  buffer = (JBLOCKROW)
+  MEMZERO(coef->dummy_buffer, SIZEOF(coef->dummy_buffer));
-    (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
-  FMEMZERO((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
-  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
-    coef->dummy_buffer[i] = buffer + i;
-  }
 }

3rdparty/libjpeg/jdapimin.c

@@ -2,7 +2,7 @@
  * jdapimin.c
  *
  * Copyright (C) 1994-1998, Thomas G. Lane.
- * Modified 2009-2013 by Guido Vollbeding.
+ * Modified 2009-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -114,7 +114,7 @@ jpeg_abort_decompress (j_decompress_ptr cinfo)
 LOCAL(void)
 default_decompress_parms (j_decompress_ptr cinfo)
 {
-  int cid0, cid1, cid2;
+  int cid0, cid1, cid2, cid3;
 
   /* Guess the input colorspace, and set output colorspace accordingly. */
   /* Note application may override our guesses. */
@@ -129,7 +129,10 @@ default_decompress_parms (j_decompress_ptr cinfo)
     cid1 = cinfo->comp_info[1].component_id;
     cid2 = cinfo->comp_info[2].component_id;
 
-    /* First try to guess from the component IDs */
+    /* For robust detection of standard colorspaces
+     * regardless of the presence of special markers,
+     * check component IDs from SOF marker first.
+     */
     if      (cid0 == 0x01 && cid1 == 0x02 && cid2 == 0x03)
       cinfo->jpeg_color_space = JCS_YCbCr;
     else if (cid0 == 0x01 && cid1 == 0x22 && cid2 == 0x23)
@@ -151,7 +154,6 @@ default_decompress_parms (j_decompress_ptr cinfo)
       default:
 	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
 	cinfo->jpeg_color_space = JCS_YCbCr;	/* assume it's YCbCr */
-	break;
       }
     } else {
       TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
@@ -162,7 +164,20 @@ default_decompress_parms (j_decompress_ptr cinfo)
     break;
 
   case 4:
-    if (cinfo->saw_Adobe_marker) {
+    cid0 = cinfo->comp_info[0].component_id;
+    cid1 = cinfo->comp_info[1].component_id;
+    cid2 = cinfo->comp_info[2].component_id;
+    cid3 = cinfo->comp_info[3].component_id;
+
+    /* For robust detection of standard colorspaces
+     * regardless of the presence of special markers,
+     * check component IDs from SOF marker first.
+     */
+    if      (cid0 == 0x01 && cid1 == 0x02 && cid2 == 0x03 && cid3 == 0x04)
+      cinfo->jpeg_color_space = JCS_YCCK;
+    else if (cid0 == 0x43 && cid1 == 0x4D && cid2 == 0x59 && cid3 == 0x4B)
+      cinfo->jpeg_color_space = JCS_CMYK;   /* ASCII 'C', 'M', 'Y', 'K' */
+    else if (cinfo->saw_Adobe_marker) {
       switch (cinfo->Adobe_transform) {
       case 0:
 	cinfo->jpeg_color_space = JCS_CMYK;
@@ -173,10 +188,9 @@ default_decompress_parms (j_decompress_ptr cinfo)
       default:
 	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
 	cinfo->jpeg_color_space = JCS_YCCK;	/* assume it's YCCK */
-	break;
       }
     } else {
-      /* No special markers, assume straight CMYK. */
+      /* Unknown IDs and no special markers, assume straight CMYK. */
       cinfo->jpeg_color_space = JCS_CMYK;
     }
     cinfo->out_color_space = JCS_CMYK;
@@ -185,7 +199,6 @@ default_decompress_parms (j_decompress_ptr cinfo)
   default:
     cinfo->jpeg_color_space = JCS_UNKNOWN;
     cinfo->out_color_space = JCS_UNKNOWN;
-    break;
   }
 
   /* Set defaults for other decompression parameters. */

3rdparty/libjpeg/jdarith.c

@@ -1,7 +1,7 @@
 /*
  * jdarith.c
  *
- * Developed 1997-2019 by Guido Vollbeding.
+ * Developed 1997-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -239,7 +239,7 @@ process_restart (j_decompress_ptr cinfo)
  */
 
 METHODDEF(boolean)
-decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   JBLOCKROW block;
@@ -318,7 +318,7 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   JBLOCKROW block;
@@ -400,7 +400,7 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   unsigned char *st;
@@ -434,7 +434,7 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   JBLOCKROW block;
@@ -509,7 +509,7 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
   jpeg_component_info * compptr;

3rdparty/libjpeg/jdatadst.c

@@ -2,7 +2,7 @@
  * jdatadst.c
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -28,17 +28,17 @@ extern void free JPP((void *ptr));
 
 /* Expanded data destination object for stdio output */
 
+#define OUTPUT_BUF_SIZE  4096	/* choose an efficiently fwrite'able size */
+
 typedef struct {
   struct jpeg_destination_mgr pub; /* public fields */
 
   FILE * outfile;		/* target stream */
-  JOCTET * buffer;		/* start of buffer */
+  JOCTET buffer[OUTPUT_BUF_SIZE]; /* output buffer */
 } my_destination_mgr;
 
 typedef my_destination_mgr * my_dest_ptr;
 
-#define OUTPUT_BUF_SIZE  4096	/* choose an efficiently fwrite'able size */
-
 
 /* Expanded data destination object for memory output */
 
@@ -65,10 +65,6 @@ init_destination (j_compress_ptr cinfo)
 {
   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
 
-  /* Allocate the output buffer --- it will be released when done with image */
-  dest->buffer = (JOCTET *) (*cinfo->mem->alloc_small)
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
-
   dest->pub.next_output_byte = dest->buffer;
   dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
 }
@@ -187,8 +183,8 @@ term_mem_destination (j_compress_ptr cinfo)
 
 /*
  * Prepare for output to a stdio stream.
- * The caller must have already opened the stream, and is responsible
+ * The caller must have already opened the stream,
- * for closing it after finishing compression.
+ * and is responsible for closing it after finishing compression.
  */
 
 GLOBAL(void)

3rdparty/libjpeg/jdatasrc.c

@@ -2,7 +2,7 @@
  * jdatasrc.c
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -23,18 +23,18 @@
 
 /* Expanded data source object for stdio input */
 
+#define INPUT_BUF_SIZE  4096	/* choose an efficiently fread'able size */
+
 typedef struct {
   struct jpeg_source_mgr pub;	/* public fields */
 
   FILE * infile;		/* source stream */
-  JOCTET * buffer;		/* start of buffer */
+  JOCTET buffer[INPUT_BUF_SIZE]; /* input buffer */
   boolean start_of_file;	/* have we gotten any data yet? */
 } my_source_mgr;
 
 typedef my_source_mgr * my_src_ptr;
 
-#define INPUT_BUF_SIZE  4096	/* choose an efficiently fread'able size */
-
 
 /*
  * Initialize source --- called by jpeg_read_header
@@ -204,8 +204,8 @@ term_source (j_decompress_ptr cinfo)
 
 /*
  * Prepare for input from a stdio stream.
- * The caller must have already opened the stream, and is responsible
+ * The caller must have already opened the stream,
- * for closing it after finishing decompression.
+ * and is responsible for closing it after finishing decompression.
  */
 
 GLOBAL(void)
@@ -213,19 +213,16 @@ jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
 {
   my_src_ptr src;
 
-  /* The source object and input buffer are made permanent so that a series
+  /* The source object including the input buffer is made permanent so that
-   * of JPEG images can be read from the same file by calling jpeg_stdio_src
+   * a series of JPEG images can be read from the same file by calling
-   * only before the first one.  (If we discarded the buffer at the end of
+   * jpeg_stdio_src only before the first one.  (If we discarded the buffer
-   * one image, we'd likely lose the start of the next one.)
+   * at the end of one image, we'd likely lose the start of the next one.)
    * This makes it unsafe to use this manager and a different source
    * manager serially with the same JPEG object.  Caveat programmer.
    */
   if (cinfo->src == NULL) {	/* first time for this JPEG object? */
     cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)
       ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_source_mgr));
-    src = (my_src_ptr) cinfo->src;
-    src->buffer = (JOCTET *) (*cinfo->mem->alloc_small)
-      ((j_common_ptr) cinfo, JPOOL_PERMANENT, INPUT_BUF_SIZE * SIZEOF(JOCTET));
   }
 
   src = (my_src_ptr) cinfo->src;

3rdparty/libjpeg/jdcoefct.c

@@ -2,7 +2,7 @@
  * jdcoefct.c
  *
  * Copyright (C) 1994-1997, Thomas G. Lane.
- * Modified 2002-2011 by Guido Vollbeding.
+ * Modified 2002-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -19,11 +19,13 @@
 #include "jinclude.h"
 #include "jpeglib.h"
 
+
 /* Block smoothing is only applicable for progressive JPEG, so: */
 #ifndef D_PROGRESSIVE_SUPPORTED
 #undef BLOCK_SMOOTHING_SUPPORTED
 #endif
 
+
 /* Private buffer controller object */
 
 typedef struct {
@@ -38,11 +40,8 @@ typedef struct {
   /* The output side's location is represented by cinfo->output_iMCU_row. */
 
   /* In single-pass modes, it's sufficient to buffer just one MCU.
-   * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+   * We append a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
    * and let the entropy decoder write into that workspace each time.
-   * (On 80x86, the workspace is FAR even though it's not really very big;
-   * this is to keep the module interfaces unchanged when a large coefficient
-   * buffer is necessary.)
    * In multi-pass modes, this array points to the current MCU's blocks
    * within the virtual arrays; it is used only by the input side.
    */
@@ -58,10 +57,14 @@ typedef struct {
   int * coef_bits_latch;
 #define SAVED_COEFS  6		/* we save coef_bits[0..5] */
 #endif
+
+  /* Workspace for single-pass modes (omitted otherwise). */
+  JBLOCK blk_buffer[D_MAX_BLOCKS_IN_MCU];
 } my_coef_controller;
 
 typedef my_coef_controller * my_coef_ptr;
 
+
 /* Forward declarations */
 METHODDEF(int) decompress_onepass
 	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
@@ -151,7 +154,8 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
   JDIMENSION MCU_col_num;	/* index of current MCU within row */
   JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
   JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
-  int blkn, ci, xindex, yindex, yoffset, useful_width;
+  int ci, xindex, yindex, yoffset, useful_width;
+  JBLOCKROW blkp;
   JSAMPARRAY output_ptr;
   JDIMENSION start_col, output_col;
   jpeg_component_info *compptr;
@@ -162,10 +166,10 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
        yoffset++) {
     for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
 	 MCU_col_num++) {
+      blkp = coef->blk_buffer;	/* pointer to current DCT block within MCU */
       /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
       if (cinfo->lim_Se)	/* can bypass in DC only case */
-	FMEMZERO((void FAR *) coef->MCU_buffer[0],
+	MEMZERO(blkp, cinfo->blocks_in_MCU * SIZEOF(JBLOCK));
-		 (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
       if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
 	/* Suspension forced; update state counters and exit */
 	coef->MCU_vert_offset = yoffset;
@@ -173,37 +177,34 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
 	return JPEG_SUSPENDED;
       }
       /* Determine where data should go in output_buf and do the IDCT thing.
-       * We skip dummy blocks at the right and bottom edges (but blkn gets
+       * We skip dummy blocks at the right and bottom edges (but blkp gets
-       * incremented past them!).  Note the inner loop relies on having
+       * incremented past them!).
-       * allocated the MCU_buffer[] blocks sequentially.
        */
-      blkn = 0;			/* index of current DCT block within MCU */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 	compptr = cinfo->cur_comp_info[ci];
 	/* Don't bother to IDCT an uninteresting component. */
 	if (! compptr->component_needed) {
-	  blkn += compptr->MCU_blocks;
+	  blkp += compptr->MCU_blocks;
 	  continue;
 	}
 	inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
-	useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
-						    : compptr->last_col_width;
 	output_ptr = output_buf[compptr->component_index] +
 	  yoffset * compptr->DCT_v_scaled_size;
+	useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						    : compptr->last_col_width;
 	start_col = MCU_col_num * compptr->MCU_sample_width;
 	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
 	  if (cinfo->input_iMCU_row < last_iMCU_row ||
-	      yoffset+yindex < compptr->last_row_height) {
+	      yoffset + yindex < compptr->last_row_height) {
 	    output_col = start_col;
 	    for (xindex = 0; xindex < useful_width; xindex++) {
-	      (*inverse_DCT) (cinfo, compptr,
+	      (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) (blkp + xindex),
-			      (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
 			      output_ptr, output_col);
 	      output_col += compptr->DCT_h_scaled_size;
 	    }
+	    output_ptr += compptr->DCT_v_scaled_size;
 	  }
-	  blkn += compptr->MCU_width;
+	  blkp += compptr->MCU_width;
-	  output_ptr += compptr->DCT_v_scaled_size;
 	}
       }
     }
@@ -212,7 +213,7 @@ decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
   }
   /* Completed the iMCU row, advance counters for next one */
   cinfo->output_iMCU_row++;
-  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+  if (++(cinfo->input_iMCU_row) <= last_iMCU_row) {
     start_iMCU_row(cinfo);
     return JPEG_ROW_COMPLETED;
   }
@@ -247,8 +248,9 @@ consume_data (j_decompress_ptr cinfo)
 {
   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
   JDIMENSION MCU_col_num;	/* index of current MCU within row */
-  int blkn, ci, xindex, yindex, yoffset;
+  int ci, xindex, yindex, yoffset;
   JDIMENSION start_col;
+  JBLOCKARRAY blkp;
   JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
   JBLOCKROW buffer_ptr;
   jpeg_component_info *compptr;
@@ -272,15 +274,16 @@ consume_data (j_decompress_ptr cinfo)
     for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
 	 MCU_col_num++) {
       /* Construct list of pointers to DCT blocks belonging to this MCU */
-      blkn = 0;			/* index of current DCT block within MCU */
+      blkp = coef->MCU_buffer;	/* pointer to current DCT block within MCU */
       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 	compptr = cinfo->cur_comp_info[ci];
 	start_col = MCU_col_num * compptr->MCU_width;
 	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
-	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  buffer_ptr = buffer[ci][yoffset + yindex] + start_col;
-	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	  xindex = compptr->MCU_width;
-	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  do {
-	  }
+	    *blkp++ = buffer_ptr++;
+	  } while (--xindex);
 	}
       }
       /* Try to fetch the MCU. */
@@ -370,7 +373,7 @@ decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
     }
   }
 
-  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+  if (++(cinfo->output_iMCU_row) <= last_iMCU_row)
     return JPEG_ROW_COMPLETED;
   return JPEG_SCAN_COMPLETED;
 }
@@ -419,10 +422,9 @@ smoothing_ok (j_decompress_ptr cinfo)
 
   /* Allocate latch area if not already done */
   if (coef->coef_bits_latch == NULL)
-    coef->coef_bits_latch = (int *)
+    coef->coef_bits_latch = (int *) (*cinfo->mem->alloc_small)
-      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				  cinfo->num_components *
+       cinfo->num_components * (SAVED_COEFS * SIZEOF(int)));
-				  (SAVED_COEFS * SIZEOF(int)));
   coef_bits_latch = coef->coef_bits_latch;
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
@@ -662,7 +664,7 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
     }
   }
 
-  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+  if (++(cinfo->output_iMCU_row) <= last_iMCU_row)
     return JPEG_ROW_COMPLETED;
   return JPEG_SCAN_COMPLETED;
 }
@@ -679,17 +681,6 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 {
   my_coef_ptr coef;
 
-  coef = (my_coef_ptr)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				SIZEOF(my_coef_controller));
-  cinfo->coef = (struct jpeg_d_coef_controller *) coef;
-  coef->pub.start_input_pass = start_input_pass;
-  coef->pub.start_output_pass = start_output_pass;
-#ifdef BLOCK_SMOOTHING_SUPPORTED
-  coef->coef_bits_latch = NULL;
-#endif
-
-  /* Create the coefficient buffer. */
   if (need_full_buffer) {
 #ifdef D_MULTISCAN_FILES_SUPPORTED
     /* Allocate a full-image virtual array for each component, */
@@ -698,6 +689,9 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
     int ci, access_rows;
     jpeg_component_info *compptr;
 
+    coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       SIZEOF(my_coef_controller) - SIZEOF(coef->blk_buffer));
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 	 ci++, compptr++) {
       access_rows = compptr->v_samp_factor;
@@ -722,20 +716,29 @@ jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 #endif
   } else {
     /* We only need a single-MCU buffer. */
-    JBLOCKROW buffer;
+    JBLOCKARRAY blkp;
-    int i;
+    JBLOCKROW buffer_ptr;
+    int bi;
 
-    buffer = (JBLOCKROW)
+    coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
-      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller));
-				  D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    buffer_ptr = coef->blk_buffer;
-    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
-      coef->MCU_buffer[i] = buffer + i;
-    }
     if (cinfo->lim_Se == 0)	/* DC only case: want to bypass later */
-      FMEMZERO((void FAR *) buffer,
+      MEMZERO(buffer_ptr, SIZEOF(coef->blk_buffer));
-	       (size_t) (D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)));
+    blkp = coef->MCU_buffer;
+    bi = D_MAX_BLOCKS_IN_MCU;
+    do {
+      *blkp++ = buffer_ptr++;
+    } while (--bi);
     coef->pub.consume_data = dummy_consume_data;
     coef->pub.decompress_data = decompress_onepass;
     coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
   }
+
+  coef->pub.start_input_pass = start_input_pass;
+  coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  coef->coef_bits_latch = NULL;
+#endif
+  cinfo->coef = &coef->pub;
 }

3rdparty/libjpeg/jdcolor.c

@@ -2,7 +2,7 @@
  * jdcolor.c
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2011-2019 by Guido Vollbeding.
+ * Modified 2011-2023 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -32,7 +32,9 @@ typedef struct {
   INT32 * Cb_g_tab;		/* => table for Cb to G conversion */
 
   /* Private state for RGB->Y conversion */
-  INT32 * rgb_y_tab;		/* => table for RGB to Y conversion */
+  INT32 * R_y_tab;		/* => table for R to Y conversion */
+  INT32 * G_y_tab;		/* => table for G to Y conversion */
+  INT32 * B_y_tab;		/* => table for B to Y conversion */
 } my_color_deconverter;
 
 typedef my_color_deconverter * my_cconvert_ptr;
@@ -87,29 +89,17 @@ typedef my_color_deconverter * my_cconvert_ptr;
  * by precalculating the constants times Cb and Cr for all possible values.
  * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
  * for 9-bit to 12-bit samples it is still acceptable.  It's not very
- * reasonable for 16-bit samples, but if you want lossless storage you
+ * reasonable for 16-bit samples, but if you want lossless storage
- * shouldn't be changing colorspace anyway.
+ * you shouldn't be changing colorspace anyway.
- * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance;
- * values for the G calculation are left scaled up, since we must add them
+ * the values for the G calculation are left scaled up,
- * together before rounding.
+ * since we must add them together before rounding.
  */
 
 #define SCALEBITS	16	/* speediest right-shift on some machines */
 #define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
 #define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
 
-/* We allocate one big table for RGB->Y conversion and divide it up into
- * three parts, instead of doing three alloc_small requests.  This lets us
- * use a single table base address, which can be held in a register in the
- * inner loops on many machines (more than can hold all three addresses,
- * anyway).
- */
-
-#define R_Y_OFF		0			/* offset to R => Y section */
-#define G_Y_OFF		(1*(MAXJSAMPLE+1))	/* offset to G => Y section */
-#define B_Y_OFF		(2*(MAXJSAMPLE+1))	/* etc. */
-#define TABLE_SIZE	(3*(MAXJSAMPLE+1))
-
 
 /*
  * Initialize tables for YCbCr->RGB and BG_YCC->RGB colorspace conversion.
@@ -249,17 +239,19 @@ LOCAL(void)
 build_rgb_y_table (j_decompress_ptr cinfo)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  INT32 * rgb_y_tab;
   INT32 i;
 
-  /* Allocate and fill in the conversion tables. */
+  cconvert->R_y_tab = (INT32 *) (*cinfo->mem->alloc_small)
-  cconvert->rgb_y_tab = rgb_y_tab = (INT32 *) (*cinfo->mem->alloc_small)
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
-    ((j_common_ptr) cinfo, JPOOL_IMAGE, TABLE_SIZE * SIZEOF(INT32));
+  cconvert->G_y_tab = (INT32 *) (*cinfo->mem->alloc_small)
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->B_y_tab = (INT32 *) (*cinfo->mem->alloc_small)
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
 
   for (i = 0; i <= MAXJSAMPLE; i++) {
-    rgb_y_tab[i+R_Y_OFF] = FIX(0.299) * i;
+    cconvert->R_y_tab[i] = FIX(0.299) * i;
-    rgb_y_tab[i+G_Y_OFF] = FIX(0.587) * i;
+    cconvert->G_y_tab[i] = FIX(0.587) * i;
-    rgb_y_tab[i+B_Y_OFF] = FIX(0.114) * i + ONE_HALF;
+    cconvert->B_y_tab[i] = FIX(0.114) * i + ONE_HALF;
   }
 }
 
@@ -274,8 +266,10 @@ rgb_gray_convert (j_decompress_ptr cinfo,
 		  JSAMPARRAY output_buf, int num_rows)
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
-  register int r, g, b;
+  register INT32 y;
-  register INT32 * ctab = cconvert->rgb_y_tab;
+  register INT32 * Rytab = cconvert->R_y_tab;
+  register INT32 * Gytab = cconvert->G_y_tab;
+  register INT32 * Bytab = cconvert->B_y_tab;
   register JSAMPROW outptr;
   register JSAMPROW inptr0, inptr1, inptr2;
   register JDIMENSION col;
@@ -288,13 +282,10 @@ rgb_gray_convert (j_decompress_ptr cinfo,
     input_row++;
     outptr = *output_buf++;
     for (col = 0; col < num_cols; col++) {
-      r = GETJSAMPLE(inptr0[col]);
+      y  = Rytab[GETJSAMPLE(inptr0[col])];
-      g = GETJSAMPLE(inptr1[col]);
+      y += Gytab[GETJSAMPLE(inptr1[col])];
-      b = GETJSAMPLE(inptr2[col]);
+      y += Bytab[GETJSAMPLE(inptr2[col])];
-      /* Y */
+      outptr[col] = (JSAMPLE) (y >> SCALEBITS);
-      outptr[col] = (JSAMPLE)
-		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-		 >> SCALEBITS);
     }
   }
 }
@@ -354,7 +345,10 @@ rgb1_gray_convert (j_decompress_ptr cinfo,
 {
   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
   register int r, g, b;
-  register INT32 * ctab = cconvert->rgb_y_tab;
+  register INT32 y;
+  register INT32 * Rytab = cconvert->R_y_tab;
+  register INT32 * Gytab = cconvert->G_y_tab;
+  register INT32 * Bytab = cconvert->B_y_tab;
   register JSAMPROW outptr;
   register JSAMPROW inptr0, inptr1, inptr2;
   register JDIMENSION col;
@@ -373,12 +367,10 @@ rgb1_gray_convert (j_decompress_ptr cinfo,
       /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
        * (modulo) operator is equivalent to the bitmask operator AND.
        */
-      r = (r + g - CENTERJSAMPLE) & MAXJSAMPLE;
+      y  = Rytab[(r + g - CENTERJSAMPLE) & MAXJSAMPLE];
-      b = (b + g - CENTERJSAMPLE) & MAXJSAMPLE;
+      y += Gytab[g];
-      /* Y */
+      y += Bytab[(b + g - CENTERJSAMPLE) & MAXJSAMPLE];
-      outptr[col] = (JSAMPLE)
+      outptr[col] = (JSAMPLE) (y >> SCALEBITS);
-		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
-		 >> SCALEBITS);
     }
   }
 }
@@ -420,7 +412,7 @@ rgb_convert (j_decompress_ptr cinfo,
 /*
  * Color conversion for no colorspace change: just copy the data,
  * converting from separate-planes to interleaved representation.
- * We assume out_color_components == num_components.
+ * Note: Omit uninteresting components in output buffer.
  */
 
 METHODDEF(void)
@@ -431,22 +423,27 @@ null_convert (j_decompress_ptr cinfo,
   register JSAMPROW outptr;
   register JSAMPROW inptr;
   register JDIMENSION count;
-  register int num_comps = cinfo->num_components;
+  register int out_comps = cinfo->out_color_components;
   JDIMENSION num_cols = cinfo->output_width;
+  JSAMPROW startptr;
   int ci;
+  jpeg_component_info *compptr;
 
   while (--num_rows >= 0) {
     /* It seems fastest to make a separate pass for each component. */
-    for (ci = 0; ci < num_comps; ci++) {
+    startptr = *output_buf++;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      if (! compptr->component_needed)
+	continue;		/* skip uninteresting component */
       inptr = input_buf[ci][input_row];
-      outptr = output_buf[0] + ci;
+      outptr = startptr++;
       for (count = num_cols; count > 0; count--) {
 	*outptr = *inptr++;	/* don't need GETJSAMPLE() here */
-	outptr += num_comps;
+	outptr += out_comps;
       }
     }
     input_row++;
-    output_buf++;
   }
 }
 
@@ -462,7 +459,7 @@ grayscale_convert (j_decompress_ptr cinfo,
 		   JSAMPIMAGE input_buf, JDIMENSION input_row,
 		   JSAMPARRAY output_buf, int num_rows)
 {
-  jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+  jcopy_sample_rows(input_buf[0] + input_row, output_buf,
 		    num_rows, cinfo->output_width);
 }
 
@@ -549,6 +546,46 @@ ycck_cmyk_convert (j_decompress_ptr cinfo,
 }
 
 
+/*
+ * Convert CMYK to YK part of YCCK for colorless output.
+ * We assume build_rgb_y_table has been called.
+ */
+
+METHODDEF(void)
+cmyk_yk_convert (j_decompress_ptr cinfo,
+		 JSAMPIMAGE input_buf, JDIMENSION input_row,
+		 JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register INT32 y;
+  register INT32 * Rytab = cconvert->R_y_tab;
+  register INT32 * Gytab = cconvert->G_y_tab;
+  register INT32 * Bytab = cconvert->B_y_tab;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    inptr3 = input_buf[3][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = Rytab[MAXJSAMPLE - GETJSAMPLE(inptr0[col])];
+      y += Gytab[MAXJSAMPLE - GETJSAMPLE(inptr1[col])];
+      y += Bytab[MAXJSAMPLE - GETJSAMPLE(inptr2[col])];
+      outptr[0] = (JSAMPLE) (y >> SCALEBITS);
+      /* K passes through unchanged */
+      outptr[1] = inptr3[col];	/* don't need GETJSAMPLE here */
+      outptr += 2;
+    }
+  }
+}
+
+
 /*
  * Empty method for start_pass.
  */
@@ -568,7 +605,7 @@ GLOBAL(void)
 jinit_color_deconverter (j_decompress_ptr cinfo)
 {
   my_cconvert_ptr cconvert;
-  int ci;
+  int ci, i;
 
   cconvert = (my_cconvert_ptr) (*cinfo->mem->alloc_small)
     ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_color_deconverter));
@@ -608,7 +645,7 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
     ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 
   /* Set out_color_components and conversion method based on requested space.
-   * Also clear the component_needed flags for any unused components,
+   * Also adjust the component_needed flags for any unused components,
    * so that earlier pipeline stages can avoid useless computation.
    */
 
@@ -674,9 +711,9 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
     break;
 
   case JCS_BG_RGB:
-    cinfo->out_color_components = RGB_PIXELSIZE;
     if (cinfo->jpeg_color_space != JCS_BG_RGB)
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    cinfo->out_color_components = RGB_PIXELSIZE;
     switch (cinfo->color_transform) {
     case JCT_NONE:
       cconvert->pub.color_convert = rgb_convert;
@@ -690,25 +727,38 @@ jinit_color_deconverter (j_decompress_ptr cinfo)
     break;
 
   case JCS_CMYK:
+    if (cinfo->jpeg_color_space != JCS_YCCK)
+      goto def_label;
     cinfo->out_color_components = 4;
-    switch (cinfo->jpeg_color_space) {
+    cconvert->pub.color_convert = ycck_cmyk_convert;
-    case JCS_YCCK:
+    build_ycc_rgb_table(cinfo);
-      cconvert->pub.color_convert = ycck_cmyk_convert;
-      build_ycc_rgb_table(cinfo);
-      break;
-    case JCS_CMYK:
-      cconvert->pub.color_convert = null_convert;
-      break;
-    default:
-      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    }
     break;
 
-  default:		/* permit null conversion to same output space */
+  case JCS_YCCK:
+    if (cinfo->jpeg_color_space != JCS_CMYK ||
+	/* Support only YK part of YCCK for colorless output */
+	! cinfo->comp_info[0].component_needed ||
+	  cinfo->comp_info[1].component_needed ||
+	  cinfo->comp_info[2].component_needed ||
+	! cinfo->comp_info[3].component_needed)
+      goto def_label;
+    cinfo->out_color_components = 2;
+    /* Need all components on input side */
+    cinfo->comp_info[1].component_needed = TRUE;
+    cinfo->comp_info[2].component_needed = TRUE;
+    cconvert->pub.color_convert = cmyk_yk_convert;
+    build_rgb_y_table(cinfo);
+    break;
+
+  default: def_label:	/* permit null conversion to same output space */
     if (cinfo->out_color_space != cinfo->jpeg_color_space)
       /* unsupported non-null conversion */
       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
-    cinfo->out_color_components = cinfo->num_components;
+    i = 0;
+    for (ci = 0; ci < cinfo->num_components; ci++)
+      if (cinfo->comp_info[ci].component_needed)
+	i++;		/* count output color components */
+    cinfo->out_color_components = i;
     cconvert->pub.color_convert = null_convert;
   }
 

3rdparty/libjpeg/jdct.h

@@ -2,7 +2,7 @@
  * jdct.h
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2002-2019 by Guido Vollbeding.
+ * Modified 2002-2023 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -158,7 +158,7 @@ typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
 #define jpeg_idct_6x12		jRD6x12
 #define jpeg_idct_5x10		jRD5x10
 #define jpeg_idct_4x8		jRD4x8
-#define jpeg_idct_3x6		jRD3x8
+#define jpeg_idct_3x6		jRD3x6
 #define jpeg_idct_2x4		jRD2x4
 #define jpeg_idct_1x2		jRD1x2
 #endif /* NEED_SHORT_EXTERNAL_NAMES */

3rdparty/libjpeg/jdhuff.c

@@ -2,7 +2,7 @@
  * jdhuff.c
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2006-2019 by Guido Vollbeding.
+ * Modified 2006-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -704,7 +704,7 @@ process_restart (j_decompress_ptr cinfo)
  */
 
 METHODDEF(boolean)
-decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   int Al = cinfo->Al;
@@ -776,7 +776,7 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   register int s, k, r;
@@ -864,7 +864,7 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   JCOEF p1;
@@ -913,7 +913,7 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   register int s, k, r;
@@ -1072,7 +1072,7 @@ undoit:
  */
 
 METHODDEF(boolean)
-decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   const int * natural_order;
@@ -1201,7 +1201,7 @@ decode_mcu_sub (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
  */
 
 METHODDEF(boolean)
-decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data)
 {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   int blkn;

3rdparty/libjpeg/jdinput.c

@@ -2,7 +2,7 @@
  * jdinput.c
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2002-2013 by Guido Vollbeding.
+ * Modified 2002-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -330,7 +330,6 @@ initial_setup (j_decompress_ptr cinfo)
     default:
       ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
 	       cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
-      break;
     }
 
   /* We initialize DCT_scaled_size and min_DCT_scaled_size to block_size.
@@ -429,9 +428,7 @@ per_scan_setup (j_decompress_ptr cinfo)
     cinfo->MCUs_per_row = (JDIMENSION)
       jdiv_round_up((long) cinfo->image_width,
 		    (long) (cinfo->max_h_samp_factor * cinfo->block_size));
-    cinfo->MCU_rows_in_scan = (JDIMENSION)
+    cinfo->MCU_rows_in_scan = cinfo->total_iMCU_rows;
-      jdiv_round_up((long) cinfo->image_height,
-		    (long) (cinfo->max_v_samp_factor * cinfo->block_size));
 
     cinfo->blocks_in_MCU = 0;
 
@@ -501,9 +498,8 @@ latch_quant_tables (j_decompress_ptr cinfo)
 	cinfo->quant_tbl_ptrs[qtblno] == NULL)
       ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
     /* OK, save away the quantization table */
-    qtbl = (JQUANT_TBL *)
+    qtbl = (JQUANT_TBL *) (*cinfo->mem->alloc_small)
-      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(JQUANT_TBL));
-				  SIZEOF(JQUANT_TBL));
     MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
     compptr->quant_table = qtbl;
   }
@@ -644,9 +640,8 @@ jinit_input_controller (j_decompress_ptr cinfo)
   my_inputctl_ptr inputctl;
 
   /* Create subobject in permanent pool */
-  inputctl = (my_inputctl_ptr)
+  inputctl = (my_inputctl_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+    ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_input_controller));
-				SIZEOF(my_input_controller));
   cinfo->inputctl = &inputctl->pub;
   /* Initialize method pointers */
   inputctl->pub.consume_input = consume_markers;

3rdparty/libjpeg/jdmainct.c

@@ -2,7 +2,7 @@
  * jdmainct.c
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2002-2016 by Guido Vollbeding.
+ * Modified 2002-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -170,21 +170,22 @@ alloc_funny_pointers (j_decompress_ptr cinfo)
   /* Get top-level space for component array pointers.
    * We alloc both arrays with one call to save a few cycles.
    */
-  mainp->xbuffer[0] = (JSAMPIMAGE)
+  mainp->xbuffer[0] = (JSAMPIMAGE) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
+     cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
   mainp->xbuffer[1] = mainp->xbuffer[0] + cinfo->num_components;
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
+    if (! compptr->component_needed)
+      continue;			/* skip uninteresting component */
     rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
       cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
     /* Get space for pointer lists --- M+4 row groups in each list.
      * We alloc both pointer lists with one call to save a few cycles.
      */
-    xbuf = (JSAMPARRAY)
+    xbuf = (JSAMPARRAY) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
-      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+      JPOOL_IMAGE, 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
-				  2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
     xbuf += rgroup;		/* want one row group at negative offsets */
     mainp->xbuffer[0][ci] = xbuf;
     xbuf += rgroup * (M + 4);
@@ -210,6 +211,8 @@ make_funny_pointers (j_decompress_ptr cinfo)
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
+    if (! compptr->component_needed)
+      continue;			/* skip uninteresting component */
     rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
       cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
     xbuf0 = mainp->xbuffer[0][ci];
@@ -250,6 +253,8 @@ set_wraparound_pointers (j_decompress_ptr cinfo)
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
+    if (! compptr->component_needed)
+      continue;			/* skip uninteresting component */
     rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
       cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
     xbuf0 = mainp->xbuffer[0][ci];
@@ -278,6 +283,8 @@ set_bottom_pointers (j_decompress_ptr cinfo)
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
+    if (! compptr->component_needed)
+      continue;			/* skip uninteresting component */
     /* Count sample rows in one iMCU row and in one row group */
     iMCUheight = compptr->v_samp_factor * compptr->DCT_v_scaled_size;
     rgroup = iMCUheight / cinfo->min_DCT_v_scaled_size;
@@ -333,7 +340,6 @@ start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
 #endif
   default:
     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
-    break;
   }
 }
 
@@ -344,9 +350,8 @@ start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
  */
 
 METHODDEF(void)
-process_data_simple_main (j_decompress_ptr cinfo,
+process_data_simple_main (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
-			  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			  JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
-			  JDIMENSION out_rows_avail)
 {
   my_main_ptr mainp = (my_main_ptr) cinfo->main;
 
@@ -375,9 +380,8 @@ process_data_simple_main (j_decompress_ptr cinfo,
  */
 
 METHODDEF(void)
-process_data_context_main (j_decompress_ptr cinfo,
+process_data_context_main (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
-			   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			   JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
-			   JDIMENSION out_rows_avail)
 {
   my_main_ptr mainp = (my_main_ptr) cinfo->main;
 
@@ -449,13 +453,12 @@ process_data_context_main (j_decompress_ptr cinfo,
 #ifdef QUANT_2PASS_SUPPORTED
 
 METHODDEF(void)
-process_data_crank_post (j_decompress_ptr cinfo,
+process_data_crank_post (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
-			 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			 JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
-			 JDIMENSION out_rows_avail)
 {
   (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
-				     (JDIMENSION *) NULL, (JDIMENSION) 0,
+			(JDIMENSION *) NULL, (JDIMENSION) 0,
-				     output_buf, out_row_ctr, out_rows_avail);
+			output_buf, out_row_ctr, out_rows_avail);
 }
 
 #endif /* QUANT_2PASS_SUPPORTED */
@@ -472,9 +475,8 @@ jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
   int ci, rgroup, ngroups;
   jpeg_component_info *compptr;
 
-  mainp = (my_main_ptr)
+  mainp = (my_main_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_main_controller));
-				SIZEOF(my_main_controller));
   cinfo->main = &mainp->pub;
   mainp->pub.start_pass = start_pass_main;
 
@@ -497,6 +499,8 @@ jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
 
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
+    if (! compptr->component_needed)
+      continue;			/* skip uninteresting component */
     rgroup = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
       cinfo->min_DCT_v_scaled_size; /* height of a row group of component */
     mainp->buffer[ci] = (*cinfo->mem->alloc_sarray)

3rdparty/libjpeg/jdmaster.c

@@ -2,7 +2,7 @@
  * jdmaster.c
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 2002-2019 by Guido Vollbeding.
+ * Modified 2002-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -103,10 +103,8 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
  * This function is used for full decompression.
  */
 {
-#ifdef IDCT_SCALING_SUPPORTED
+  int ci, i;
-  int ci, ssize;
   jpeg_component_info *compptr;
-#endif
 
   /* Prevent application from calling me at wrong times */
   if (cinfo->global_state != DSTATE_READY)
@@ -124,7 +122,7 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
    */
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
-    ssize = 1;
+    int ssize = 1;
     if (! cinfo->raw_data_out)
       while (cinfo->min_DCT_h_scaled_size * ssize <=
 	     (cinfo->do_fancy_upsampling ? DCTSIZE : DCTSIZE / 2) &&
@@ -166,27 +164,22 @@ jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
 #endif /* IDCT_SCALING_SUPPORTED */
 
   /* Report number of components in selected colorspace. */
-  /* Probably this should be in the color conversion module... */
+  /* This should correspond to the actual code in the color conversion module. */
   switch (cinfo->out_color_space) {
   case JCS_GRAYSCALE:
     cinfo->out_color_components = 1;
     break;
   case JCS_RGB:
   case JCS_BG_RGB:
-#if RGB_PIXELSIZE != 3
     cinfo->out_color_components = RGB_PIXELSIZE;
     break;
-#endif /* else share code with YCbCr */
+  default:	/* YCCK <=> CMYK conversion or same colorspace as in file */
-  case JCS_YCbCr:
+    i = 0;
-  case JCS_BG_YCC:
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
-    cinfo->out_color_components = 3;
+	 ci++, compptr++)
-    break;
+      if (compptr->component_needed)
-  case JCS_CMYK:
+	i++;	/* count output color components */
-  case JCS_YCCK:
+    cinfo->out_color_components = i;
-    cinfo->out_color_components = 4;
-    break;
-  default:			/* else must be same colorspace as in file */
-    cinfo->out_color_components = cinfo->num_components;
   }
   cinfo->output_components = (cinfo->quantize_colors ? 1 :
 			      cinfo->out_color_components);

3rdparty/libjpeg/jdmerge.c

@@ -2,7 +2,7 @@
  * jdmerge.c
  *
  * Copyright (C) 1994-1996, Thomas G. Lane.
- * Modified 2013-2019 by Guido Vollbeding.
+ * Modified 2013-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -20,17 +20,17 @@
  *	B = Y + K4 * Cb
  * only the Y term varies among the group of pixels corresponding to a pair
  * of chroma samples, so the rest of the terms can be calculated just once.
- * At typical sampling ratios, this eliminates half or three-quarters of the
+ * At typical sampling ratios, this eliminates half or three-quarters
- * multiplications needed for color conversion.
+ * of the multiplications needed for color conversion.
  *
  * This file currently provides implementations for the following cases:
  *	YCC => RGB color conversion only (YCbCr or BG_YCC).
  *	Sampling ratios of 2h1v or 2h2v.
  *	No scaling needed at upsample time.
  *	Corner-aligned (non-CCIR601) sampling alignment.
- * Other special cases could be added, but in most applications these are
+ * Other special cases could be added, but in most applications these
- * the only common cases.  (For uncommon cases we fall back on the more
+ * are the only common cases.  (For uncommon cases we fall back on
- * general code in jdsample.c and jdcolor.c.)
+ * the more general code in jdsample.c and jdcolor.c.)
  */
 
 #define JPEG_INTERNALS
@@ -190,7 +190,7 @@ merged_2v_upsample (j_decompress_ptr cinfo,
 
   if (upsample->spare_full) {
     /* If we have a spare row saved from a previous cycle, just return it. */
-    jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
+    jcopy_sample_rows(& upsample->spare_row, output_buf + *out_row_ctr,
 		      1, upsample->out_row_width);
     num_rows = 1;
     upsample->spare_full = FALSE;
@@ -286,9 +286,9 @@ h2v1_merged_upsample (j_decompress_ptr cinfo,
     /* Do the chroma part of the calculation */
     cb = GETJSAMPLE(*inptr1++);
     cr = GETJSAMPLE(*inptr2++);
-    cred   = Crrtab[cr];
     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
     cblue  = Cbbtab[cb];
+    cred   = Crrtab[cr];
     /* Fetch 2 Y values and emit 2 pixels */
     y  = GETJSAMPLE(*inptr0++);
     outptr[RGB_RED]   = range_limit[y + cred];
@@ -303,15 +303,14 @@ h2v1_merged_upsample (j_decompress_ptr cinfo,
   }
   /* If image width is odd, do the last output column separately */
   if (cinfo->output_width & 1) {
+    y  = GETJSAMPLE(*inptr0);
     cb = GETJSAMPLE(*inptr1);
     cr = GETJSAMPLE(*inptr2);
-    cred   = Crrtab[cr];
+    outptr[RGB_RED]   = range_limit[y + Crrtab[cr]];
-    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+    outptr[RGB_GREEN] = range_limit[y +
-    cblue  = Cbbtab[cb];
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
-    y  = GETJSAMPLE(*inptr0);
+						 SCALEBITS))];
-    outptr[RGB_RED]   = range_limit[y + cred];
+    outptr[RGB_BLUE]  = range_limit[y + Cbbtab[cb]];
-    outptr[RGB_GREEN] = range_limit[y + cgreen];
-    outptr[RGB_BLUE]  = range_limit[y + cblue];
   }
 }
 
@@ -350,9 +349,9 @@ h2v2_merged_upsample (j_decompress_ptr cinfo,
     /* Do the chroma part of the calculation */
     cb = GETJSAMPLE(*inptr1++);
     cr = GETJSAMPLE(*inptr2++);
-    cred   = Crrtab[cr];
     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
     cblue  = Cbbtab[cb];
+    cred   = Crrtab[cr];
     /* Fetch 4 Y values and emit 4 pixels */
     y  = GETJSAMPLE(*inptr00++);
     outptr0[RGB_RED]   = range_limit[y + cred];
@@ -379,9 +378,9 @@ h2v2_merged_upsample (j_decompress_ptr cinfo,
   if (cinfo->output_width & 1) {
     cb = GETJSAMPLE(*inptr1);
     cr = GETJSAMPLE(*inptr2);
-    cred   = Crrtab[cr];
     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
     cblue  = Cbbtab[cb];
+    cred   = Crrtab[cr];
     y  = GETJSAMPLE(*inptr00);
     outptr0[RGB_RED]   = range_limit[y + cred];
     outptr0[RGB_GREEN] = range_limit[y + cgreen];

3rdparty/libjpeg/jdsample.c

@@ -2,7 +2,7 @@
  * jdsample.c
  *
  * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2002-2015 by Guido Vollbeding.
+ * Modified 2002-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -27,7 +27,7 @@
 /* Pointer to routine to upsample a single component */
 typedef JMETHOD(void, upsample1_ptr,
 		(j_decompress_ptr cinfo, jpeg_component_info * compptr,
-		 JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+		 JSAMPARRAY input_data, JSAMPIMAGE output_data_ptr));
 
 /* Private subobject */
 
@@ -102,6 +102,9 @@ sep_upsample (j_decompress_ptr cinfo,
   if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
 	 ci++, compptr++) {
+      /* Don't bother to upsample an uninteresting component. */
+      if (! compptr->component_needed)
+	continue;
       /* Invoke per-component upsample method.  Notice we pass a POINTER
        * to color_buf[ci], so that fullsize_upsample can change it.
        */
@@ -156,25 +159,12 @@ sep_upsample (j_decompress_ptr cinfo,
 
 METHODDEF(void)
 fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-		   JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+		   JSAMPARRAY input_data, JSAMPIMAGE output_data_ptr)
 {
   *output_data_ptr = input_data;
 }
 
 
-/*
- * This is a no-op version used for "uninteresting" components.
- * These components will not be referenced by color conversion.
- */
-
-METHODDEF(void)
-noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
-{
-  *output_data_ptr = NULL;	/* safety check */
-}
-
-
 /*
  * This version handles any integral sampling ratios.
  * This is not used for typical JPEG files, so it need not be fast.
@@ -188,25 +178,25 @@ noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-	      JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+	      JSAMPARRAY input_data, JSAMPIMAGE output_data_ptr)
 {
   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
-  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPARRAY output_data, output_end;
   register JSAMPROW inptr, outptr;
   register JSAMPLE invalue;
   register int h;
   JSAMPROW outend;
   int h_expand, v_expand;
-  int inrow, outrow;
 
   h_expand = upsample->h_expand[compptr->component_index];
   v_expand = upsample->v_expand[compptr->component_index];
 
-  inrow = outrow = 0;
+  output_data = *output_data_ptr;
-  while (outrow < cinfo->max_v_samp_factor) {
+  output_end = output_data + cinfo->max_v_samp_factor;
+  for (; output_data < output_end; output_data += v_expand) {
     /* Generate one output row with proper horizontal expansion */
-    inptr = input_data[inrow];
+    inptr = *input_data++;
-    outptr = output_data[outrow];
+    outptr = *output_data;
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
       invalue = *inptr++;	/* don't need GETJSAMPLE() here */
@@ -216,11 +206,9 @@ int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
     }
     /* Generate any additional output rows by duplicating the first one */
     if (v_expand > 1) {
-      jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+      jcopy_sample_rows(output_data, output_data + 1,
-			v_expand-1, cinfo->output_width);
+			v_expand - 1, cinfo->output_width);
     }
-    inrow++;
-    outrow += v_expand;
   }
 }
 
@@ -232,7 +220,7 @@ int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+	       JSAMPARRAY input_data, JSAMPIMAGE output_data_ptr)
 {
   JSAMPARRAY output_data = *output_data_ptr;
   register JSAMPROW inptr, outptr;
@@ -260,28 +248,26 @@ h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
 
 METHODDEF(void)
 h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
-	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+	       JSAMPARRAY input_data, JSAMPIMAGE output_data_ptr)
 {
-  JSAMPARRAY output_data = *output_data_ptr;
+  JSAMPARRAY output_data, output_end;
   register JSAMPROW inptr, outptr;
   register JSAMPLE invalue;
   JSAMPROW outend;
-  int inrow, outrow;
 
-  inrow = outrow = 0;
+  output_data = *output_data_ptr;
-  while (outrow < cinfo->max_v_samp_factor) {
+  output_end = output_data + cinfo->max_v_samp_factor;
-    inptr = input_data[inrow];
+  for (; output_data < output_end; output_data += 2) {
-    outptr = output_data[outrow];
+    inptr = *input_data++;
+    outptr = *output_data;
     outend = outptr + cinfo->output_width;
     while (outptr < outend) {
       invalue = *inptr++;	/* don't need GETJSAMPLE() here */
       *outptr++ = invalue;
       *outptr++ = invalue;
     }
-    jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+    jcopy_sample_rows(output_data, output_data + 1,
 		      1, cinfo->output_width);
-    inrow++;
-    outrow += 2;
   }
 }
 
@@ -298,9 +284,8 @@ jinit_upsampler (j_decompress_ptr cinfo)
   jpeg_component_info * compptr;
   int h_in_group, v_in_group, h_out_group, v_out_group;
 
-  upsample = (my_upsample_ptr)
+  upsample = (my_upsample_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_upsampler));
-				SIZEOF(my_upsampler));
   cinfo->upsample = &upsample->pub;
   upsample->pub.start_pass = start_pass_upsample;
   upsample->pub.upsample = sep_upsample;
@@ -314,6 +299,9 @@ jinit_upsampler (j_decompress_ptr cinfo)
    */
   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
        ci++, compptr++) {
+    /* Don't bother to upsample an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
     /* Compute size of an "input group" after IDCT scaling.  This many samples
      * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
      */
@@ -324,11 +312,6 @@ jinit_upsampler (j_decompress_ptr cinfo)
     h_out_group = cinfo->max_h_samp_factor;
     v_out_group = cinfo->max_v_samp_factor;
     upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
-    if (! compptr->component_needed) {
-      /* Don't bother to upsample an uninteresting component. */
-      upsample->methods[ci] = noop_upsample;
-      continue;		/* don't need to allocate buffer */
-    }
     if (h_in_group == h_out_group && v_in_group == v_out_group) {
       /* Fullsize components can be processed without any work. */
       upsample->methods[ci] = fullsize_upsample;

3rdparty/libjpeg/jinclude.h

@@ -2,7 +2,7 @@
  * jinclude.h
  *
  * Copyright (C) 1991-1994, Thomas G. Lane.
- * Modified 2017 by Guido Vollbeding.
+ * Modified 2017-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -11,8 +11,8 @@
  * care of by the standard jconfig symbols, but on really weird systems
  * you may have to edit this file.)
  *
- * NOTE: this file is NOT intended to be included by applications using the
+ * NOTE: this file is NOT intended to be included by applications using
- * JPEG library.  Most applications need only include jpeglib.h.
+ * the JPEG library.  Most applications need only include jpeglib.h.
  */
 
 
@@ -87,11 +87,71 @@
  *
  * Furthermore, macros are provided for fflush() and ferror() in order
  * to facilitate adaption by applications using an own FILE class.
+ *
+ * You can define your own custom file I/O functions in jconfig.h and
+ * #define JPEG_HAVE_FILE_IO_CUSTOM there to prevent redefinition here.
+ *
+ * You can #define JPEG_USE_FILE_IO_CUSTOM in jconfig.h to use custom file
+ * I/O functions implemented in Delphi VCL (Visual Component Library)
+ * in Vcl.Imaging.jpeg.pas for the TJPEGImage component utilizing
+ * the Delphi RTL (Run-Time Library) TMemoryStream component:
+ *
+ *   procedure jpeg_stdio_src(var cinfo: jpeg_decompress_struct;
+ *     input_file: TStream); external;
+ *
+ *   procedure jpeg_stdio_dest(var cinfo: jpeg_compress_struct;
+ *     output_file: TStream); external;
+ *
+ *   function jfread(var buf; recsize, reccount: Integer; S: TStream): Integer;
+ *   begin
+ *     Result := S.Read(buf, recsize * reccount);
+ *   end;
+ *
+ *   function jfwrite(const buf; recsize, reccount: Integer; S: TStream): Integer;
+ *   begin
+ *     Result := S.Write(buf, recsize * reccount);
+ *   end;
+ *
+ *   function jfflush(S: TStream): Integer;
+ *   begin
+ *     Result := 0;
+ *   end;
+ *
+ *   function jferror(S: TStream): Integer;
+ *   begin
+ *     Result := 0;
+ *   end;
+ *
+ * TMemoryStream of Delphi RTL has the distinctive feature to provide dynamic
+ * memory buffer management with a file/stream-based interface, particularly for
+ * the write (output) operation, which is easier to apply compared with direct
+ * implementations as given in jdatadst.c for memory destination.  Those direct
+ * implementations of dynamic memory write tend to be more difficult to use,
+ * so providing an option like TMemoryStream may be a useful alternative.
+ *
+ * The CFile/CMemFile classes of the Microsoft Foundation Class (MFC) Library
+ * may be used in a similar fashion.
  */
 
+#ifndef JPEG_HAVE_FILE_IO_CUSTOM
+#ifdef JPEG_USE_FILE_IO_CUSTOM
+extern size_t jfread(void * __ptr, size_t __size, size_t __n, FILE * __stream);
+extern size_t jfwrite(const void * __ptr, size_t __size, size_t __n, FILE * __stream);
+extern int    jfflush(FILE * __stream);
+extern int    jferror(FILE * __fp);
+
+#define JFREAD(file,buf,sizeofbuf)  \
+  ((size_t) jfread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFWRITE(file,buf,sizeofbuf)  \
+  ((size_t) jfwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFFLUSH(file)	jfflush(file)
+#define JFERROR(file)	jferror(file)
+#else
 #define JFREAD(file,buf,sizeofbuf)  \
   ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
 #define JFWRITE(file,buf,sizeofbuf)  \
   ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
 #define JFFLUSH(file)	fflush(file)
 #define JFERROR(file)	ferror(file)
+#endif
+#endif

3rdparty/libjpeg/jmorecfg.h

@@ -2,7 +2,7 @@
  * jmorecfg.h
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 1997-2013 by Guido Vollbeding.
+ * Modified 1997-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -351,8 +351,8 @@ typedef enum { FALSE = 0, TRUE = 1 } boolean;
 
 #define C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
 #define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
-#define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN) */
-#define DCT_SCALING_SUPPORTED	    /* Input rescaling via DCT? (Requires DCT_ISLOW)*/
+#define DCT_SCALING_SUPPORTED	/* Input rescaling via DCT? (Requires DCT_ISLOW) */
 #define ENTROPY_OPT_SUPPORTED	    /* Optimization of entropy coding parms? */
 /* Note: if you selected more than 8-bit data precision, it is dangerous to
  * turn off ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only
@@ -369,8 +369,8 @@ typedef enum { FALSE = 0, TRUE = 1 } boolean;
 
 #define D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
 #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
-#define D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#define D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN) */
-#define IDCT_SCALING_SUPPORTED	    /* Output rescaling via IDCT? (Requires DCT_ISLOW)*/
+#define IDCT_SCALING_SUPPORTED	/* Output rescaling via IDCT? (Requires DCT_ISLOW) */
 #define SAVE_MARKERS_SUPPORTED	    /* jpeg_save_markers() needed? */
 #define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
 #undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
@@ -384,20 +384,31 @@ typedef enum { FALSE = 0, TRUE = 1 } boolean;
 /*
  * Ordering of RGB data in scanlines passed to or from the application.
  * If your application wants to deal with data in the order B,G,R, just
- * change these macros.  You can also deal with formats such as R,G,B,X
+ * #define JPEG_USE_RGB_CUSTOM in jconfig.h, or define your own custom
- * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
+ * order in jconfig.h and #define JPEG_HAVE_RGB_CUSTOM.
- * the offsets will also change the order in which colormap data is organized.
+ * You can also deal with formats such as R,G,B,X (one extra byte per pixel)
+ * by changing RGB_PIXELSIZE.
+ * Note that changing the offsets will also change
+ * the order in which colormap data is organized.
  * RESTRICTIONS:
  * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
  * 2. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
- *    is not 3 (they don't understand about dummy color components!).  So you
+ *    is not 3 (they don't understand about dummy color components!).
- *    can't use color quantization if you change that value.
+ *    So you can't use color quantization if you change that value.
  */
 
+#ifndef JPEG_HAVE_RGB_CUSTOM
+#ifdef JPEG_USE_RGB_CUSTOM
+#define RGB_RED		2	/* Offset of Red in an RGB scanline element */
+#define RGB_GREEN	1	/* Offset of Green */
+#define RGB_BLUE	0	/* Offset of Blue */
+#else
 #define RGB_RED		0	/* Offset of Red in an RGB scanline element */
 #define RGB_GREEN	1	/* Offset of Green */
 #define RGB_BLUE	2	/* Offset of Blue */
+#endif
 #define RGB_PIXELSIZE	3	/* JSAMPLEs per RGB scanline element */
+#endif
 
 
 /* Definitions for speed-related optimizations. */

3rdparty/libjpeg/jpegint.h

@@ -2,7 +2,7 @@
  * jpegint.h
  *
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * Modified 1997-2019 by Guido Vollbeding.
+ * Modified 1997-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -103,8 +103,7 @@ struct jpeg_downsampler {
 typedef JMETHOD(void, forward_DCT_ptr,
 		(j_compress_ptr cinfo, jpeg_component_info * compptr,
 		 JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
-		 JDIMENSION start_row, JDIMENSION start_col,
+		 JDIMENSION start_col, JDIMENSION num_blocks));
-		 JDIMENSION num_blocks));
 
 struct jpeg_forward_dct {
   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
@@ -115,7 +114,7 @@ struct jpeg_forward_dct {
 /* Entropy encoding */
 struct jpeg_entropy_encoder {
   JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
-  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKARRAY MCU_data));
   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
 };
 
@@ -211,7 +210,7 @@ struct jpeg_marker_reader {
 /* Entropy decoding */
 struct jpeg_entropy_decoder {
   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
-  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, JBLOCKROW *MCU_data));
+  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, JBLOCKARRAY MCU_data));
   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
 };
 
@@ -416,8 +415,8 @@ EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
 /* Utility routines in jutils.c */
 EXTERN(long) jdiv_round_up JPP((long a, long b));
 EXTERN(long) jround_up JPP((long a, long b));
-EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
+EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array,
-				    JSAMPARRAY output_array, int dest_row,
+				    JSAMPARRAY output_array,
 				    int num_rows, JDIMENSION num_cols));
 EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
 				  JDIMENSION num_blocks));

3rdparty/libjpeg/jpeglib.h

@@ -2,7 +2,7 @@
  * jpeglib.h
  *
  * Copyright (C) 1991-1998, Thomas G. Lane.
- * Modified 2002-2019 by Guido Vollbeding.
+ * Modified 2002-2022 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -39,7 +39,7 @@ extern "C" {
 
 #define JPEG_LIB_VERSION        90	/* Compatibility version 9.0 */
 #define JPEG_LIB_VERSION_MAJOR  9
-#define JPEG_LIB_VERSION_MINOR  4
+#define JPEG_LIB_VERSION_MINOR  6
 
 
 /* Various constants determining the sizes of things.

3rdparty/libjpeg/jquant1.c

@@ -2,7 +2,7 @@
  * jquant1.c
  *
  * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2011 by Guido Vollbeding.
+ * Modified 2011-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -293,8 +293,7 @@ create_colormap (j_decompress_ptr cinfo)
   /* The colors are ordered in the map in standard row-major order, */
   /* i.e. rightmost (highest-indexed) color changes most rapidly. */
 
-  colormap = (*cinfo->mem->alloc_sarray)
+  colormap = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-    ((j_common_ptr) cinfo, JPOOL_IMAGE,
      (JDIMENSION) total_colors, (JDIMENSION) cinfo->out_color_components);
 
   /* blksize is number of adjacent repeated entries for a component */
@@ -400,9 +399,8 @@ make_odither_array (j_decompress_ptr cinfo, int ncolors)
   int j,k;
   INT32 num,den;
 
-  odither = (ODITHER_MATRIX_PTR)
+  odither = (ODITHER_MATRIX_PTR) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(ODITHER_MATRIX));
-				SIZEOF(ODITHER_MATRIX));
   /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
    * Hence the dither value for the matrix cell with fill order f
    * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
@@ -531,8 +529,7 @@ quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
   for (row = 0; row < num_rows; row++) {
     /* Initialize output values to 0 so can process components separately */
-    FMEMZERO((void FAR *) output_buf[row],
+    FMEMZERO((void FAR *) output_buf[row], (size_t) width * SIZEOF(JSAMPLE));
-	     (size_t) (width * SIZEOF(JSAMPLE)));
     row_index = cquantize->row_index;
     for (ci = 0; ci < nc; ci++) {
       input_ptr = input_buf[row] + ci;
@@ -636,8 +633,7 @@ quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
 
   for (row = 0; row < num_rows; row++) {
     /* Initialize output values to 0 so can process components separately */
-    FMEMZERO((void FAR *) output_buf[row],
+    FMEMZERO((void FAR *) output_buf[row], (size_t) width * SIZEOF(JSAMPLE));
-	     (size_t) (width * SIZEOF(JSAMPLE)));
     for (ci = 0; ci < nc; ci++) {
       input_ptr = input_buf[row] + ci;
       output_ptr = output_buf[row];
@@ -726,10 +722,10 @@ alloc_fs_workspace (j_decompress_ptr cinfo)
   size_t arraysize;
   int i;
 
-  arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));
+  arraysize = ((size_t) cinfo->output_width + (size_t) 2) * SIZEOF(FSERROR);
   for (i = 0; i < cinfo->out_color_components; i++) {
-    cquantize->fserrors[i] = (FSERRPTR)
+    cquantize->fserrors[i] = (FSERRPTR) (*cinfo->mem->alloc_large)
-      (*cinfo->mem->alloc_large)((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+      ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
   }
 }
 
@@ -780,13 +776,12 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
     if (cquantize->fserrors[0] == NULL)
       alloc_fs_workspace(cinfo);
     /* Initialize the propagated errors to zero. */
-    arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));
+    arraysize = ((size_t) cinfo->output_width + (size_t) 2) * SIZEOF(FSERROR);
     for (i = 0; i < cinfo->out_color_components; i++)
       FMEMZERO((void FAR *) cquantize->fserrors[i], arraysize);
     break;
   default:
     ERREXIT(cinfo, JERR_NOT_COMPILED);
-    break;
   }
 }
 
@@ -823,10 +818,9 @@ jinit_1pass_quantizer (j_decompress_ptr cinfo)
 {
   my_cquantize_ptr cquantize;
 
-  cquantize = (my_cquantize_ptr)
+  cquantize = (my_cquantize_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_cquantizer));
-				SIZEOF(my_cquantizer));
+  cinfo->cquantize = &cquantize->pub;
-  cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
   cquantize->pub.start_pass = start_pass_1_quant;
   cquantize->pub.finish_pass = finish_pass_1_quant;
   cquantize->pub.new_color_map = new_color_map_1_quant;

3rdparty/libjpeg/jquant2.c

@@ -2,7 +2,7 @@
  * jquant2.c
  *
  * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2011 by Guido Vollbeding.
+ * Modified 2011-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -1197,8 +1197,8 @@ start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
       ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
 
     if (cinfo->dither_mode == JDITHER_FS) {
-      size_t arraysize = (size_t) ((cinfo->output_width + 2) *
+      size_t arraysize = ((size_t) cinfo->output_width + (size_t) 2)
-				   (3 * SIZEOF(FSERROR)));
+	* (3 * SIZEOF(FSERROR));
       /* Allocate Floyd-Steinberg workspace if we didn't already. */
       if (cquantize->fserrors == NULL)
 	cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
@@ -1247,10 +1247,9 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)
   my_cquantize_ptr cquantize;
   int i;
 
-  cquantize = (my_cquantize_ptr)
+  cquantize = (my_cquantize_ptr) (*cinfo->mem->alloc_small)
-    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_cquantizer));
-				SIZEOF(my_cquantizer));
+  cinfo->cquantize = &cquantize->pub;
-  cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
   cquantize->pub.start_pass = start_pass_2_quant;
   cquantize->pub.new_color_map = new_color_map_2_quant;
   cquantize->fserrors = NULL;	/* flag optional arrays not allocated */
@@ -1284,7 +1283,8 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)
     if (desired > MAXNUMCOLORS)
       ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
     cquantize->sv_colormap = (*cinfo->mem->alloc_sarray)
-      ((j_common_ptr) cinfo,JPOOL_IMAGE, (JDIMENSION) desired, (JDIMENSION) 3);
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       (JDIMENSION) desired, (JDIMENSION) 3);
     cquantize->desired = desired;
   } else
     cquantize->sv_colormap = NULL;
@@ -1302,7 +1302,7 @@ jinit_2pass_quantizer (j_decompress_ptr cinfo)
   if (cinfo->dither_mode == JDITHER_FS) {
     cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
       ((j_common_ptr) cinfo, JPOOL_IMAGE,
-       (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR))));
+       ((size_t) cinfo->output_width + (size_t) 2) * (3 * SIZEOF(FSERROR)));
     /* Might as well create the error-limiting table too. */
     init_error_limit(cinfo);
   }

3rdparty/libjpeg/jutils.c

@@ -2,7 +2,7 @@
  * jutils.c
  *
  * Copyright (C) 1991-1996, Thomas G. Lane.
- * Modified 2009-2019 by Guido Vollbeding.
+ * Modified 2009-2020 by Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -52,67 +52,67 @@ const int jpeg_zigzag_order[DCTSIZE2] = {
  */
 
 const int jpeg_natural_order[DCTSIZE2+16] = {
-  0,  1,  8, 16,  9,  2,  3, 10,
+   0,  1,  8, 16,  9,  2,  3, 10,
- 17, 24, 32, 25, 18, 11,  4,  5,
+  17, 24, 32, 25, 18, 11,  4,  5,
- 12, 19, 26, 33, 40, 48, 41, 34,
+  12, 19, 26, 33, 40, 48, 41, 34,
- 27, 20, 13,  6,  7, 14, 21, 28,
+  27, 20, 13,  6,  7, 14, 21, 28,
- 35, 42, 49, 56, 57, 50, 43, 36,
+  35, 42, 49, 56, 57, 50, 43, 36,
- 29, 22, 15, 23, 30, 37, 44, 51,
+  29, 22, 15, 23, 30, 37, 44, 51,
- 58, 59, 52, 45, 38, 31, 39, 46,
+  58, 59, 52, 45, 38, 31, 39, 46,
- 53, 60, 61, 54, 47, 55, 62, 63,
+  53, 60, 61, 54, 47, 55, 62, 63,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 const int jpeg_natural_order7[7*7+16] = {
-  0,  1,  8, 16,  9,  2,  3, 10,
+   0,  1,  8, 16,  9,  2,  3, 10,
- 17, 24, 32, 25, 18, 11,  4,  5,
+  17, 24, 32, 25, 18, 11,  4,  5,
- 12, 19, 26, 33, 40, 48, 41, 34,
+  12, 19, 26, 33, 40, 48, 41, 34,
- 27, 20, 13,  6, 14, 21, 28, 35,
+  27, 20, 13,  6, 14, 21, 28, 35,
- 42, 49, 50, 43, 36, 29, 22, 30,
+  42, 49, 50, 43, 36, 29, 22, 30,
- 37, 44, 51, 52, 45, 38, 46, 53,
+  37, 44, 51, 52, 45, 38, 46, 53,
- 54,
+  54,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 const int jpeg_natural_order6[6*6+16] = {
-  0,  1,  8, 16,  9,  2,  3, 10,
+   0,  1,  8, 16,  9,  2,  3, 10,
- 17, 24, 32, 25, 18, 11,  4,  5,
+  17, 24, 32, 25, 18, 11,  4,  5,
- 12, 19, 26, 33, 40, 41, 34, 27,
+  12, 19, 26, 33, 40, 41, 34, 27,
- 20, 13, 21, 28, 35, 42, 43, 36,
+  20, 13, 21, 28, 35, 42, 43, 36,
- 29, 37, 44, 45,
+  29, 37, 44, 45,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 const int jpeg_natural_order5[5*5+16] = {
-  0,  1,  8, 16,  9,  2,  3, 10,
+   0,  1,  8, 16,  9,  2,  3, 10,
- 17, 24, 32, 25, 18, 11,  4, 12,
+  17, 24, 32, 25, 18, 11,  4, 12,
- 19, 26, 33, 34, 27, 20, 28, 35,
+  19, 26, 33, 34, 27, 20, 28, 35,
- 36,
+  36,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 const int jpeg_natural_order4[4*4+16] = {
-  0,  1,  8, 16,  9,  2,  3, 10,
+   0,  1,  8, 16,  9,  2,  3, 10,
- 17, 24, 25, 18, 11, 19, 26, 27,
+  17, 24, 25, 18, 11, 19, 26, 27,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 const int jpeg_natural_order3[3*3+16] = {
-  0,  1,  8, 16,  9,  2, 10, 17,
+   0,  1,  8, 16,  9,  2, 10, 17,
- 18,
+  18,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 const int jpeg_natural_order2[2*2+16] = {
-  0,  1,  8,  9,
+   0,  1,  8,  9,
- 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
- 63, 63, 63, 63, 63, 63, 63, 63
+  63, 63, 63, 63, 63, 63, 63, 63
 };
 
 
@@ -174,12 +174,12 @@ jzero_far (void FAR * target, size_t bytestozero)
 
 
 GLOBAL(void)
-jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
+jcopy_sample_rows (JSAMPARRAY input_array,
-		   JSAMPARRAY output_array, int dest_row,
+		   JSAMPARRAY output_array,
 		   int num_rows, JDIMENSION num_cols)
 /* Copy some rows of samples from one place to another.
- * num_rows rows are copied from input_array[source_row++]
+ * num_rows rows are copied from *input_array++ to *output_array++;
- * to output_array[dest_row++]; these areas may overlap for duplication.
+ * these areas may overlap for duplication.
  * The source and destination arrays must be at least as wide as num_cols.
  */
 {
@@ -191,9 +191,6 @@ jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
 #endif
   register int row;
 
-  input_array += source_row;
-  output_array += dest_row;
-
   for (row = num_rows; row > 0; row--) {
     inptr = *input_array++;
     outptr = *output_array++;

3rdparty/libjpeg/jversion.h

@@ -1,7 +1,7 @@
 /*
  * jversion.h
  *
- * Copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+ * Copyright (C) 1991-2024, Thomas G. Lane, Guido Vollbeding.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -9,6 +9,6 @@
  */
 
 
-#define JVERSION	"9d  12-Jan-2020"
+#define JVERSION	"9f  14-Jan-2024"
 
-#define JCOPYRIGHT	"Copyright (C) 2020, Thomas G. Lane, Guido Vollbeding"
+#define JCOPYRIGHT	"Copyright (C) 2024, Thomas G. Lane, Guido Vollbeding"

3rdparty/libtiff/CMakeLists.txt

@@ -124,17 +124,17 @@ elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL 8)
 endif()
 
 if(SIZEOF_UNSIGNED_INT EQUAL SIZEOF_SIZE_T)
-  set(TIFF_SIZE_T "unsigned int")
+  set(TIFF_SIZE_T "uint32_t")
   set(TIFF_SIZE_FORMAT "%u")
-  set(TIFF_SSIZE_T "signed int")
+  set(TIFF_SSIZE_T "int32_t")
   set(TIFF_SSIZE_FORMAT "%d")
 elseif(SIZEOF_UNSIGNED_LONG EQUAL SIZEOF_SIZE_T)
-  set(TIFF_SIZE_T "unsigned long")
+  set(TIFF_SIZE_T "uint64_t")
   set(TIFF_SIZE_FORMAT "%lu")
-  set(TIFF_SSIZE_T "signed long")
+  set(TIFF_SSIZE_T "int64_t")
   set(TIFF_SSIZE_FORMAT "%ld")
 elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL SIZEOF_SIZE_T)
-  set(TIFF_SIZE_T "unsigned long")
+  set(TIFF_SIZE_T "uint64_t")
   if(MINGW)
     set(TIFF_SIZE_FORMAT "%I64u")
     set(TIFF_SSIZE_FORMAT "%I64d")
@@ -198,20 +198,6 @@ check_function_exists(strtol     HAVE_STRTOUL)
 check_function_exists(strtoull   HAVE_STRTOULL)
 check_function_exists(lfind      HAVE_LFIND)
 
-# May be inlined, so check it compiles:
-check_c_source_compiles("
-#include <stdio.h>
-int main(void) {
-  char buf[10];
-  snprintf(buf, 10, \"Test %d\", 1);
-  return 0;
-}"
-  HAVE_SNPRINTF)
-
-if(NOT HAVE_SNPRINTF)
-  add_definitions(-DNEED_LIBPORT)
-endif()
-
 # CPU bit order
 set(fillorder FILLORDER_MSB2LSB)
 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i.*86.*" OR
@@ -371,7 +357,13 @@ if(LIBLZMA_LIBRARIES)
   list(APPEND TIFF_LIBRARY_DEPS ${LIBLZMA_LIBRARIES})
 endif()
 
+set(LIBTIFF_MAJOR_VERSION "4")
+set(LIBTIFF_MINOR_VERSION "6")
+set(LIBTIFF_MICRO_VERSION "0")
+set(LIBTIFF_VERSION "${LIBTIFF_MAJOR_VERSION}.${LIBTIFF_MINOR_VERSION}.${LIBTIFF_MICRO_VERSION}")
+file(READ "RELEASE-DATE" LIBTIFF_RELEASE_DATE content)
 
+set(TIFF_MAX_DIR_COUNT "1048576")
 
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmake.in"
                "${CMAKE_CURRENT_BINARY_DIR}/tif_config.h"
@@ -379,6 +371,9 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmake.in"
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tiffconf.h.cmake.in"
                "${CMAKE_CURRENT_BINARY_DIR}/tiffconf.h"
                @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tiffvers.h.cmake.in"
+               "${CMAKE_CURRENT_BINARY_DIR}/tiffvers.h"
+               @ONLY)
 
 ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIRS})
 
@@ -399,6 +394,7 @@ set(lib_srcs
     tif_fax3sm.c
     tif_flush.c
     tif_getimage.c
+    tif_hash_set.c
     tif_jbig.c
     tif_jpeg_12.c
     tif_jpeg.c
@@ -427,21 +423,18 @@ set(lib_srcs
     t4.h
     tif_dir.h
     tif_fax3.h
+    tif_hash_set.h
+    tif_predict.h
     tiff.h
     tiffio.h
     tiffiop.h
-    tiffvers.h
+    "${CMAKE_CURRENT_BINARY_DIR}/tiffvers.h"
-    tif_predict.h
     uvcode.h
     tiffio.hxx
     "${CMAKE_CURRENT_BINARY_DIR}/tif_config.h"
     "${CMAKE_CURRENT_BINARY_DIR}/tiffconf.h"
     )
 
-if(WIN32 AND NOT HAVE_SNPRINTF)
-  list(APPEND lib_srcs snprintf.c libport.h)
-endif()
-
 if(WIN32 AND NOT WINRT)
   list(APPEND lib_srcs tif_win32.c)
 else()

3rdparty/libtiff/README.md

@@ -0,0 +1,69 @@
+TIFF Software Distribution
+--------------------------
+This file is just a placeholder; the entire documentation is now located
+as reStructuredText in the doc directory. To view the documentation
+as HTML, visit https://libtiff.gitlab.io/libtiff/ or
+http://www.simplesystems.org/libtiff/ or within the release package
+in the doc/html-prebuilt directory. The manual pages are
+located at doc/man-prebuilt.
+
+The release package can be downloaded at
+
+http://download.osgeo.org/libtiff/
+
+If you can't hack either of these options then basically what you
+want to do is:
+
+    % ./configure
+    % make
+    % su
+    # make install
+
+More information, email contacts, and mailing list information can be 
+found online at http://www.simplesystems.org/libtiff/
+
+Source code repository
+----------------------
+
+[GitLab](https://gitlab.com/libtiff/libtiff)
+
+Bug database
+------------
+
+[GitLab issues](https://gitlab.com/libtiff/libtiff/issues)
+
+Previously, the project used
+[Bugzilla](http://bugzilla.maptools.org/buglist.cgi?product=libtiff). This
+is no longer in use, and all remaining issues have been migrated to GitLab.
+
+Use and Copyright
+-----------------
+Silicon Graphics has seen fit to allow us to give this work away.  It
+is free.  There is no support or guarantee of any sort as to its
+operations, correctness, or whatever.  If you do anything useful with
+all or parts of it you need to honor the copyright notices.   I would
+also be interested in knowing about it and, hopefully, be acknowledged.
+
+The legal way of saying that is:
+
+Copyright (c) 1988-1997 Sam Leffler
+Copyright (c) 1991-1997 Silicon Graphics, Inc.
+
+Permission to use, copy, modify, distribute, and sell this software and 
+its documentation for any purpose is hereby granted without fee, provided
+that (i) the above copyright notices and this permission notice appear in
+all copies of the software and related documentation, and (ii) the names of
+Sam Leffler and Silicon Graphics may not be used in any advertising or
+publicity relating to the software without the specific, prior written
+permission of Sam Leffler and Silicon Graphics.
+
+THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+
+IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+OF THIS SOFTWARE.

3rdparty/libtiff/RELEASE-DATE

@@ -0,0 +1 @@
+20230908

3rdparty/libtiff/libport.h

@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2009 Frank Warmerdam
- *
- * Permission to use, copy, modify, distribute, and sell this software and 
- * its documentation for any purpose is hereby granted without fee, provided
- * that (i) the above copyright notices and this permission notice appear in
- * all copies of the software and related documentation, and (ii) the names of
- * Sam Leffler and Silicon Graphics may not be used in any advertising or
- * publicity relating to the software without the specific, prior written
- * permission of Sam Leffler and Silicon Graphics.
- * 
- * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
- * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
- * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
- * 
- * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
- * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
- * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
- * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
- * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
- * OF THIS SOFTWARE.
- */
-
-#ifndef _LIBPORT_
-#define	_LIBPORT_
-
-#if defined(HAVE_CONFIG_H)
-#  include <tif_config.h>
-#endif
-
-int getopt(int argc, char * const argv[], const char *optstring);
-extern   char *optarg;
-extern   int opterr;
-extern   int optind;
-extern   int optopt;
-
-int strcasecmp(const char *s1, const char *s2);
-
-#ifndef HAVE_GETOPT
-#  define HAVE_GETOPT 1
-#endif
-
-#if !defined(HAVE_STRTOL)
-long strtol(const char *nptr, char **endptr, int base);
-#endif
-#if !defined(HAVE_STRTOLL)
-long long strtoll(const char *nptr, char **endptr, int base);
-#endif
-#if !defined(HAVE_STRTOUL)
-unsigned long strtoul(const char *nptr, char **endptr, int base);
-#endif
-#if !defined(HAVE_STRTOULL)
-unsigned long long strtoull(const char *nptr, char **endptr, int base);
-#endif
-
-#if 0
-void *
-lfind(const void *key, const void *base, size_t *nmemb, size_t size,
-      int(*compar)(const void *, const void *));
-#endif
-
-#if !defined(HAVE_SNPRINTF)
-#undef vsnprintf
-#define vsnprintf _TIFF_vsnprintf_f
-
-#undef snprintf
-#define snprintf _TIFF_snprintf_f
-int snprintf(char* str, size_t size, const char* format, ...);
-#endif
-
-#endif /* ndef _LIBPORT_ */

3rdparty/libtiff/snprintf.c

@@ -1,42 +0,0 @@
-/**
- * Workaround for lack of snprintf(3) in Visual Studio.  See
- * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010/8712996#8712996
- * It's a trivial wrapper around the builtin _vsnprintf_s and
- * _vscprintf functions.
- */
-
-#ifdef _MSC_VER
-
-#include <stdio.h>
-#include <stdarg.h>
-#include "libport.h"
-
-int _TIFF_vsnprintf_f(char* str, size_t size, const char* format, va_list ap)
-{
-  int count = -1;
-
-  if (size != 0)
-#if _MSC_VER <=	1310
-    count = _vsnprintf(str, size, format, ap);
-#else
-    count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
-#endif
-  if (count == -1)
-    count = _vscprintf(format, ap);
-
-  return count;
-}
-
-int _TIFF_snprintf_f(char* str, size_t size, const char* format, ...)
-{
-  int count;
-  va_list ap;
-
-  va_start(ap, format);
-  count = vsnprintf(str, size, format, ap);
-  va_end(ap);
-
-  return count;
-}
-
-#endif // _MSC_VER

3rdparty/libtiff/t4.h

@@ -23,26 +23,27 @@
  */
 
 #ifndef _T4_
-#define	_T4_
+#define _T4_
 /*
  * CCITT T.4 1D Huffman runlength codes and
  * related definitions.  Given the small sizes
  * of these tables it does not seem
  * worthwhile to make code & length 8 bits.
  */
-typedef struct tableentry {
+typedef struct tableentry
-    unsigned short length;  /* bit length of g3 code */
+{
-    unsigned short code;    /* g3 code */
+    unsigned short length; /* bit length of g3 code */
-    short runlen;           /* run length in bits */
+    unsigned short code;   /* g3 code */
+    short runlen;          /* run length in bits */
 } tableentry;
 
-#define EOL	0x001	/* EOL code value - 0000 0000 0000 1 */
+#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */
 
 /* status values returned instead of a run length */
-#define G3CODE_EOL	-1	/* NB: ACT_EOL - ACT_WRUNT */
+#define G3CODE_EOL -1     /* NB: ACT_EOL - ACT_WRUNT */
-#define G3CODE_INVALID	-2	/* NB: ACT_INVALID - ACT_WRUNT */
+#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */
-#define G3CODE_EOF	-3	/* end of input data */
+#define G3CODE_EOF -3     /* end of input data */
-#define G3CODE_INCOMP	-4	/* incomplete run code */
+#define G3CODE_INCOMP -4  /* incomplete run code */
 
 /*
  * Note that these tables are ordered such that the
@@ -54,237 +55,230 @@ typedef struct tableentry {
  */
 #ifdef G3CODES
 const tableentry TIFFFaxWhiteCodes[] = {
-    { 8, 0x35, 0 },	/* 0011 0101 */
+    {8, 0x35, 0},              /* 0011 0101 */
-    { 6, 0x7, 1 },	/* 0001 11 */
+    {6, 0x7, 1},               /* 0001 11 */
-    { 4, 0x7, 2 },	/* 0111 */
+    {4, 0x7, 2},               /* 0111 */
-    { 4, 0x8, 3 },	/* 1000 */
+    {4, 0x8, 3},               /* 1000 */
-    { 4, 0xB, 4 },	/* 1011 */
+    {4, 0xB, 4},               /* 1011 */
-    { 4, 0xC, 5 },	/* 1100 */
+    {4, 0xC, 5},               /* 1100 */
-    { 4, 0xE, 6 },	/* 1110 */
+    {4, 0xE, 6},               /* 1110 */
-    { 4, 0xF, 7 },	/* 1111 */
+    {4, 0xF, 7},               /* 1111 */
-    { 5, 0x13, 8 },	/* 1001 1 */
+    {5, 0x13, 8},              /* 1001 1 */
-    { 5, 0x14, 9 },	/* 1010 0 */
+    {5, 0x14, 9},              /* 1010 0 */
-    { 5, 0x7, 10 },	/* 0011 1 */
+    {5, 0x7, 10},              /* 0011 1 */
-    { 5, 0x8, 11 },	/* 0100 0 */
+    {5, 0x8, 11},              /* 0100 0 */
-    { 6, 0x8, 12 },	/* 0010 00 */
+    {6, 0x8, 12},              /* 0010 00 */
-    { 6, 0x3, 13 },	/* 0000 11 */
+    {6, 0x3, 13},              /* 0000 11 */
-    { 6, 0x34, 14 },	/* 1101 00 */
+    {6, 0x34, 14},             /* 1101 00 */
-    { 6, 0x35, 15 },	/* 1101 01 */
+    {6, 0x35, 15},             /* 1101 01 */
-    { 6, 0x2A, 16 },	/* 1010 10 */
+    {6, 0x2A, 16},             /* 1010 10 */
-    { 6, 0x2B, 17 },	/* 1010 11 */
+    {6, 0x2B, 17},             /* 1010 11 */
-    { 7, 0x27, 18 },	/* 0100 111 */
+    {7, 0x27, 18},             /* 0100 111 */
-    { 7, 0xC, 19 },	/* 0001 100 */
+    {7, 0xC, 19},              /* 0001 100 */
-    { 7, 0x8, 20 },	/* 0001 000 */
+    {7, 0x8, 20},              /* 0001 000 */
-    { 7, 0x17, 21 },	/* 0010 111 */
+    {7, 0x17, 21},             /* 0010 111 */
-    { 7, 0x3, 22 },	/* 0000 011 */
+    {7, 0x3, 22},              /* 0000 011 */
-    { 7, 0x4, 23 },	/* 0000 100 */
+    {7, 0x4, 23},              /* 0000 100 */
-    { 7, 0x28, 24 },	/* 0101 000 */
+    {7, 0x28, 24},             /* 0101 000 */
-    { 7, 0x2B, 25 },	/* 0101 011 */
+    {7, 0x2B, 25},             /* 0101 011 */
-    { 7, 0x13, 26 },	/* 0010 011 */
+    {7, 0x13, 26},             /* 0010 011 */
-    { 7, 0x24, 27 },	/* 0100 100 */
+    {7, 0x24, 27},             /* 0100 100 */
-    { 7, 0x18, 28 },	/* 0011 000 */
+    {7, 0x18, 28},             /* 0011 000 */
-    { 8, 0x2, 29 },	/* 0000 0010 */
+    {8, 0x2, 29},              /* 0000 0010 */
-    { 8, 0x3, 30 },	/* 0000 0011 */
+    {8, 0x3, 30},              /* 0000 0011 */
-    { 8, 0x1A, 31 },	/* 0001 1010 */
+    {8, 0x1A, 31},             /* 0001 1010 */
-    { 8, 0x1B, 32 },	/* 0001 1011 */
+    {8, 0x1B, 32},             /* 0001 1011 */
-    { 8, 0x12, 33 },	/* 0001 0010 */
+    {8, 0x12, 33},             /* 0001 0010 */
-    { 8, 0x13, 34 },	/* 0001 0011 */
+    {8, 0x13, 34},             /* 0001 0011 */
-    { 8, 0x14, 35 },	/* 0001 0100 */
+    {8, 0x14, 35},             /* 0001 0100 */
-    { 8, 0x15, 36 },	/* 0001 0101 */
+    {8, 0x15, 36},             /* 0001 0101 */
-    { 8, 0x16, 37 },	/* 0001 0110 */
+    {8, 0x16, 37},             /* 0001 0110 */
-    { 8, 0x17, 38 },	/* 0001 0111 */
+    {8, 0x17, 38},             /* 0001 0111 */
-    { 8, 0x28, 39 },	/* 0010 1000 */
+    {8, 0x28, 39},             /* 0010 1000 */
-    { 8, 0x29, 40 },	/* 0010 1001 */
+    {8, 0x29, 40},             /* 0010 1001 */
-    { 8, 0x2A, 41 },	/* 0010 1010 */
+    {8, 0x2A, 41},             /* 0010 1010 */
-    { 8, 0x2B, 42 },	/* 0010 1011 */
+    {8, 0x2B, 42},             /* 0010 1011 */
-    { 8, 0x2C, 43 },	/* 0010 1100 */
+    {8, 0x2C, 43},             /* 0010 1100 */
-    { 8, 0x2D, 44 },	/* 0010 1101 */
+    {8, 0x2D, 44},             /* 0010 1101 */
-    { 8, 0x4, 45 },	/* 0000 0100 */
+    {8, 0x4, 45},              /* 0000 0100 */
-    { 8, 0x5, 46 },	/* 0000 0101 */
+    {8, 0x5, 46},              /* 0000 0101 */
-    { 8, 0xA, 47 },	/* 0000 1010 */
+    {8, 0xA, 47},              /* 0000 1010 */
-    { 8, 0xB, 48 },	/* 0000 1011 */
+    {8, 0xB, 48},              /* 0000 1011 */
-    { 8, 0x52, 49 },	/* 0101 0010 */
+    {8, 0x52, 49},             /* 0101 0010 */
-    { 8, 0x53, 50 },	/* 0101 0011 */
+    {8, 0x53, 50},             /* 0101 0011 */
-    { 8, 0x54, 51 },	/* 0101 0100 */
+    {8, 0x54, 51},             /* 0101 0100 */
-    { 8, 0x55, 52 },	/* 0101 0101 */
+    {8, 0x55, 52},             /* 0101 0101 */
-    { 8, 0x24, 53 },	/* 0010 0100 */
+    {8, 0x24, 53},             /* 0010 0100 */
-    { 8, 0x25, 54 },	/* 0010 0101 */
+    {8, 0x25, 54},             /* 0010 0101 */
-    { 8, 0x58, 55 },	/* 0101 1000 */
+    {8, 0x58, 55},             /* 0101 1000 */
-    { 8, 0x59, 56 },	/* 0101 1001 */
+    {8, 0x59, 56},             /* 0101 1001 */
-    { 8, 0x5A, 57 },	/* 0101 1010 */
+    {8, 0x5A, 57},             /* 0101 1010 */
-    { 8, 0x5B, 58 },	/* 0101 1011 */
+    {8, 0x5B, 58},             /* 0101 1011 */
-    { 8, 0x4A, 59 },	/* 0100 1010 */
+    {8, 0x4A, 59},             /* 0100 1010 */
-    { 8, 0x4B, 60 },	/* 0100 1011 */
+    {8, 0x4B, 60},             /* 0100 1011 */
-    { 8, 0x32, 61 },	/* 0011 0010 */
+    {8, 0x32, 61},             /* 0011 0010 */
-    { 8, 0x33, 62 },	/* 0011 0011 */
+    {8, 0x33, 62},             /* 0011 0011 */
-    { 8, 0x34, 63 },	/* 0011 0100 */
+    {8, 0x34, 63},             /* 0011 0100 */
-    { 5, 0x1B, 64 },	/* 1101 1 */
+    {5, 0x1B, 64},             /* 1101 1 */
-    { 5, 0x12, 128 },	/* 1001 0 */
+    {5, 0x12, 128},            /* 1001 0 */
-    { 6, 0x17, 192 },	/* 0101 11 */
+    {6, 0x17, 192},            /* 0101 11 */
-    { 7, 0x37, 256 },	/* 0110 111 */
+    {7, 0x37, 256},            /* 0110 111 */
-    { 8, 0x36, 320 },	/* 0011 0110 */
+    {8, 0x36, 320},            /* 0011 0110 */
-    { 8, 0x37, 384 },	/* 0011 0111 */
+    {8, 0x37, 384},            /* 0011 0111 */
-    { 8, 0x64, 448 },	/* 0110 0100 */
+    {8, 0x64, 448},            /* 0110 0100 */
-    { 8, 0x65, 512 },	/* 0110 0101 */
+    {8, 0x65, 512},            /* 0110 0101 */
-    { 8, 0x68, 576 },	/* 0110 1000 */
+    {8, 0x68, 576},            /* 0110 1000 */
-    { 8, 0x67, 640 },	/* 0110 0111 */
+    {8, 0x67, 640},            /* 0110 0111 */
-    { 9, 0xCC, 704 },	/* 0110 0110 0 */
+    {9, 0xCC, 704},            /* 0110 0110 0 */
-    { 9, 0xCD, 768 },	/* 0110 0110 1 */
+    {9, 0xCD, 768},            /* 0110 0110 1 */
-    { 9, 0xD2, 832 },	/* 0110 1001 0 */
+    {9, 0xD2, 832},            /* 0110 1001 0 */
-    { 9, 0xD3, 896 },	/* 0110 1001 1 */
+    {9, 0xD3, 896},            /* 0110 1001 1 */
-    { 9, 0xD4, 960 },	/* 0110 1010 0 */
+    {9, 0xD4, 960},            /* 0110 1010 0 */
-    { 9, 0xD5, 1024 },	/* 0110 1010 1 */
+    {9, 0xD5, 1024},           /* 0110 1010 1 */
-    { 9, 0xD6, 1088 },	/* 0110 1011 0 */
+    {9, 0xD6, 1088},           /* 0110 1011 0 */
-    { 9, 0xD7, 1152 },	/* 0110 1011 1 */
+    {9, 0xD7, 1152},           /* 0110 1011 1 */
-    { 9, 0xD8, 1216 },	/* 0110 1100 0 */
+    {9, 0xD8, 1216},           /* 0110 1100 0 */
-    { 9, 0xD9, 1280 },	/* 0110 1100 1 */
+    {9, 0xD9, 1280},           /* 0110 1100 1 */
-    { 9, 0xDA, 1344 },	/* 0110 1101 0 */
+    {9, 0xDA, 1344},           /* 0110 1101 0 */
-    { 9, 0xDB, 1408 },	/* 0110 1101 1 */
+    {9, 0xDB, 1408},           /* 0110 1101 1 */
-    { 9, 0x98, 1472 },	/* 0100 1100 0 */
+    {9, 0x98, 1472},           /* 0100 1100 0 */
-    { 9, 0x99, 1536 },	/* 0100 1100 1 */
+    {9, 0x99, 1536},           /* 0100 1100 1 */
-    { 9, 0x9A, 1600 },	/* 0100 1101 0 */
+    {9, 0x9A, 1600},           /* 0100 1101 0 */
-    { 6, 0x18, 1664 },	/* 0110 00 */
+    {6, 0x18, 1664},           /* 0110 00 */
-    { 9, 0x9B, 1728 },	/* 0100 1101 1 */
+    {9, 0x9B, 1728},           /* 0100 1101 1 */
-    { 11, 0x8, 1792 },	/* 0000 0001 000 */
+    {11, 0x8, 1792},           /* 0000 0001 000 */
-    { 11, 0xC, 1856 },	/* 0000 0001 100 */
+    {11, 0xC, 1856},           /* 0000 0001 100 */
-    { 11, 0xD, 1920 },	/* 0000 0001 101 */
+    {11, 0xD, 1920},           /* 0000 0001 101 */
-    { 12, 0x12, 1984 },	/* 0000 0001 0010 */
+    {12, 0x12, 1984},          /* 0000 0001 0010 */
-    { 12, 0x13, 2048 },	/* 0000 0001 0011 */
+    {12, 0x13, 2048},          /* 0000 0001 0011 */
-    { 12, 0x14, 2112 },	/* 0000 0001 0100 */
+    {12, 0x14, 2112},          /* 0000 0001 0100 */
-    { 12, 0x15, 2176 },	/* 0000 0001 0101 */
+    {12, 0x15, 2176},          /* 0000 0001 0101 */
-    { 12, 0x16, 2240 },	/* 0000 0001 0110 */
+    {12, 0x16, 2240},          /* 0000 0001 0110 */
-    { 12, 0x17, 2304 },	/* 0000 0001 0111 */
+    {12, 0x17, 2304},          /* 0000 0001 0111 */
-    { 12, 0x1C, 2368 },	/* 0000 0001 1100 */
+    {12, 0x1C, 2368},          /* 0000 0001 1100 */
-    { 12, 0x1D, 2432 },	/* 0000 0001 1101 */
+    {12, 0x1D, 2432},          /* 0000 0001 1101 */
-    { 12, 0x1E, 2496 },	/* 0000 0001 1110 */
+    {12, 0x1E, 2496},          /* 0000 0001 1110 */
-    { 12, 0x1F, 2560 },	/* 0000 0001 1111 */
+    {12, 0x1F, 2560},          /* 0000 0001 1111 */
-    { 12, 0x1, G3CODE_EOL },	/* 0000 0000 0001 */
+    {12, 0x1, G3CODE_EOL},     /* 0000 0000 0001 */
-    { 9, 0x1, G3CODE_INVALID },	/* 0000 0000 1 */
+    {9, 0x1, G3CODE_INVALID},  /* 0000 0000 1 */
-    { 10, 0x1, G3CODE_INVALID },	/* 0000 0000 01 */
+    {10, 0x1, G3CODE_INVALID}, /* 0000 0000 01 */
-    { 11, 0x1, G3CODE_INVALID },	/* 0000 0000 001 */
+    {11, 0x1, G3CODE_INVALID}, /* 0000 0000 001 */
-    { 12, 0x0, G3CODE_INVALID },	/* 0000 0000 0000 */
+    {12, 0x0, G3CODE_INVALID}, /* 0000 0000 0000 */
 };
 
 const tableentry TIFFFaxBlackCodes[] = {
-    { 10, 0x37, 0 },	/* 0000 1101 11 */
+    {10, 0x37, 0},             /* 0000 1101 11 */
-    { 3, 0x2, 1 },	/* 010 */
+    {3, 0x2, 1},               /* 010 */
-    { 2, 0x3, 2 },	/* 11 */
+    {2, 0x3, 2},               /* 11 */
-    { 2, 0x2, 3 },	/* 10 */
+    {2, 0x2, 3},               /* 10 */
-    { 3, 0x3, 4 },	/* 011 */
+    {3, 0x3, 4},               /* 011 */
-    { 4, 0x3, 5 },	/* 0011 */
+    {4, 0x3, 5},               /* 0011 */
-    { 4, 0x2, 6 },	/* 0010 */
+    {4, 0x2, 6},               /* 0010 */
-    { 5, 0x3, 7 },	/* 0001 1 */
+    {5, 0x3, 7},               /* 0001 1 */
-    { 6, 0x5, 8 },	/* 0001 01 */
+    {6, 0x5, 8},               /* 0001 01 */
-    { 6, 0x4, 9 },	/* 0001 00 */
+    {6, 0x4, 9},               /* 0001 00 */
-    { 7, 0x4, 10 },	/* 0000 100 */
+    {7, 0x4, 10},              /* 0000 100 */
-    { 7, 0x5, 11 },	/* 0000 101 */
+    {7, 0x5, 11},              /* 0000 101 */
-    { 7, 0x7, 12 },	/* 0000 111 */
+    {7, 0x7, 12},              /* 0000 111 */
-    { 8, 0x4, 13 },	/* 0000 0100 */
+    {8, 0x4, 13},              /* 0000 0100 */
-    { 8, 0x7, 14 },	/* 0000 0111 */
+    {8, 0x7, 14},              /* 0000 0111 */
-    { 9, 0x18, 15 },	/* 0000 1100 0 */
+    {9, 0x18, 15},             /* 0000 1100 0 */
-    { 10, 0x17, 16 },	/* 0000 0101 11 */
+    {10, 0x17, 16},            /* 0000 0101 11 */
-    { 10, 0x18, 17 },	/* 0000 0110 00 */
+    {10, 0x18, 17},            /* 0000 0110 00 */
-    { 10, 0x8, 18 },	/* 0000 0010 00 */
+    {10, 0x8, 18},             /* 0000 0010 00 */
-    { 11, 0x67, 19 },	/* 0000 1100 111 */
+    {11, 0x67, 19},            /* 0000 1100 111 */
-    { 11, 0x68, 20 },	/* 0000 1101 000 */
+    {11, 0x68, 20},            /* 0000 1101 000 */
-    { 11, 0x6C, 21 },	/* 0000 1101 100 */
+    {11, 0x6C, 21},            /* 0000 1101 100 */
-    { 11, 0x37, 22 },	/* 0000 0110 111 */
+    {11, 0x37, 22},            /* 0000 0110 111 */
-    { 11, 0x28, 23 },	/* 0000 0101 000 */
+    {11, 0x28, 23},            /* 0000 0101 000 */
-    { 11, 0x17, 24 },	/* 0000 0010 111 */
+    {11, 0x17, 24},            /* 0000 0010 111 */
-    { 11, 0x18, 25 },	/* 0000 0011 000 */
+    {11, 0x18, 25},            /* 0000 0011 000 */
-    { 12, 0xCA, 26 },	/* 0000 1100 1010 */
+    {12, 0xCA, 26},            /* 0000 1100 1010 */
-    { 12, 0xCB, 27 },	/* 0000 1100 1011 */
+    {12, 0xCB, 27},            /* 0000 1100 1011 */
-    { 12, 0xCC, 28 },	/* 0000 1100 1100 */
+    {12, 0xCC, 28},            /* 0000 1100 1100 */
-    { 12, 0xCD, 29 },	/* 0000 1100 1101 */
+    {12, 0xCD, 29},            /* 0000 1100 1101 */
-    { 12, 0x68, 30 },	/* 0000 0110 1000 */
+    {12, 0x68, 30},            /* 0000 0110 1000 */
-    { 12, 0x69, 31 },	/* 0000 0110 1001 */
+    {12, 0x69, 31},            /* 0000 0110 1001 */
-    { 12, 0x6A, 32 },	/* 0000 0110 1010 */
+    {12, 0x6A, 32},            /* 0000 0110 1010 */
-    { 12, 0x6B, 33 },	/* 0000 0110 1011 */
+    {12, 0x6B, 33},            /* 0000 0110 1011 */
-    { 12, 0xD2, 34 },	/* 0000 1101 0010 */
+    {12, 0xD2, 34},            /* 0000 1101 0010 */
-    { 12, 0xD3, 35 },	/* 0000 1101 0011 */
+    {12, 0xD3, 35},            /* 0000 1101 0011 */
-    { 12, 0xD4, 36 },	/* 0000 1101 0100 */
+    {12, 0xD4, 36},            /* 0000 1101 0100 */
-    { 12, 0xD5, 37 },	/* 0000 1101 0101 */
+    {12, 0xD5, 37},            /* 0000 1101 0101 */
-    { 12, 0xD6, 38 },	/* 0000 1101 0110 */
+    {12, 0xD6, 38},            /* 0000 1101 0110 */
-    { 12, 0xD7, 39 },	/* 0000 1101 0111 */
+    {12, 0xD7, 39},            /* 0000 1101 0111 */
-    { 12, 0x6C, 40 },	/* 0000 0110 1100 */
+    {12, 0x6C, 40},            /* 0000 0110 1100 */
-    { 12, 0x6D, 41 },	/* 0000 0110 1101 */
+    {12, 0x6D, 41},            /* 0000 0110 1101 */
-    { 12, 0xDA, 42 },	/* 0000 1101 1010 */
+    {12, 0xDA, 42},            /* 0000 1101 1010 */
-    { 12, 0xDB, 43 },	/* 0000 1101 1011 */
+    {12, 0xDB, 43},            /* 0000 1101 1011 */
-    { 12, 0x54, 44 },	/* 0000 0101 0100 */
+    {12, 0x54, 44},            /* 0000 0101 0100 */
-    { 12, 0x55, 45 },	/* 0000 0101 0101 */
+    {12, 0x55, 45},            /* 0000 0101 0101 */
-    { 12, 0x56, 46 },	/* 0000 0101 0110 */
+    {12, 0x56, 46},            /* 0000 0101 0110 */
-    { 12, 0x57, 47 },	/* 0000 0101 0111 */
+    {12, 0x57, 47},            /* 0000 0101 0111 */
-    { 12, 0x64, 48 },	/* 0000 0110 0100 */
+    {12, 0x64, 48},            /* 0000 0110 0100 */
-    { 12, 0x65, 49 },	/* 0000 0110 0101 */
+    {12, 0x65, 49},            /* 0000 0110 0101 */
-    { 12, 0x52, 50 },	/* 0000 0101 0010 */
+    {12, 0x52, 50},            /* 0000 0101 0010 */
-    { 12, 0x53, 51 },	/* 0000 0101 0011 */
+    {12, 0x53, 51},            /* 0000 0101 0011 */
-    { 12, 0x24, 52 },	/* 0000 0010 0100 */
+    {12, 0x24, 52},            /* 0000 0010 0100 */
-    { 12, 0x37, 53 },	/* 0000 0011 0111 */
+    {12, 0x37, 53},            /* 0000 0011 0111 */
-    { 12, 0x38, 54 },	/* 0000 0011 1000 */
+    {12, 0x38, 54},            /* 0000 0011 1000 */
-    { 12, 0x27, 55 },	/* 0000 0010 0111 */
+    {12, 0x27, 55},            /* 0000 0010 0111 */
-    { 12, 0x28, 56 },	/* 0000 0010 1000 */
+    {12, 0x28, 56},            /* 0000 0010 1000 */
-    { 12, 0x58, 57 },	/* 0000 0101 1000 */
+    {12, 0x58, 57},            /* 0000 0101 1000 */
-    { 12, 0x59, 58 },	/* 0000 0101 1001 */
+    {12, 0x59, 58},            /* 0000 0101 1001 */
-    { 12, 0x2B, 59 },	/* 0000 0010 1011 */
+    {12, 0x2B, 59},            /* 0000 0010 1011 */
-    { 12, 0x2C, 60 },	/* 0000 0010 1100 */
+    {12, 0x2C, 60},            /* 0000 0010 1100 */
-    { 12, 0x5A, 61 },	/* 0000 0101 1010 */
+    {12, 0x5A, 61},            /* 0000 0101 1010 */
-    { 12, 0x66, 62 },	/* 0000 0110 0110 */
+    {12, 0x66, 62},            /* 0000 0110 0110 */
-    { 12, 0x67, 63 },	/* 0000 0110 0111 */
+    {12, 0x67, 63},            /* 0000 0110 0111 */
-    { 10, 0xF, 64 },	/* 0000 0011 11 */
+    {10, 0xF, 64},             /* 0000 0011 11 */
-    { 12, 0xC8, 128 },	/* 0000 1100 1000 */
+    {12, 0xC8, 128},           /* 0000 1100 1000 */
-    { 12, 0xC9, 192 },	/* 0000 1100 1001 */
+    {12, 0xC9, 192},           /* 0000 1100 1001 */
-    { 12, 0x5B, 256 },	/* 0000 0101 1011 */
+    {12, 0x5B, 256},           /* 0000 0101 1011 */
-    { 12, 0x33, 320 },	/* 0000 0011 0011 */
+    {12, 0x33, 320},           /* 0000 0011 0011 */
-    { 12, 0x34, 384 },	/* 0000 0011 0100 */
+    {12, 0x34, 384},           /* 0000 0011 0100 */
-    { 12, 0x35, 448 },	/* 0000 0011 0101 */
+    {12, 0x35, 448},           /* 0000 0011 0101 */
-    { 13, 0x6C, 512 },	/* 0000 0011 0110 0 */
+    {13, 0x6C, 512},           /* 0000 0011 0110 0 */
-    { 13, 0x6D, 576 },	/* 0000 0011 0110 1 */
+    {13, 0x6D, 576},           /* 0000 0011 0110 1 */
-    { 13, 0x4A, 640 },	/* 0000 0010 0101 0 */
+    {13, 0x4A, 640},           /* 0000 0010 0101 0 */
-    { 13, 0x4B, 704 },	/* 0000 0010 0101 1 */
+    {13, 0x4B, 704},           /* 0000 0010 0101 1 */
-    { 13, 0x4C, 768 },	/* 0000 0010 0110 0 */
+    {13, 0x4C, 768},           /* 0000 0010 0110 0 */
-    { 13, 0x4D, 832 },	/* 0000 0010 0110 1 */
+    {13, 0x4D, 832},           /* 0000 0010 0110 1 */
-    { 13, 0x72, 896 },	/* 0000 0011 1001 0 */
+    {13, 0x72, 896},           /* 0000 0011 1001 0 */
-    { 13, 0x73, 960 },	/* 0000 0011 1001 1 */
+    {13, 0x73, 960},           /* 0000 0011 1001 1 */
-    { 13, 0x74, 1024 },	/* 0000 0011 1010 0 */
+    {13, 0x74, 1024},          /* 0000 0011 1010 0 */
-    { 13, 0x75, 1088 },	/* 0000 0011 1010 1 */
+    {13, 0x75, 1088},          /* 0000 0011 1010 1 */
-    { 13, 0x76, 1152 },	/* 0000 0011 1011 0 */
+    {13, 0x76, 1152},          /* 0000 0011 1011 0 */
-    { 13, 0x77, 1216 },	/* 0000 0011 1011 1 */
+    {13, 0x77, 1216},          /* 0000 0011 1011 1 */
-    { 13, 0x52, 1280 },	/* 0000 0010 1001 0 */
+    {13, 0x52, 1280},          /* 0000 0010 1001 0 */
-    { 13, 0x53, 1344 },	/* 0000 0010 1001 1 */
+    {13, 0x53, 1344},          /* 0000 0010 1001 1 */
-    { 13, 0x54, 1408 },	/* 0000 0010 1010 0 */
+    {13, 0x54, 1408},          /* 0000 0010 1010 0 */
-    { 13, 0x55, 1472 },	/* 0000 0010 1010 1 */
+    {13, 0x55, 1472},          /* 0000 0010 1010 1 */
-    { 13, 0x5A, 1536 },	/* 0000 0010 1101 0 */
+    {13, 0x5A, 1536},          /* 0000 0010 1101 0 */
-    { 13, 0x5B, 1600 },	/* 0000 0010 1101 1 */
+    {13, 0x5B, 1600},          /* 0000 0010 1101 1 */
-    { 13, 0x64, 1664 },	/* 0000 0011 0010 0 */
+    {13, 0x64, 1664},          /* 0000 0011 0010 0 */
-    { 13, 0x65, 1728 },	/* 0000 0011 0010 1 */
+    {13, 0x65, 1728},          /* 0000 0011 0010 1 */
-    { 11, 0x8, 1792 },	/* 0000 0001 000 */
+    {11, 0x8, 1792},           /* 0000 0001 000 */
-    { 11, 0xC, 1856 },	/* 0000 0001 100 */
+    {11, 0xC, 1856},           /* 0000 0001 100 */
-    { 11, 0xD, 1920 },	/* 0000 0001 101 */
+    {11, 0xD, 1920},           /* 0000 0001 101 */
-    { 12, 0x12, 1984 },	/* 0000 0001 0010 */
+    {12, 0x12, 1984},          /* 0000 0001 0010 */
-    { 12, 0x13, 2048 },	/* 0000 0001 0011 */
+    {12, 0x13, 2048},          /* 0000 0001 0011 */
-    { 12, 0x14, 2112 },	/* 0000 0001 0100 */
+    {12, 0x14, 2112},          /* 0000 0001 0100 */
-    { 12, 0x15, 2176 },	/* 0000 0001 0101 */
+    {12, 0x15, 2176},          /* 0000 0001 0101 */
-    { 12, 0x16, 2240 },	/* 0000 0001 0110 */
+    {12, 0x16, 2240},          /* 0000 0001 0110 */
-    { 12, 0x17, 2304 },	/* 0000 0001 0111 */
+    {12, 0x17, 2304},          /* 0000 0001 0111 */
-    { 12, 0x1C, 2368 },	/* 0000 0001 1100 */
+    {12, 0x1C, 2368},          /* 0000 0001 1100 */
-    { 12, 0x1D, 2432 },	/* 0000 0001 1101 */
+    {12, 0x1D, 2432},          /* 0000 0001 1101 */
-    { 12, 0x1E, 2496 },	/* 0000 0001 1110 */
+    {12, 0x1E, 2496},          /* 0000 0001 1110 */
-    { 12, 0x1F, 2560 },	/* 0000 0001 1111 */
+    {12, 0x1F, 2560},          /* 0000 0001 1111 */
-    { 12, 0x1, G3CODE_EOL },	/* 0000 0000 0001 */
+    {12, 0x1, G3CODE_EOL},     /* 0000 0000 0001 */
-    { 9, 0x1, G3CODE_INVALID },	/* 0000 0000 1 */
+    {9, 0x1, G3CODE_INVALID},  /* 0000 0000 1 */
-    { 10, 0x1, G3CODE_INVALID },	/* 0000 0000 01 */
+    {10, 0x1, G3CODE_INVALID}, /* 0000 0000 01 */
-    { 11, 0x1, G3CODE_INVALID },	/* 0000 0000 001 */
+    {11, 0x1, G3CODE_INVALID}, /* 0000 0000 001 */
-    { 12, 0x0, G3CODE_INVALID },	/* 0000 0000 0000 */
+    {12, 0x0, G3CODE_INVALID}, /* 0000 0000 0000 */
 };
 #else
 extern const tableentry TIFFFaxWhiteCodes[];
 extern const tableentry TIFFFaxBlackCodes[];
 #endif
 #endif /* _T4_ */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_aux.c

@@ -27,173 +27,180 @@
  *
  * Auxiliary Support Routines.
  */
-#include "tiffiop.h"
 #include "tif_predict.h"
-#include <math.h>
+#include "tiffiop.h"
 #include <float.h>
+#include <math.h>
 
-uint32
+uint32_t _TIFFMultiply32(TIFF *tif, uint32_t first, uint32_t second,
-_TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where)
+                         const char *where)
 {
-	if (second && first > TIFF_UINT32_MAX / second) {
+    if (second && first > UINT32_MAX / second)
-		TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
-		return 0;
-	}
-
-	return first * second;
-}
-
-uint64
-_TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where)
-{
-	if (second && first > TIFF_UINT64_MAX / second) {
-		TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
-		return 0;
-	}
-
-	return first * second;
-}
-
-tmsize_t
-_TIFFMultiplySSize(TIFF* tif, tmsize_t first, tmsize_t second, const char* where)
-{
-    if( first <= 0 || second <= 0 )
     {
-        if( tif != NULL && where != NULL )
+        TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
+        return 0;
+    }
+
+    return first * second;
+}
+
+uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second,
+                         const char *where)
+{
+    if (second && first > UINT64_MAX / second)
+    {
+        TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
+        return 0;
+    }
+
+    return first * second;
+}
+
+tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,
+                            const char *where)
+{
+    if (first <= 0 || second <= 0)
+    {
+        if (tif != NULL && where != NULL)
         {
-            TIFFErrorExt(tif->tif_clientdata, where,
+            TIFFErrorExtR(tif, where,
-                        "Invalid argument to _TIFFMultiplySSize() in %s", where);
+                          "Invalid argument to _TIFFMultiplySSize() in %s",
+                          where);
         }
         return 0;
     }
 
-    if( first > TIFF_TMSIZE_T_MAX / second )
+    if (first > TIFF_TMSIZE_T_MAX / second)
     {
-        if( tif != NULL && where != NULL )
+        if (tif != NULL && where != NULL)
         {
-            TIFFErrorExt(tif->tif_clientdata, where,
+            TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
-                        "Integer overflow in %s", where);
         }
         return 0;
     }
     return first * second;
 }
 
-tmsize_t _TIFFCastUInt64ToSSize(TIFF* tif, uint64 val, const char* module)
+tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
 {
-    if( val > (uint64)TIFF_TMSIZE_T_MAX )
+    if (val > (uint64_t)TIFF_TMSIZE_T_MAX)
     {
-        if( tif != NULL && module != NULL )
+        if (tif != NULL && module != NULL)
         {
-            TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
+            TIFFErrorExtR(tif, module, "Integer overflow");
         }
         return 0;
     }
     return (tmsize_t)val;
 }
 
-void*
+void *_TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb,
-_TIFFCheckRealloc(TIFF* tif, void* buffer,
+                        tmsize_t elem_size, const char *what)
-		  tmsize_t nmemb, tmsize_t elem_size, const char* what)
 {
-	void* cp = NULL;
+    void *cp = NULL;
-        tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
+    tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
-	/*
+    /*
-	 * Check for integer overflow.
+     * Check for integer overflow.
-	 */
+     */
-	if (count != 0)
+    if (count != 0)
-	{
+    {
-		cp = _TIFFrealloc(buffer, count);
+        cp = _TIFFreallocExt(tif, buffer, count);
-	}
+    }
 
-	if (cp == NULL) {
+    if (cp == NULL)
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+    {
-			     "Failed to allocate memory for %s "
+        TIFFErrorExtR(tif, tif->tif_name,
-			     "(%ld elements of %ld bytes each)",
+                      "Failed to allocate memory for %s "
-			     what,(long) nmemb, (long) elem_size);
+                      "(%" TIFF_SSIZE_FORMAT " elements of %" TIFF_SSIZE_FORMAT
-	}
+                      " bytes each)",
+                      what, nmemb, elem_size);
+    }
 
-	return cp;
+    return cp;
 }
 
-void*
+void *_TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size,
-_TIFFCheckMalloc(TIFF* tif, tmsize_t nmemb, tmsize_t elem_size, const char* what)
+                       const char *what)
 {
-	return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);  
+    return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
 }
 
-static int
+static int TIFFDefaultTransferFunction(TIFF *tif, TIFFDirectory *td)
-TIFFDefaultTransferFunction(TIFFDirectory* td)
 {
-	uint16 **tf = td->td_transferfunction;
+    uint16_t **tf = td->td_transferfunction;
-	tmsize_t i, n, nbytes;
+    tmsize_t i, n, nbytes;
 
-	tf[0] = tf[1] = tf[2] = 0;
+    tf[0] = tf[1] = tf[2] = 0;
-	if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2)
+    if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2)
-		return 0;
+        return 0;
 
-	n = ((tmsize_t)1)<<td->td_bitspersample;
+    n = ((tmsize_t)1) << td->td_bitspersample;
-	nbytes = n * sizeof (uint16);
+    nbytes = n * sizeof(uint16_t);
-        tf[0] = (uint16 *)_TIFFmalloc(nbytes);
+    tf[0] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
-	if (tf[0] == NULL)
+    if (tf[0] == NULL)
-		return 0;
+        return 0;
-	tf[0][0] = 0;
+    tf[0][0] = 0;
-	for (i = 1; i < n; i++) {
+    for (i = 1; i < n; i++)
-		double t = (double)i/((double) n-1.);
+    {
-		tf[0][i] = (uint16)floor(65535.*pow(t, 2.2) + .5);
+        double t = (double)i / ((double)n - 1.);
-	}
+        tf[0][i] = (uint16_t)floor(65535. * pow(t, 2.2) + .5);
+    }
 
-	if (td->td_samplesperpixel - td->td_extrasamples > 1) {
+    if (td->td_samplesperpixel - td->td_extrasamples > 1)
-                tf[1] = (uint16 *)_TIFFmalloc(nbytes);
+    {
-		if(tf[1] == NULL)
+        tf[1] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
-			goto bad;
+        if (tf[1] == NULL)
-		_TIFFmemcpy(tf[1], tf[0], nbytes);
+            goto bad;
-                tf[2] = (uint16 *)_TIFFmalloc(nbytes);
+        _TIFFmemcpy(tf[1], tf[0], nbytes);
-		if (tf[2] == NULL)
+        tf[2] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
-			goto bad;
+        if (tf[2] == NULL)
-		_TIFFmemcpy(tf[2], tf[0], nbytes);
+            goto bad;
-	}
+        _TIFFmemcpy(tf[2], tf[0], nbytes);
-	return 1;
+    }
+    return 1;
 
 bad:
-	if (tf[0])
+    if (tf[0])
-		_TIFFfree(tf[0]);
+        _TIFFfreeExt(tif, tf[0]);
-	if (tf[1])
+    if (tf[1])
-		_TIFFfree(tf[1]);
+        _TIFFfreeExt(tif, tf[1]);
-	if (tf[2])
+    if (tf[2])
-		_TIFFfree(tf[2]);
+        _TIFFfreeExt(tif, tf[2]);
-	tf[0] = tf[1] = tf[2] = 0;
+    tf[0] = tf[1] = tf[2] = 0;
-	return 0;
+    return 0;
 }
 
-static int
+static int TIFFDefaultRefBlackWhite(TIFF *tif, TIFFDirectory *td)
-TIFFDefaultRefBlackWhite(TIFFDirectory* td)
 {
-	int i;
+    int i;
 
-        td->td_refblackwhite = (float *)_TIFFmalloc(6*sizeof (float));
+    td->td_refblackwhite = (float *)_TIFFmallocExt(tif, 6 * sizeof(float));
-	if (td->td_refblackwhite == NULL)
+    if (td->td_refblackwhite == NULL)
-		return 0;
+        return 0;
-        if (td->td_photometric == PHOTOMETRIC_YCBCR) {
+    if (td->td_photometric == PHOTOMETRIC_YCBCR)
-		/*
+    {
-		 * YCbCr (Class Y) images must have the ReferenceBlackWhite
+        /*
-		 * tag set. Fix the broken images, which lacks that tag.
+         * YCbCr (Class Y) images must have the ReferenceBlackWhite
-		 */
+         * tag set. Fix the broken images, which lacks that tag.
-		td->td_refblackwhite[0] = 0.0F;
+         */
-		td->td_refblackwhite[1] = td->td_refblackwhite[3] =
+        td->td_refblackwhite[0] = 0.0F;
-			td->td_refblackwhite[5] = 255.0F;
+        td->td_refblackwhite[1] = td->td_refblackwhite[3] =
-		td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
+            td->td_refblackwhite[5] = 255.0F;
-	} else {
+        td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
-		/*
+    }
-		 * Assume RGB (Class R)
+    else
-		 */
+    {
-		for (i = 0; i < 3; i++) {
+        /*
-		    td->td_refblackwhite[2*i+0] = 0;
+         * Assume RGB (Class R)
-		    td->td_refblackwhite[2*i+1] =
+         */
-			    (float)((1L<<td->td_bitspersample)-1L);
+        for (i = 0; i < 3; i++)
-		}
+        {
-	}
+            td->td_refblackwhite[2 * i + 0] = 0;
-	return 1;
+            td->td_refblackwhite[2 * i + 1] =
+                (float)((1L << td->td_bitspersample) - 1L);
+        }
+    }
+    return 1;
 }
 
 /*
@@ -204,216 +211,248 @@ TIFFDefaultRefBlackWhite(TIFFDirectory* td)
  *	explicit values so that defaults exist only one
  *	place in the library -- in TIFFDefaultDirectory.
  */
-int
+int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
-TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap)
 {
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
 
-	if (TIFFVGetField(tif, tag, ap))
+    if (TIFFVGetField(tif, tag, ap))
-		return (1);
+        return (1);
-	switch (tag) {
+    switch (tag)
-	case TIFFTAG_SUBFILETYPE:
-		*va_arg(ap, uint32 *) = td->td_subfiletype;
-		return (1);
-	case TIFFTAG_BITSPERSAMPLE:
-		*va_arg(ap, uint16 *) = td->td_bitspersample;
-		return (1);
-	case TIFFTAG_THRESHHOLDING:
-		*va_arg(ap, uint16 *) = td->td_threshholding;
-		return (1);
-	case TIFFTAG_FILLORDER:
-		*va_arg(ap, uint16 *) = td->td_fillorder;
-		return (1);
-	case TIFFTAG_ORIENTATION:
-		*va_arg(ap, uint16 *) = td->td_orientation;
-		return (1);
-	case TIFFTAG_SAMPLESPERPIXEL:
-		*va_arg(ap, uint16 *) = td->td_samplesperpixel;
-		return (1);
-	case TIFFTAG_ROWSPERSTRIP:
-		*va_arg(ap, uint32 *) = td->td_rowsperstrip;
-		return (1);
-	case TIFFTAG_MINSAMPLEVALUE:
-		*va_arg(ap, uint16 *) = td->td_minsamplevalue;
-		return (1);
-	case TIFFTAG_MAXSAMPLEVALUE:
-		*va_arg(ap, uint16 *) = td->td_maxsamplevalue;
-		return (1);
-	case TIFFTAG_PLANARCONFIG:
-		*va_arg(ap, uint16 *) = td->td_planarconfig;
-		return (1);
-	case TIFFTAG_RESOLUTIONUNIT:
-		*va_arg(ap, uint16 *) = td->td_resolutionunit;
-		return (1);
-	case TIFFTAG_PREDICTOR:
     {
-        TIFFPredictorState* sp = (TIFFPredictorState*) tif->tif_data;
+        case TIFFTAG_SUBFILETYPE:
-        if( sp == NULL )
+            *va_arg(ap, uint32_t *) = td->td_subfiletype;
+            return (1);
+        case TIFFTAG_BITSPERSAMPLE:
+            *va_arg(ap, uint16_t *) = td->td_bitspersample;
+            return (1);
+        case TIFFTAG_THRESHHOLDING:
+            *va_arg(ap, uint16_t *) = td->td_threshholding;
+            return (1);
+        case TIFFTAG_FILLORDER:
+            *va_arg(ap, uint16_t *) = td->td_fillorder;
+            return (1);
+        case TIFFTAG_ORIENTATION:
+            *va_arg(ap, uint16_t *) = td->td_orientation;
+            return (1);
+        case TIFFTAG_SAMPLESPERPIXEL:
+            *va_arg(ap, uint16_t *) = td->td_samplesperpixel;
+            return (1);
+        case TIFFTAG_ROWSPERSTRIP:
+            *va_arg(ap, uint32_t *) = td->td_rowsperstrip;
+            return (1);
+        case TIFFTAG_MINSAMPLEVALUE:
+            *va_arg(ap, uint16_t *) = td->td_minsamplevalue;
+            return (1);
+        case TIFFTAG_MAXSAMPLEVALUE:
         {
-            TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+            uint16_t maxsamplevalue;
-                         "Cannot get \"Predictor\" tag as plugin is not configured");
+            /* td_bitspersample=1 is always set in TIFFDefaultDirectory().
-            *va_arg(ap, uint16*) = 0;
+             * Therefore, td_maxsamplevalue has to be re-calculated in
-            return 0;
+             * TIFFGetFieldDefaulted(). */
+            if (td->td_bitspersample > 0)
+            {
+                /* This shift operation into a uint16_t limits the value to
+                 * 65535 even if td_bitspersamle is > 16 */
+                if (td->td_bitspersample <= 16)
+                {
+                    maxsamplevalue = (1 << td->td_bitspersample) -
+                                     1; /* 2**(BitsPerSample) - 1 */
+                }
+                else
+                {
+                    maxsamplevalue = 65535;
+                }
+            }
+            else
+            {
+                maxsamplevalue = 0;
+            }
+            *va_arg(ap, uint16_t *) = maxsamplevalue;
+            return (1);
         }
-        *va_arg(ap, uint16*) = (uint16) sp->predictor;
+        case TIFFTAG_PLANARCONFIG:
-        return 1;
+            *va_arg(ap, uint16_t *) = td->td_planarconfig;
+            return (1);
+        case TIFFTAG_RESOLUTIONUNIT:
+            *va_arg(ap, uint16_t *) = td->td_resolutionunit;
+            return (1);
+        case TIFFTAG_PREDICTOR:
+        {
+            TIFFPredictorState *sp = (TIFFPredictorState *)tif->tif_data;
+            if (sp == NULL)
+            {
+                TIFFErrorExtR(
+                    tif, tif->tif_name,
+                    "Cannot get \"Predictor\" tag as plugin is not configured");
+                *va_arg(ap, uint16_t *) = 0;
+                return 0;
+            }
+            *va_arg(ap, uint16_t *) = (uint16_t)sp->predictor;
+            return 1;
+        }
+        case TIFFTAG_DOTRANGE:
+            *va_arg(ap, uint16_t *) = 0;
+            *va_arg(ap, uint16_t *) = (1 << td->td_bitspersample) - 1;
+            return (1);
+        case TIFFTAG_INKSET:
+            *va_arg(ap, uint16_t *) = INKSET_CMYK;
+            return 1;
+        case TIFFTAG_NUMBEROFINKS:
+            *va_arg(ap, uint16_t *) = 4;
+            return (1);
+        case TIFFTAG_EXTRASAMPLES:
+            *va_arg(ap, uint16_t *) = td->td_extrasamples;
+            *va_arg(ap, const uint16_t **) = td->td_sampleinfo;
+            return (1);
+        case TIFFTAG_MATTEING:
+            *va_arg(ap, uint16_t *) =
+                (td->td_extrasamples == 1 &&
+                 td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
+            return (1);
+        case TIFFTAG_TILEDEPTH:
+            *va_arg(ap, uint32_t *) = td->td_tiledepth;
+            return (1);
+        case TIFFTAG_DATATYPE:
+            *va_arg(ap, uint16_t *) = td->td_sampleformat - 1;
+            return (1);
+        case TIFFTAG_SAMPLEFORMAT:
+            *va_arg(ap, uint16_t *) = td->td_sampleformat;
+            return (1);
+        case TIFFTAG_IMAGEDEPTH:
+            *va_arg(ap, uint32_t *) = td->td_imagedepth;
+            return (1);
+        case TIFFTAG_YCBCRCOEFFICIENTS:
+        {
+            /* defaults are from CCIR Recommendation 601-1 */
+            static const float ycbcrcoeffs[] = {0.299f, 0.587f, 0.114f};
+            *va_arg(ap, const float **) = ycbcrcoeffs;
+            return 1;
+        }
+        case TIFFTAG_YCBCRSUBSAMPLING:
+            *va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[0];
+            *va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[1];
+            return (1);
+        case TIFFTAG_YCBCRPOSITIONING:
+            *va_arg(ap, uint16_t *) = td->td_ycbcrpositioning;
+            return (1);
+        case TIFFTAG_WHITEPOINT:
+        {
+            /* TIFF 6.0 specification tells that it is no default
+               value for the WhitePoint, but AdobePhotoshop TIFF
+               Technical Note tells that it should be CIE D50. */
+            static const float whitepoint[] = {
+                D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
+                D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)};
+            *va_arg(ap, const float **) = whitepoint;
+            return 1;
+        }
+        case TIFFTAG_TRANSFERFUNCTION:
+            if (!td->td_transferfunction[0] &&
+                !TIFFDefaultTransferFunction(tif, td))
+            {
+                TIFFErrorExtR(tif, tif->tif_name,
+                              "No space for \"TransferFunction\" tag");
+                return (0);
+            }
+            *va_arg(ap, const uint16_t **) = td->td_transferfunction[0];
+            if (td->td_samplesperpixel - td->td_extrasamples > 1)
+            {
+                *va_arg(ap, const uint16_t **) = td->td_transferfunction[1];
+                *va_arg(ap, const uint16_t **) = td->td_transferfunction[2];
+            }
+            return (1);
+        case TIFFTAG_REFERENCEBLACKWHITE:
+            if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(tif, td))
+                return (0);
+            *va_arg(ap, const float **) = td->td_refblackwhite;
+            return (1);
     }
-	case TIFFTAG_DOTRANGE:
+    return 0;
-		*va_arg(ap, uint16 *) = 0;
-		*va_arg(ap, uint16 *) = (1<<td->td_bitspersample)-1;
-		return (1);
-	case TIFFTAG_INKSET:
-		*va_arg(ap, uint16 *) = INKSET_CMYK;
-		return 1;
-	case TIFFTAG_NUMBEROFINKS:
-		*va_arg(ap, uint16 *) = 4;
-		return (1);
-	case TIFFTAG_EXTRASAMPLES:
-		*va_arg(ap, uint16 *) = td->td_extrasamples;
-		*va_arg(ap, const uint16 **) = td->td_sampleinfo;
-		return (1);
-	case TIFFTAG_MATTEING:
-		*va_arg(ap, uint16 *) =
-		    (td->td_extrasamples == 1 &&
-		     td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
-		return (1);
-	case TIFFTAG_TILEDEPTH:
-		*va_arg(ap, uint32 *) = td->td_tiledepth;
-		return (1);
-	case TIFFTAG_DATATYPE:
-		*va_arg(ap, uint16 *) = td->td_sampleformat-1;
-		return (1);
-	case TIFFTAG_SAMPLEFORMAT:
-		*va_arg(ap, uint16 *) = td->td_sampleformat;
-                return(1);
-	case TIFFTAG_IMAGEDEPTH:
-		*va_arg(ap, uint32 *) = td->td_imagedepth;
-		return (1);
-	case TIFFTAG_YCBCRCOEFFICIENTS:
-		{
-			/* defaults are from CCIR Recommendation 601-1 */
-			static const float ycbcrcoeffs[] = { 0.299f, 0.587f, 0.114f };
-			*va_arg(ap, const float **) = ycbcrcoeffs;
-			return 1;
-		}
-	case TIFFTAG_YCBCRSUBSAMPLING:
-		*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[0];
-		*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1];
-		return (1);
-	case TIFFTAG_YCBCRPOSITIONING:
-		*va_arg(ap, uint16 *) = td->td_ycbcrpositioning;
-		return (1);
-	case TIFFTAG_WHITEPOINT:
-		{
-			/* TIFF 6.0 specification tells that it is no default
-			   value for the WhitePoint, but AdobePhotoshop TIFF
-			   Technical Note tells that it should be CIE D50. */
-			static const float whitepoint[] = {
-						D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
-						D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)
-			};
-			*va_arg(ap, const float **) = whitepoint;
-			return 1;
-		}
-	case TIFFTAG_TRANSFERFUNCTION:
-		if (!td->td_transferfunction[0] &&
-		    !TIFFDefaultTransferFunction(td)) {
-			TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space for \"TransferFunction\" tag");
-			return (0);
-		}
-		*va_arg(ap, const uint16 **) = td->td_transferfunction[0];
-		if (td->td_samplesperpixel - td->td_extrasamples > 1) {
-			*va_arg(ap, const uint16 **) = td->td_transferfunction[1];
-			*va_arg(ap, const uint16 **) = td->td_transferfunction[2];
-		}
-		return (1);
-	case TIFFTAG_REFERENCEBLACKWHITE:
-		if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(td))
-			return (0);
-		*va_arg(ap, const float **) = td->td_refblackwhite;
-		return (1);
-	}
-	return 0;
 }
 
 /*
  * Like TIFFGetField, but return any default
  * value if the tag is not present in the directory.
  */
-int
+int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...)
-TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...)
 {
-	int ok;
+    int ok;
-	va_list ap;
+    va_list ap;
 
-	va_start(ap, tag);
+    va_start(ap, tag);
-	ok =  TIFFVGetFieldDefaulted(tif, tag, ap);
+    ok = TIFFVGetFieldDefaulted(tif, tag, ap);
-	va_end(ap);
+    va_end(ap);
-	return (ok);
+    return (ok);
 }
 
-struct _Int64Parts {
+struct _Int64Parts
-	int32 low, high;
+{
+    int32_t low, high;
 };
 
-typedef union {
+typedef union
-	struct _Int64Parts part;
+{
-	int64 value;
+    struct _Int64Parts part;
+    int64_t value;
 } _Int64;
 
-float
+float _TIFFUInt64ToFloat(uint64_t ui64)
-_TIFFUInt64ToFloat(uint64 ui64)
 {
-	_Int64 i;
+    _Int64 i;
 
-	i.value = ui64;
+    i.value = ui64;
-	if (i.part.high >= 0) {
+    if (i.part.high >= 0)
-		return (float)i.value;
+    {
-	} else {
+        return (float)i.value;
-		long double df;
+    }
-		df = (long double)i.value;
+    else
-		df += 18446744073709551616.0; /* adding 2**64 */
+    {
-		return (float)df;
+        long double df;
-	}
+        df = (long double)i.value;
+        df += 18446744073709551616.0; /* adding 2**64 */
+        return (float)df;
+    }
 }
 
-double
+double _TIFFUInt64ToDouble(uint64_t ui64)
-_TIFFUInt64ToDouble(uint64 ui64)
 {
-	_Int64 i;
+    _Int64 i;
 
-	i.value = ui64;
+    i.value = ui64;
-	if (i.part.high >= 0) {
+    if (i.part.high >= 0)
-		return (double)i.value;
+    {
-	} else {
+        return (double)i.value;
-		long double df;
+    }
-		df = (long double)i.value;
+    else
-		df += 18446744073709551616.0; /* adding 2**64 */
+    {
-		return (double)df;
+        long double df;
-	}
+        df = (long double)i.value;
+        df += 18446744073709551616.0; /* adding 2**64 */
+        return (double)df;
+    }
 }
 
-float _TIFFClampDoubleToFloat( double val )
+float _TIFFClampDoubleToFloat(double val)
 {
-    if( val > FLT_MAX )
+    if (val > FLT_MAX)
         return FLT_MAX;
-    if( val < -FLT_MAX )
+    if (val < -FLT_MAX)
         return -FLT_MAX;
     return (float)val;
 }
 
-int _TIFFSeekOK(TIFF* tif, toff_t off)
+uint32_t _TIFFClampDoubleToUInt32(double val)
+{
+    if (val < 0)
+        return 0;
+    if (val > 0xFFFFFFFFU || val != val)
+        return 0xFFFFFFFFU;
+    return (uint32_t)val;
+}
+
+int _TIFFSeekOK(TIFF *tif, toff_t off)
 {
     /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
     /* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
-    return off <= (~(uint64)0)/2 && TIFFSeekFile(tif,off,SEEK_SET)==off;
+    return off <= (~(uint64_t)0) / 2 && TIFFSeekFile(tif, off, SEEK_SET) == off;
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_close.c

@@ -41,66 +41,94 @@
  * @param tif A TIFF pointer.
  */
 
-void
+void TIFFCleanup(TIFF *tif)
-TIFFCleanup(TIFF* tif)
 {
-	/*
+    /*
-         * Flush buffered data and directory (if dirty).
+     * Flush buffered data and directory (if dirty).
-         */
+     */
-	if (tif->tif_mode != O_RDONLY)
+    if (tif->tif_mode != O_RDONLY)
-		TIFFFlush(tif);
+        TIFFFlush(tif);
-	(*tif->tif_cleanup)(tif);
+    (*tif->tif_cleanup)(tif);
-	TIFFFreeDirectory(tif);
+    TIFFFreeDirectory(tif);
 
-	if (tif->tif_dirlist)
+    _TIFFCleanupIFDOffsetAndNumberMaps(tif);
-		_TIFFfree(tif->tif_dirlist);
 
-	/*
+    /*
-         * Clean up client info links.
+     * Clean up client info links.
-         */
+     */
-	while( tif->tif_clientinfo )
+    while (tif->tif_clientinfo)
-	{
+    {
-		TIFFClientInfoLink *psLink = tif->tif_clientinfo;
+        TIFFClientInfoLink *psLink = tif->tif_clientinfo;
 
-		tif->tif_clientinfo = psLink->next;
+        tif->tif_clientinfo = psLink->next;
-		_TIFFfree( psLink->name );
+        _TIFFfreeExt(tif, psLink->name);
-		_TIFFfree( psLink );
+        _TIFFfreeExt(tif, psLink);
-	}
+    }
 
-	if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER))
+    if (tif->tif_rawdata && (tif->tif_flags & TIFF_MYBUFFER))
-		_TIFFfree(tif->tif_rawdata);
+        _TIFFfreeExt(tif, tif->tif_rawdata);
-	if (isMapped(tif))
+    if (isMapped(tif))
-		TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size);
+        TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size);
 
-	/*
+    /*
-         * Clean up custom fields.
+     * Clean up custom fields.
-         */
+     */
-	if (tif->tif_fields && tif->tif_nfields > 0) {
+    if (tif->tif_fields && tif->tif_nfields > 0)
-		uint32 i;
+    {
+        uint32_t i;
 
-		for (i = 0; i < tif->tif_nfields; i++) {
+        for (i = 0; i < tif->tif_nfields; i++)
-			TIFFField *fld = tif->tif_fields[i];
+        {
-			if (fld->field_bit == FIELD_CUSTOM &&
+            TIFFField *fld = tif->tif_fields[i];
-			    strncmp("Tag ", fld->field_name, 4) == 0) {
+            if (fld->field_name != NULL)
-				_TIFFfree(fld->field_name);
+            {
-				_TIFFfree(fld);
+                if (fld->field_bit == FIELD_CUSTOM &&
-			}
+                    /* caution: tif_fields[i] must not be the beginning of a
-		}
+                     * fields-array. Otherwise the following tags are also freed
-
+                     * with the first free().
-		_TIFFfree(tif->tif_fields);
+                     */
-	}
+                    TIFFFieldIsAnonymous(fld))
-
+                {
-        if (tif->tif_nfieldscompat > 0) {
+                    _TIFFfreeExt(tif, fld->field_name);
-                uint32 i;
+                    _TIFFfreeExt(tif, fld);
-
-                for (i = 0; i < tif->tif_nfieldscompat; i++) {
-                        if (tif->tif_fieldscompat[i].allocated_size)
-                                _TIFFfree(tif->tif_fieldscompat[i].fields);
                 }
-                _TIFFfree(tif->tif_fieldscompat);
+            }
         }
 
-	_TIFFfree(tif);
+        _TIFFfreeExt(tif, tif->tif_fields);
+    }
+
+    if (tif->tif_nfieldscompat > 0)
+    {
+        uint32_t i;
+
+        for (i = 0; i < tif->tif_nfieldscompat; i++)
+        {
+            if (tif->tif_fieldscompat[i].allocated_size)
+                _TIFFfreeExt(tif, tif->tif_fieldscompat[i].fields);
+        }
+        _TIFFfreeExt(tif, tif->tif_fieldscompat);
+    }
+
+    _TIFFfreeExt(NULL, tif);
+}
+
+/************************************************************************/
+/*                    _TIFFCleanupIFDOffsetAndNumberMaps()              */
+/************************************************************************/
+
+void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif)
+{
+    if (tif->tif_map_dir_offset_to_number)
+    {
+        TIFFHashSetDestroy(tif->tif_map_dir_offset_to_number);
+        tif->tif_map_dir_offset_to_number = NULL;
+    }
+    if (tif->tif_map_dir_number_to_offset)
+    {
+        TIFFHashSetDestroy(tif->tif_map_dir_number_to_offset);
+        tif->tif_map_dir_number_to_offset = NULL;
+    }
 }
 
 /************************************************************************/
@@ -117,22 +145,14 @@ TIFFCleanup(TIFF* tif)
  * @param tif A TIFF pointer.
  */
 
-void
+void TIFFClose(TIFF *tif)
-TIFFClose(TIFF* tif)
 {
-	TIFFCloseProc closeproc = tif->tif_closeproc;
+    if (tif != NULL)
-	thandle_t fd = tif->tif_clientdata;
+    {
+        TIFFCloseProc closeproc = tif->tif_closeproc;
+        thandle_t fd = tif->tif_clientdata;
 
-	TIFFCleanup(tif);
+        TIFFCleanup(tif);
-	(void) (*closeproc)(fd);
+        (void)(*closeproc)(fd);
+    }
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_codec.c

@@ -29,7 +29,7 @@
  */
 #include "tiffiop.h"
 
-static int NotConfigured(TIFF*, int);
+static int NotConfigured(TIFF *, int);
 
 #ifndef LZW_SUPPORT
 #define TIFFInitLZW NotConfigured
@@ -67,6 +67,9 @@ static int NotConfigured(TIFF*, int);
 #ifndef LOGLUV_SUPPORT
 #define TIFFInitSGILog NotConfigured
 #endif
+#ifndef LERC_SUPPORT
+#define TIFFInitLERC NotConfigured
+#endif
 #ifndef LZMA_SUPPORT
 #define TIFFInitLZMA NotConfigured
 #endif
@@ -80,58 +83,53 @@ static int NotConfigured(TIFF*, int);
 /*
  * Compression schemes statically built into the library.
  */
-#ifdef VMS
 const TIFFCodec _TIFFBuiltinCODECS[] = {
-#else
+    {"None", COMPRESSION_NONE, TIFFInitDumpMode},
-TIFFCodec _TIFFBuiltinCODECS[] = {
+    {"LZW", COMPRESSION_LZW, TIFFInitLZW},
-#endif
+    {"PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits},
-    { "None",		COMPRESSION_NONE,	TIFFInitDumpMode },
+    {"ThunderScan", COMPRESSION_THUNDERSCAN, TIFFInitThunderScan},
-    { "LZW",		COMPRESSION_LZW,	TIFFInitLZW },
+    {"NeXT", COMPRESSION_NEXT, TIFFInitNeXT},
-    { "PackBits",	COMPRESSION_PACKBITS,	TIFFInitPackBits },
+    {"JPEG", COMPRESSION_JPEG, TIFFInitJPEG},
-    { "ThunderScan",	COMPRESSION_THUNDERSCAN,TIFFInitThunderScan },
+    {"Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG},
-    { "NeXT",		COMPRESSION_NEXT,	TIFFInitNeXT },
+    {"CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE},
-    { "JPEG",		COMPRESSION_JPEG,	TIFFInitJPEG },
+    {"CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW},
-    { "Old-style JPEG",	COMPRESSION_OJPEG,	TIFFInitOJPEG },
+    {"CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3},
-    { "CCITT RLE",	COMPRESSION_CCITTRLE,	TIFFInitCCITTRLE },
+    {"CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4},
-    { "CCITT RLE/W",	COMPRESSION_CCITTRLEW,	TIFFInitCCITTRLEW },
+    {"ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG},
-    { "CCITT Group 3",	COMPRESSION_CCITTFAX3,	TIFFInitCCITTFax3 },
+    {"Deflate", COMPRESSION_DEFLATE, TIFFInitZIP},
-    { "CCITT Group 4",	COMPRESSION_CCITTFAX4,	TIFFInitCCITTFax4 },
+    {"AdobeDeflate", COMPRESSION_ADOBE_DEFLATE, TIFFInitZIP},
-    { "ISO JBIG",	COMPRESSION_JBIG,	TIFFInitJBIG },
+    {"PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog},
-    { "Deflate",	COMPRESSION_DEFLATE,	TIFFInitZIP },
+    {"SGILog", COMPRESSION_SGILOG, TIFFInitSGILog},
-    { "AdobeDeflate",   COMPRESSION_ADOBE_DEFLATE , TIFFInitZIP }, 
+    {"SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog},
-    { "PixarLog",	COMPRESSION_PIXARLOG,	TIFFInitPixarLog },
+    {"LZMA", COMPRESSION_LZMA, TIFFInitLZMA},
-    { "SGILog",		COMPRESSION_SGILOG,	TIFFInitSGILog },
+    {"ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD},
-    { "SGILog24",	COMPRESSION_SGILOG24,	TIFFInitSGILog },
+    {"WEBP", COMPRESSION_WEBP, TIFFInitWebP},
-    { "LZMA",		COMPRESSION_LZMA,	TIFFInitLZMA },
+    {"LERC", COMPRESSION_LERC, TIFFInitLERC},
-    { "ZSTD",		COMPRESSION_ZSTD,	TIFFInitZSTD },
+    {NULL, 0, NULL}};
-    { "WEBP",		COMPRESSION_WEBP,	TIFFInitWebP },
-    { NULL,             0,                      NULL }
-};
 
-static int
+static int _notConfigured(TIFF *tif)
-_notConfigured(TIFF* tif)
 {
-	const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
+    const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
-        char compression_code[20];
+    char compression_code[20];
 
-        sprintf(compression_code, "%d",tif->tif_dir.td_compression );
+    snprintf(compression_code, sizeof(compression_code), "%" PRIu16,
-	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+             tif->tif_dir.td_compression);
-                     "%s compression support is not configured", 
+    TIFFErrorExtR(tif, tif->tif_name,
-                     c ? c->name : compression_code );
+                  "%s compression support is not configured",
-	return (0);
+                  c ? c->name : compression_code);
+    return (0);
 }
 
-static int
+static int NotConfigured(TIFF *tif, int scheme)
-NotConfigured(TIFF* tif, int scheme)
 {
-	(void) scheme;
+    (void)scheme;
 
-	tif->tif_fixuptags = _notConfigured;
+    tif->tif_fixuptags = _notConfigured;
-	tif->tif_decodestatus = FALSE;
+    tif->tif_decodestatus = FALSE;
-	tif->tif_setupdecode = _notConfigured;
+    tif->tif_setupdecode = _notConfigured;
-	tif->tif_encodestatus = FALSE;
+    tif->tif_encodestatus = FALSE;
-	tif->tif_setupencode = _notConfigured;
+    tif->tif_setupencode = _notConfigured;
-	return (1);
+    return (1);
 }
 
 /************************************************************************/
@@ -145,27 +143,21 @@ NotConfigured(TIFF* tif, int scheme)
  * 0 will be returned.
  */
 
-int
+int TIFFIsCODECConfigured(uint16_t scheme)
-TIFFIsCODECConfigured(uint16 scheme)
 {
-	const TIFFCodec* codec = TIFFFindCODEC(scheme);
+    const TIFFCodec *codec = TIFFFindCODEC(scheme);
 
-	if(codec == NULL) {
+    if (codec == NULL)
-		return 0;
+    {
-	}
+        return 0;
-	if(codec->init == NULL) {
+    }
-		return 0;
+    if (codec->init == NULL)
-	}
+    {
-	if(codec->init != NotConfigured){
+        return 0;
-		return 1;
+    }
-	}
+    if (codec->init != NotConfigured)
-	return 0;
+    {
+        return 1;
+    }
+    return 0;
 }
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_color.c

@@ -40,78 +40,91 @@
 /*
  * Convert color value from the CIE L*a*b* 1976 space to CIE XYZ.
  */
-void
+void TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b,
-TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32 l, int32 a, int32 b,
+                     float *X, float *Y, float *Z)
-		float *X, float *Y, float *Z)
 {
-	float L = (float)l * 100.0F / 255.0F;
+    TIFFCIELab16ToXYZ(cielab, l * 257, a * 256, b * 256, X, Y, Z);
-	float cby, tmp;
-
-	if( L < 8.856F ) {
-		*Y = (L * cielab->Y0) / 903.292F;
-		cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
-	} else {
-		cby = (L + 16.0F) / 116.0F;
-		*Y = cielab->Y0 * cby * cby * cby;
-	}
-
-	tmp = (float)a / 500.0F + cby;
-	if( tmp < 0.2069F )
-		*X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
-	else    
-		*X = cielab->X0 * tmp * tmp * tmp;
-
-	tmp = cby - (float)b / 200.0F;
-	if( tmp < 0.2069F )
-		*Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
-	else    
-		*Z = cielab->Z0 * tmp * tmp * tmp;
 }
 
-#define RINT(R) ((uint32)((R)>0?((R)+0.5):((R)-0.5)))
+/*
+ * For CIELab encoded in 16 bits, L is an unsigned integer range [0,65535].
+ * The a* and b* components are signed integers range [-32768,32767]. The 16
+ * bit chrominance values are encoded as 256 times the 1976 CIE a* and b*
+ * values
+ */
+void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a,
+                       int32_t b, float *X, float *Y, float *Z)
+{
+    float L = (float)l * 100.0F / 65535.0F;
+    float cby, tmp;
+
+    if (L < 8.856F)
+    {
+        *Y = (L * cielab->Y0) / 903.292F;
+        cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
+    }
+    else
+    {
+        cby = (L + 16.0F) / 116.0F;
+        *Y = cielab->Y0 * cby * cby * cby;
+    }
+
+    tmp = (float)a / 256.0F / 500.0F + cby;
+    if (tmp < 0.2069F)
+        *X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
+    else
+        *X = cielab->X0 * tmp * tmp * tmp;
+
+    tmp = cby - (float)b / 256.0F / 200.0F;
+    if (tmp < 0.2069F)
+        *Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
+    else
+        *Z = cielab->Z0 * tmp * tmp * tmp;
+}
+
+#define RINT(R) ((uint32_t)((R) > 0 ? ((R) + 0.5) : ((R)-0.5)))
 /*
  * Convert color value from the XYZ space to RGB.
  */
-void
+void TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
-TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
+                  uint32_t *r, uint32_t *g, uint32_t *b)
-	     uint32 *r, uint32 *g, uint32 *b)
 {
-	int i;
+    int i;
-	float Yr, Yg, Yb;
+    float Yr, Yg, Yb;
-	float *matrix = &cielab->display.d_mat[0][0];
+    float *matrix = &cielab->display.d_mat[0][0];
 
-	/* Multiply through the matrix to get luminosity values. */
+    /* Multiply through the matrix to get luminosity values. */
-	Yr =  matrix[0] * X + matrix[1] * Y + matrix[2] * Z;
+    Yr = matrix[0] * X + matrix[1] * Y + matrix[2] * Z;
-	Yg =  matrix[3] * X + matrix[4] * Y + matrix[5] * Z;
+    Yg = matrix[3] * X + matrix[4] * Y + matrix[5] * Z;
-	Yb =  matrix[6] * X + matrix[7] * Y + matrix[8] * Z;
+    Yb = matrix[6] * X + matrix[7] * Y + matrix[8] * Z;
 
-	/* Clip input */
+    /* Clip input */
-	Yr = TIFFmax(Yr, cielab->display.d_Y0R);
+    Yr = TIFFmax(Yr, cielab->display.d_Y0R);
-	Yg = TIFFmax(Yg, cielab->display.d_Y0G);
+    Yg = TIFFmax(Yg, cielab->display.d_Y0G);
-	Yb = TIFFmax(Yb, cielab->display.d_Y0B);
+    Yb = TIFFmax(Yb, cielab->display.d_Y0B);
 
-	/* Avoid overflow in case of wrong input values */
+    /* Avoid overflow in case of wrong input values */
-	Yr = TIFFmin(Yr, cielab->display.d_YCR);
+    Yr = TIFFmin(Yr, cielab->display.d_YCR);
-	Yg = TIFFmin(Yg, cielab->display.d_YCG);
+    Yg = TIFFmin(Yg, cielab->display.d_YCG);
-	Yb = TIFFmin(Yb, cielab->display.d_YCB);
+    Yb = TIFFmin(Yb, cielab->display.d_YCB);
 
-	/* Turn luminosity to colour value. */
+    /* Turn luminosity to colour value. */
-	i = (int)((Yr - cielab->display.d_Y0R) / cielab->rstep);
+    i = (int)((Yr - cielab->display.d_Y0R) / cielab->rstep);
-	i = TIFFmin(cielab->range, i);
+    i = TIFFmin(cielab->range, i);
-	*r = RINT(cielab->Yr2r[i]);
+    *r = RINT(cielab->Yr2r[i]);
 
-	i = (int)((Yg - cielab->display.d_Y0G) / cielab->gstep);
+    i = (int)((Yg - cielab->display.d_Y0G) / cielab->gstep);
-	i = TIFFmin(cielab->range, i);
+    i = TIFFmin(cielab->range, i);
-	*g = RINT(cielab->Yg2g[i]);
+    *g = RINT(cielab->Yg2g[i]);
 
-	i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep);
+    i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep);
-	i = TIFFmin(cielab->range, i);
+    i = TIFFmin(cielab->range, i);
-	*b = RINT(cielab->Yb2b[i]);
+    *b = RINT(cielab->Yb2b[i]);
 
-	/* Clip output. */
+    /* Clip output. */
-	*r = TIFFmin(*r, cielab->display.d_Vrwr);
+    *r = TIFFmin(*r, cielab->display.d_Vrwr);
-	*g = TIFFmin(*g, cielab->display.d_Vrwg);
+    *g = TIFFmin(*g, cielab->display.d_Vrwg);
-	*b = TIFFmin(*b, cielab->display.d_Vrwb);
+    *b = TIFFmin(*b, cielab->display.d_Vrwb);
 }
 #undef RINT
 
@@ -119,50 +132,52 @@ TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
  * Allocate conversion state structures and make look_up tables for
  * the Yr,Yb,Yg <=> r,g,b conversions.
  */
-int
+int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, const TIFFDisplay *display,
-TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
+                        float *refWhite)
-		    const TIFFDisplay *display, float *refWhite)
 {
-	int i;
+    int i;
-	double dfGamma;
+    double dfGamma;
 
-	cielab->range = CIELABTORGB_TABLE_RANGE;
+    cielab->range = CIELABTORGB_TABLE_RANGE;
 
-	_TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));
+    _TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));
 
-	/* Red */
+    /* Red */
-	dfGamma = 1.0 / cielab->display.d_gammaR ;
+    dfGamma = 1.0 / cielab->display.d_gammaR;
-	cielab->rstep =
+    cielab->rstep =
-		(cielab->display.d_YCR - cielab->display.d_Y0R)	/ cielab->range;
+        (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
-	for(i = 0; i <= cielab->range; i++) {
+    for (i = 0; i <= cielab->range; i++)
-		cielab->Yr2r[i] = cielab->display.d_Vrwr
+    {
-		    * ((float)pow((double)i / cielab->range, dfGamma));
+        cielab->Yr2r[i] = cielab->display.d_Vrwr *
-	}
+                          ((float)pow((double)i / cielab->range, dfGamma));
+    }
 
-	/* Green */
+    /* Green */
-	dfGamma = 1.0 / cielab->display.d_gammaG ;
+    dfGamma = 1.0 / cielab->display.d_gammaG;
-	cielab->gstep =
+    cielab->gstep =
-	    (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
+        (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
-	for(i = 0; i <= cielab->range; i++) {
+    for (i = 0; i <= cielab->range; i++)
-		cielab->Yg2g[i] = cielab->display.d_Vrwg
+    {
-		    * ((float)pow((double)i / cielab->range, dfGamma));
+        cielab->Yg2g[i] = cielab->display.d_Vrwg *
-	}
+                          ((float)pow((double)i / cielab->range, dfGamma));
+    }
 
-	/* Blue */
+    /* Blue */
-	dfGamma = 1.0 / cielab->display.d_gammaB ;
+    dfGamma = 1.0 / cielab->display.d_gammaB;
-	cielab->bstep =
+    cielab->bstep =
-	    (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
+        (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
-	for(i = 0; i <= cielab->range; i++) {
+    for (i = 0; i <= cielab->range; i++)
-		cielab->Yb2b[i] = cielab->display.d_Vrwb
+    {
-		    * ((float)pow((double)i / cielab->range, dfGamma));
+        cielab->Yb2b[i] = cielab->display.d_Vrwb *
-	}
+                          ((float)pow((double)i / cielab->range, dfGamma));
+    }
 
-	/* Init reference white point */
+    /* Init reference white point */
-	cielab->X0 = refWhite[0];
+    cielab->X0 = refWhite[0];
-	cielab->Y0 = refWhite[1];
+    cielab->Y0 = refWhite[1];
-	cielab->Z0 = refWhite[2];
+    cielab->Z0 = refWhite[2];
 
-	return 0;
+    return 0;
 }
 
 /*
@@ -170,43 +185,46 @@ TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
  * The colorspace conversion algorithm comes from the IJG v5a code;
  * see below for more information on how it works.
  */
-#define	SHIFT			16
+#define SHIFT 16
-#define	FIX(x)			((int32)((x) * (1L<<SHIFT) + 0.5))
+#define FIX(x) ((int32_t)((x) * (1L << SHIFT) + 0.5))
-#define	ONE_HALF		((int32)(1<<(SHIFT-1)))
+#define ONE_HALF ((int32_t)(1 << (SHIFT - 1)))
-#define	Code2V(c, RB, RW, CR)	((((c)-(int32)(RB))*(float)(CR))/(float)(((RW)-(RB)!=0) ? ((RW)-(RB)) : 1))
+#define Code2V(c, RB, RW, CR)                                                  \
-#define	CLAMP(f,min,max)	((f)<(min)?(min):(f)>(max)?(max):(f))
+    ((((c) - (int32_t)(RB)) * (float)(CR)) /                                   \
-#define HICLAMP(f,max)		((f)>(max)?(max):(f))
+     (float)(((RW) - (RB) != 0) ? ((RW) - (RB)) : 1))
+/* !((f)>=(min)) written that way to deal with NaN */
+#define CLAMP(f, min, max)                                                     \
+    ((!((f) >= (min))) ? (min) : (f) > (max) ? (max) : (f))
+#define HICLAMP(f, max) ((f) > (max) ? (max) : (f))
 
-void
+void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32_t Y, int32_t Cb, int32_t Cr,
-TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr,
+                    uint32_t *r, uint32_t *g, uint32_t *b)
-	       uint32 *r, uint32 *g, uint32 *b)
 {
-	int32 i;
+    int32_t i;
 
-	/* XXX: Only 8-bit YCbCr input supported for now */
+    /* XXX: Only 8-bit YCbCr input supported for now */
-	Y = HICLAMP(Y, 255);
+    Y = HICLAMP(Y, 255);
-	Cb = CLAMP(Cb, 0, 255);
+    Cb = CLAMP(Cb, 0, 255);
-	Cr = CLAMP(Cr, 0, 255);
+    Cr = CLAMP(Cr, 0, 255);
 
-	i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr];
+    i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr];
-	*r = CLAMP(i, 0, 255);
+    *r = CLAMP(i, 0, 255);
-	i = ycbcr->Y_tab[Y]
+    i = ycbcr->Y_tab[Y] +
-	    + (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT);
+        (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT);
-	*g = CLAMP(i, 0, 255);
+    *g = CLAMP(i, 0, 255);
-	i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb];
+    i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb];
-	*b = CLAMP(i, 0, 255);
+    *b = CLAMP(i, 0, 255);
 }
 
 /* Clamp function for sanitization purposes. Normally clamping should not */
 /* occur for well behaved chroma and refBlackWhite coefficients */
 static float CLAMPw(float v, float vmin, float vmax)
 {
-    if( v < vmin )
+    if (v < vmin)
     {
         /* printf("%f clamped to %f\n", v, vmin); */
         return vmin;
     }
-    if( v > vmax )
+    if (v > vmax)
     {
         /* printf("%f clamped to %f\n", v, vmax); */
         return vmax;
@@ -230,78 +248,75 @@ static float CLAMPw(float v, float vmin, float vmax)
  * pre-calculating possible values indexed by Cb and Cr (this code
  * assumes conversion is being done for 8-bit samples).
  */
-int
+int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
-TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
 {
-    TIFFRGBValue* clamptab;
+    TIFFRGBValue *clamptab;
     int i;
 
-#define LumaRed	    luma[0]
+#define LumaRed luma[0]
-#define LumaGreen   luma[1]
+#define LumaGreen luma[1]
-#define LumaBlue    luma[2]
+#define LumaBlue luma[2]
 
-    clamptab = (TIFFRGBValue*)(
+    clamptab =
-	(uint8*) ycbcr+TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long)));  
+        (TIFFRGBValue *)((uint8_t *)ycbcr +
-    _TIFFmemset(clamptab, 0, 256);		/* v < 0 => 0 */
+                         TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long)));
+    _TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */
     ycbcr->clamptab = (clamptab += 256);
     for (i = 0; i < 256; i++)
-	clamptab[i] = (TIFFRGBValue) i;
+        clamptab[i] = (TIFFRGBValue)i;
-    _TIFFmemset(clamptab+256, 255, 2*256);	/* v > 255 => 255 */
+    _TIFFmemset(clamptab + 256, 255, 2 * 256); /* v > 255 => 255 */
-    ycbcr->Cr_r_tab = (int*) (clamptab + 3*256);
+    ycbcr->Cr_r_tab = (int *)(clamptab + 3 * 256);
     ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256;
-    ycbcr->Cr_g_tab = (int32*) (ycbcr->Cb_b_tab + 256);
+    ycbcr->Cr_g_tab = (int32_t *)(ycbcr->Cb_b_tab + 256);
     ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256;
     ycbcr->Y_tab = ycbcr->Cb_g_tab + 256;
 
-    { float f1 = 2-2*LumaRed;		int32 D1 = FIX(CLAMP(f1,0.0F,2.0F));
+    {
-      float f2 = LumaRed*f1/LumaGreen;	int32 D2 = -FIX(CLAMP(f2,0.0F,2.0F));
+        float f1 = 2 - 2 * LumaRed;
-      float f3 = 2-2*LumaBlue;		int32 D3 = FIX(CLAMP(f3,0.0F,2.0F));
+        int32_t D1 = FIX(CLAMP(f1, 0.0F, 2.0F));
-      float f4 = LumaBlue*f3/LumaGreen;	int32 D4 = -FIX(CLAMP(f4,0.0F,2.0F));
+        float f2 = LumaRed * f1 / LumaGreen;
-      int x;
+        int32_t D2 = -FIX(CLAMP(f2, 0.0F, 2.0F));
+        float f3 = 2 - 2 * LumaBlue;
+        int32_t D3 = FIX(CLAMP(f3, 0.0F, 2.0F));
+        float f4 = LumaBlue * f3 / LumaGreen;
+        int32_t D4 = -FIX(CLAMP(f4, 0.0F, 2.0F));
+        int x;
 
 #undef LumaBlue
 #undef LumaGreen
 #undef LumaRed
 
-      /*
+        /*
-       * i is the actual input pixel value in the range 0..255
+         * i is the actual input pixel value in the range 0..255
-       * Cb and Cr values are in the range -128..127 (actually
+         * Cb and Cr values are in the range -128..127 (actually
-       * they are in a range defined by the ReferenceBlackWhite
+         * they are in a range defined by the ReferenceBlackWhite
-       * tag) so there is some range shifting to do here when
+         * tag) so there is some range shifting to do here when
-       * constructing tables indexed by the raw pixel data.
+         * constructing tables indexed by the raw pixel data.
-       */
+         */
-      for (i = 0, x = -128; i < 256; i++, x++) {
+        for (i = 0, x = -128; i < 256; i++, x++)
-	    int32 Cr = (int32)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
+        {
-			    refBlackWhite[5] - 128.0F, 127),
+            int32_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
-                            -128.0F * 32, 128.0F * 32);
+                                                refBlackWhite[5] - 128.0F, 127),
-	    int32 Cb = (int32)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
+                                         -128.0F * 32, 128.0F * 32);
-			    refBlackWhite[3] - 128.0F, 127),
+            int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
-                            -128.0F * 32, 128.0F * 32);
+                                                refBlackWhite[3] - 128.0F, 127),
+                                         -128.0F * 32, 128.0F * 32);
 
-	    ycbcr->Cr_r_tab[i] = (int32)((D1*Cr + ONE_HALF)>>SHIFT);
+            ycbcr->Cr_r_tab[i] = (int32_t)((D1 * Cr + ONE_HALF) >> SHIFT);
-	    ycbcr->Cb_b_tab[i] = (int32)((D3*Cb + ONE_HALF)>>SHIFT);
+            ycbcr->Cb_b_tab[i] = (int32_t)((D3 * Cb + ONE_HALF) >> SHIFT);
-	    ycbcr->Cr_g_tab[i] = D2*Cr;
+            ycbcr->Cr_g_tab[i] = D2 * Cr;
-	    ycbcr->Cb_g_tab[i] = D4*Cb + ONE_HALF;
+            ycbcr->Cb_g_tab[i] = D4 * Cb + ONE_HALF;
-	    ycbcr->Y_tab[i] =
+            ycbcr->Y_tab[i] = (int32_t)CLAMPw(
-		    (int32)CLAMPw(Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
+                Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
-                                  -128.0F * 32, 128.0F * 32);
+                -128.0F * 32, 128.0F * 32);
-      }
+        }
     }
 
     return 0;
 }
-#undef	HICLAMP
+#undef HICLAMP
-#undef	CLAMP
+#undef CLAMP
-#undef	Code2V
+#undef Code2V
-#undef	SHIFT
+#undef SHIFT
-#undef	ONE_HALF
+#undef ONE_HALF
-#undef	FIX
+#undef FIX
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_compress.c

@@ -29,145 +29,152 @@
  */
 #include "tiffiop.h"
 
-static int
+static int TIFFNoEncode(TIFF *tif, const char *method)
-TIFFNoEncode(TIFF* tif, const char* method)
 {
-	const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
+    const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
 
-	if (c) {
+    if (c)
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+    {
-			     "%s %s encoding is not implemented",
+        TIFFErrorExtR(tif, tif->tif_name, "%s %s encoding is not implemented",
-			     c->name, method);
+                      c->name, method);
-	} else {
+    }
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+    else
-			"Compression scheme %u %s encoding is not implemented",
+    {
-			     tif->tif_dir.td_compression, method);
+        TIFFErrorExtR(tif, tif->tif_name,
-	}
+                      "Compression scheme %" PRIu16
-	return (-1);
+                      " %s encoding is not implemented",
+                      tif->tif_dir.td_compression, method);
+    }
+    return (-1);
 }
 
-int
+int _TIFFNoRowEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-_TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) pp; (void) cc; (void) s;
+    (void)pp;
-	return (TIFFNoEncode(tif, "scanline"));
+    (void)cc;
+    (void)s;
+    return (TIFFNoEncode(tif, "scanline"));
 }
 
-int
+int _TIFFNoStripEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-_TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) pp; (void) cc; (void) s;
+    (void)pp;
-	return (TIFFNoEncode(tif, "strip"));
+    (void)cc;
+    (void)s;
+    return (TIFFNoEncode(tif, "strip"));
 }
 
-int
+int _TIFFNoTileEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-_TIFFNoTileEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) pp; (void) cc; (void) s;
+    (void)pp;
-	return (TIFFNoEncode(tif, "tile"));
+    (void)cc;
+    (void)s;
+    return (TIFFNoEncode(tif, "tile"));
 }
 
-static int
+static int TIFFNoDecode(TIFF *tif, const char *method)
-TIFFNoDecode(TIFF* tif, const char* method)
 {
-	const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
+    const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
 
-	if (c)
+    if (c)
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+        TIFFErrorExtR(tif, tif->tif_name, "%s %s decoding is not implemented",
-			     "%s %s decoding is not implemented",
+                      c->name, method);
-			     c->name, method);
+    else
-	else
+        TIFFErrorExtR(tif, tif->tif_name,
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+                      "Compression scheme %" PRIu16
-			     "Compression scheme %u %s decoding is not implemented",
+                      " %s decoding is not implemented",
-			     tif->tif_dir.td_compression, method);
+                      tif->tif_dir.td_compression, method);
-	return (0);
+    return (0);
 }
 
-static int
+static int _TIFFNoFixupTags(TIFF *tif)
-_TIFFNoFixupTags(TIFF* tif)
 {
-	(void) tif;
+    (void)tif;
-	return (1);
+    return (1);
 }
 
-int
+int _TIFFNoRowDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-_TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) pp; (void) cc; (void) s;
+    (void)pp;
-	return (TIFFNoDecode(tif, "scanline"));
+    (void)cc;
+    (void)s;
+    return (TIFFNoDecode(tif, "scanline"));
 }
 
-int
+int _TIFFNoStripDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-_TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) pp; (void) cc; (void) s;
+    (void)pp;
-	return (TIFFNoDecode(tif, "strip"));
+    (void)cc;
+    (void)s;
+    return (TIFFNoDecode(tif, "strip"));
 }
 
-int
+int _TIFFNoTileDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-_TIFFNoTileDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) pp; (void) cc; (void) s;
+    (void)pp;
-	return (TIFFNoDecode(tif, "tile"));
+    (void)cc;
+    (void)s;
+    return (TIFFNoDecode(tif, "tile"));
 }
 
-int
+int _TIFFNoSeek(TIFF *tif, uint32_t off)
-_TIFFNoSeek(TIFF* tif, uint32 off)
 {
-	(void) off;
+    (void)off;
-	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+    TIFFErrorExtR(tif, tif->tif_name,
-		     "Compression algorithm does not support random access");
+                  "Compression algorithm does not support random access");
-	return (0);
+    return (0);
 }
 
-int
+int _TIFFNoPreCode(TIFF *tif, uint16_t s)
-_TIFFNoPreCode(TIFF* tif, uint16 s)
 {
-	(void) tif; (void) s;
+    (void)tif;
-	return (1);
+    (void)s;
+    return (1);
 }
 
-static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); }
+static int _TIFFtrue(TIFF *tif)
-static void _TIFFvoid(TIFF* tif) { (void) tif; }
-
-void
-_TIFFSetDefaultCompressionState(TIFF* tif)
 {
-	tif->tif_fixuptags = _TIFFNoFixupTags; 
+    (void)tif;
-	tif->tif_decodestatus = TRUE;
+    return (1);
-	tif->tif_setupdecode = _TIFFtrue;
+}
-	tif->tif_predecode = _TIFFNoPreCode;
+static void _TIFFvoid(TIFF *tif) { (void)tif; }
-	tif->tif_decoderow = _TIFFNoRowDecode;  
+
-	tif->tif_decodestrip = _TIFFNoStripDecode;
+void _TIFFSetDefaultCompressionState(TIFF *tif)
-	tif->tif_decodetile = _TIFFNoTileDecode;  
+{
-	tif->tif_encodestatus = TRUE;
+    tif->tif_fixuptags = _TIFFNoFixupTags;
-	tif->tif_setupencode = _TIFFtrue;
+    tif->tif_decodestatus = TRUE;
-	tif->tif_preencode = _TIFFNoPreCode;
+    tif->tif_setupdecode = _TIFFtrue;
-	tif->tif_postencode = _TIFFtrue;
+    tif->tif_predecode = _TIFFNoPreCode;
-	tif->tif_encoderow = _TIFFNoRowEncode;
+    tif->tif_decoderow = _TIFFNoRowDecode;
-	tif->tif_encodestrip = _TIFFNoStripEncode;  
+    tif->tif_decodestrip = _TIFFNoStripDecode;
-	tif->tif_encodetile = _TIFFNoTileEncode;  
+    tif->tif_decodetile = _TIFFNoTileDecode;
-	tif->tif_close = _TIFFvoid;
+    tif->tif_encodestatus = TRUE;
-	tif->tif_seek = _TIFFNoSeek;
+    tif->tif_setupencode = _TIFFtrue;
-	tif->tif_cleanup = _TIFFvoid;
+    tif->tif_preencode = _TIFFNoPreCode;
-	tif->tif_defstripsize = _TIFFDefaultStripSize;
+    tif->tif_postencode = _TIFFtrue;
-	tif->tif_deftilesize = _TIFFDefaultTileSize;
+    tif->tif_encoderow = _TIFFNoRowEncode;
-	tif->tif_flags &= ~(TIFF_NOBITREV|TIFF_NOREADRAW);
+    tif->tif_encodestrip = _TIFFNoStripEncode;
+    tif->tif_encodetile = _TIFFNoTileEncode;
+    tif->tif_close = _TIFFvoid;
+    tif->tif_seek = _TIFFNoSeek;
+    tif->tif_cleanup = _TIFFvoid;
+    tif->tif_defstripsize = _TIFFDefaultStripSize;
+    tif->tif_deftilesize = _TIFFDefaultTileSize;
+    tif->tif_flags &= ~(TIFF_NOBITREV | TIFF_NOREADRAW);
 }
 
-int
+int TIFFSetCompressionScheme(TIFF *tif, int scheme)
-TIFFSetCompressionScheme(TIFF* tif, int scheme)
 {
-	const TIFFCodec *c = TIFFFindCODEC((uint16) scheme);
+    const TIFFCodec *c = TIFFFindCODEC((uint16_t)scheme);
 
-	_TIFFSetDefaultCompressionState(tif);
+    _TIFFSetDefaultCompressionState(tif);
-	/*
+    /*
-	 * Don't treat an unknown compression scheme as an error.
+     * Don't treat an unknown compression scheme as an error.
-	 * This permits applications to open files with data that
+     * This permits applications to open files with data that
-	 * the library does not have builtin support for, but which
+     * the library does not have builtin support for, but which
-	 * may still be meaningful.
+     * may still be meaningful.
-	 */
+     */
-	return (c ? (*c->init)(tif, scheme) : 1);
+    return (c ? (*c->init)(tif, scheme) : 1);
 }
 
 /*
@@ -175,64 +182,68 @@ TIFFSetCompressionScheme(TIFF* tif, int scheme)
  * schemes can also override the builtin versions provided
  * by this library.
  */
-typedef struct _codec {
+typedef struct _codec
-	struct _codec* next;
+{
-	TIFFCodec* info;
+    struct _codec *next;
+    TIFFCodec *info;
 } codec_t;
-static codec_t* registeredCODECS = NULL;
+static codec_t *registeredCODECS = NULL;
 
-const TIFFCodec*
+const TIFFCodec *TIFFFindCODEC(uint16_t scheme)
-TIFFFindCODEC(uint16 scheme)
 {
-	const TIFFCodec* c;
+    const TIFFCodec *c;
-	codec_t* cd;
+    codec_t *cd;
 
-	for (cd = registeredCODECS; cd; cd = cd->next)
+    for (cd = registeredCODECS; cd; cd = cd->next)
-		if (cd->info->scheme == scheme)
+        if (cd->info->scheme == scheme)
-			return ((const TIFFCodec*) cd->info);
+            return ((const TIFFCodec *)cd->info);
-	for (c = _TIFFBuiltinCODECS; c->name; c++)
+    for (c = _TIFFBuiltinCODECS; c->name; c++)
-		if (c->scheme == scheme)
+        if (c->scheme == scheme)
-			return (c);
+            return (c);
-	return ((const TIFFCodec*) 0);
+    return ((const TIFFCodec *)0);
 }
 
-TIFFCodec*
+TIFFCodec *TIFFRegisterCODEC(uint16_t scheme, const char *name,
-TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
+                             TIFFInitMethod init)
 {
-	codec_t* cd = (codec_t*)
+    codec_t *cd = (codec_t *)_TIFFmallocExt(
-	    _TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1));
+        NULL,
+        (tmsize_t)(sizeof(codec_t) + sizeof(TIFFCodec) + strlen(name) + 1));
 
-	if (cd != NULL) {
+    if (cd != NULL)
-		cd->info = (TIFFCodec*) ((uint8*) cd + sizeof (codec_t));
+    {
-		cd->info->name = (char*)
+        cd->info = (TIFFCodec *)((uint8_t *)cd + sizeof(codec_t));
-		    ((uint8*) cd->info + sizeof (TIFFCodec));
+        cd->info->name = (char *)((uint8_t *)cd->info + sizeof(TIFFCodec));
-		strcpy(cd->info->name, name);
+        strcpy(cd->info->name, name);
-		cd->info->scheme = scheme;
+        cd->info->scheme = scheme;
-		cd->info->init = init;
+        cd->info->init = init;
-		cd->next = registeredCODECS;
+        cd->next = registeredCODECS;
-		registeredCODECS = cd;
+        registeredCODECS = cd;
-	} else {
+    }
-		TIFFErrorExt(0, "TIFFRegisterCODEC",
+    else
-		    "No space to register compression scheme %s", name);
+    {
-		return NULL;
+        TIFFErrorExt(0, "TIFFRegisterCODEC",
-	}
+                     "No space to register compression scheme %s", name);
-	return (cd->info);
+        return NULL;
+    }
+    return (cd->info);
 }
 
-void
+void TIFFUnRegisterCODEC(TIFFCodec *c)
-TIFFUnRegisterCODEC(TIFFCodec* c)
 {
-	codec_t* cd;
+    codec_t *cd;
-	codec_t** pcd;
+    codec_t **pcd;
 
-	for (pcd = &registeredCODECS; (cd = *pcd) != NULL; pcd = &cd->next)
+    for (pcd = &registeredCODECS; (cd = *pcd) != NULL; pcd = &cd->next)
-		if (cd->info == c) {
+        if (cd->info == c)
-			*pcd = cd->next;
+        {
-			_TIFFfree(cd);
+            *pcd = cd->next;
-			return;
+            _TIFFfreeExt(NULL, cd);
-		}
+            return;
-	TIFFErrorExt(0, "TIFFUnRegisterCODEC",
+        }
-	    "Cannot remove compression scheme %s; not registered", c->name);
+    TIFFErrorExt(0, "TIFFUnRegisterCODEC",
+                 "Cannot remove compression scheme %s; not registered",
+                 c->name);
 }
 
 /************************************************************************/
@@ -247,56 +258,53 @@ TIFFUnRegisterCODEC(TIFFCodec* c)
  * or NULL if function failed.
  */
 
-TIFFCodec*
+TIFFCodec *TIFFGetConfiguredCODECs()
-TIFFGetConfiguredCODECs()
 {
-	int i = 1;
+    int i = 1;
-	codec_t *cd;
+    codec_t *cd;
-	const TIFFCodec* c;
+    const TIFFCodec *c;
-	TIFFCodec* codecs = NULL;
+    TIFFCodec *codecs = NULL;
-	TIFFCodec* new_codecs;
+    TIFFCodec *new_codecs;
 
-	for (cd = registeredCODECS; cd; cd = cd->next) {
+    for (cd = registeredCODECS; cd; cd = cd->next)
-		new_codecs = (TIFFCodec *)
+    {
-			_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
+        new_codecs =
-		if (!new_codecs) {
+            (TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
-			_TIFFfree (codecs);
+        if (!new_codecs)
-			return NULL;
+        {
-		}
+            _TIFFfreeExt(NULL, codecs);
-		codecs = new_codecs;
+            return NULL;
-		_TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec));
+        }
-		i++;
+        codecs = new_codecs;
-	}
+        _TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec));
-	for (c = _TIFFBuiltinCODECS; c->name; c++) {
+        i++;
-		if (TIFFIsCODECConfigured(c->scheme)) {
+    }
-			new_codecs = (TIFFCodec *)
+    for (c = _TIFFBuiltinCODECS; c->name; c++)
-				_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
+    {
-			if (!new_codecs) {
+        if (TIFFIsCODECConfigured(c->scheme))
-				_TIFFfree (codecs);
+        {
-				return NULL;
+            new_codecs = (TIFFCodec *)_TIFFreallocExt(NULL, codecs,
-			}
+                                                      i * sizeof(TIFFCodec));
-			codecs = new_codecs;
+            if (!new_codecs)
-			_TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec));
+            {
-			i++;
+                _TIFFfreeExt(NULL, codecs);
-		}
+                return NULL;
-	}
+            }
+            codecs = new_codecs;
+            _TIFFmemcpy(codecs + i - 1, (const void *)c, sizeof(TIFFCodec));
+            i++;
+        }
+    }
 
-	new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
+    new_codecs =
-	if (!new_codecs) {
+        (TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
-		_TIFFfree (codecs);
+    if (!new_codecs)
-		return NULL;
+    {
-	}
+        _TIFFfreeExt(NULL, codecs);
-	codecs = new_codecs;
+        return NULL;
-	_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
+    }
+    codecs = new_codecs;
+    _TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
 
-	return codecs;
+    return codecs;
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_config.h.cmake.in

@@ -1,6 +1,14 @@
+/* clang-format off */
+/* clang-format disabled because CMake scripts are very sensitive to the
+ * formatting of this file. configure_file variables of type "@VAR@" are
+ * modified by clang-format and won't be substituted.
+ */
+
 /* libtiff/tif_config.h.cmake.in.  Not generated, but originated from autoheader.  */
 /* This file must be kept up-to-date with needed substitutions from libtiff/tif_config.h.in. */
 
+#include "tiffconf.h"
+
 /* Support CCITT Group 3 & 4 algorithms */
 #cmakedefine CCITT_SUPPORT 1
 
@@ -20,84 +28,33 @@
 /* Define to 1 if you have the <assert.h> header file. */
 #cmakedefine HAVE_ASSERT_H 1
 
-/* Define to 1 if you have the <dlfcn.h> header file. */
+/* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */
-#cmakedefine HAVE_DLFCN_H 1
+#cmakedefine HAVE_DECL_OPTARG 1
 
 /* Define to 1 if you have the <fcntl.h> header file. */
 #cmakedefine HAVE_FCNTL_H 1
 
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#cmakedefine HAVE_FSEEKO 1
+
 /* Define to 1 if you have the `getopt' function. */
 #cmakedefine HAVE_GETOPT 1
 
-/* Define to 1 if you have the <GLUT/glut.h> header file. */
-#cmakedefine HAVE_GLUT_GLUT_H 1
-
-/* Define to 1 if you have the <GL/glut.h> header file. */
-#cmakedefine HAVE_GL_GLUT_H 1
-
-/* Define to 1 if you have the <GL/glu.h> header file. */
-#cmakedefine HAVE_GL_GLU_H 1
-
-/* Define to 1 if you have the <GL/gl.h> header file. */
-#cmakedefine HAVE_GL_GL_H 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#cmakedefine HAVE_INTTYPES_H 1
-
 /* Define to 1 if you have the <io.h> header file. */
 #cmakedefine HAVE_IO_H 1
 
 /* Define to 1 if you have the `jbg_newlen' function. */
 #cmakedefine HAVE_JBG_NEWLEN 1
 
-/* Define to 1 if you have the `lfind' function. */
-#cmakedefine HAVE_LFIND 1
-
 /* Define to 1 if you have the `mmap' function. */
 #cmakedefine HAVE_MMAP 1
 
-/* Define to 1 if you have the <OpenGL/glu.h> header file. */
-#cmakedefine HAVE_OPENGL_GLU_H 1
-
-/* Define to 1 if you have the <OpenGL/gl.h> header file. */
-#cmakedefine HAVE_OPENGL_GL_H 1
-
-/* Define to 1 if you have the <search.h> header file. */
-#cmakedefine HAVE_SEARCH_H 1
-
 /* Define to 1 if you have the `setmode' function. */
 #cmakedefine HAVE_SETMODE 1
 
-/* Define to 1 if you have the `snprintf' function. */
-#cmakedefine HAVE_SNPRINTF 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#cmakedefine HAVE_STDINT_H 1
-
-/* Define to 1 if you have the `strcasecmp' function. */
-#cmakedefine HAVE_STRCASECMP 1
-
 /* Define to 1 if you have the <strings.h> header file. */
 #cmakedefine HAVE_STRINGS_H 1
 
-/* Define to 1 if you have the <string.h> header file. */
-#cmakedefine HAVE_STRING_H 1
-
-/* Define to 1 if you have the `strtol' function. */
-#cmakedefine HAVE_STRTOL 1
-
-/* Define to 1 if you have the `strtoll' function. */
-#cmakedefine HAVE_STRTOLL 1
-
-/* Define to 1 if you have the `strtoul' function. */
-#cmakedefine HAVE_STRTOUL 1
-
-/* Define to 1 if you have the `strtoull' function. */
-#cmakedefine HAVE_STRTOULL 1
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#cmakedefine HAVE_SYS_TIME_H 1
-
 /* Define to 1 if you have the <sys/types.h> header file. */
 #cmakedefine HAVE_SYS_TYPES_H 1
 
@@ -105,20 +62,17 @@
 #cmakedefine HAVE_UNISTD_H 1
 
 /* 8/12 bit libjpeg dual mode enabled */
-#cmakedefine JPEG_DUAL_MODE_8_12 1
+#cmakedefine JPEG_DUAL_MODE_8_12 1 1
+
+/* Support LERC compression */
+#cmakedefine LERC_SUPPORT 1
 
 /* 12bit libjpeg primary include file with path */
-#define LIBJPEG_12_PATH @LIBJPEG_12_PATH@
+#define LIBJPEG_12_PATH "@LIBJPEG_12_PATH@"
 
 /* Support LZMA2 compression */
 #cmakedefine LZMA_SUPPORT 1
 
-/* Support ZSTD compression */
-#cmakedefine ZSTD_SUPPORT 1
-
-/* Support WEBP compression */
-#cmakedefine WEBP_SUPPORT 1
-
 /* Name of package */
 #define PACKAGE "@PACKAGE_NAME@"
 
@@ -128,80 +82,30 @@
 /* Define to the full name of this package. */
 #define PACKAGE_NAME "@PACKAGE_NAME@"
 
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "@PACKAGE_STRING@"
-
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "@PACKAGE_TARNAME@"
 
 /* Define to the home page for this package. */
 #define PACKAGE_URL "@PACKAGE_URL@"
 
-/* Define to the version of this package. */
+/* Size of size_t */
-#define PACKAGE_VERSION "@PACKAGE_VERSION@"
+#define SIZEOF_SIZE_T @SIZEOF_SIZE_T@
-
-/* The size of `signed int', as computed by sizeof. */
-#define SIZEOF_SIGNED_INT @SIZEOF_SIGNED_INT@
-
-/* The size of `signed long', as computed by sizeof. */
-#define SIZEOF_SIGNED_LONG @SIZEOF_SIGNED_LONG@
-
-/* The size of `signed long long', as computed by sizeof. */
-#define SIZEOF_SIGNED_LONG_LONG @SIZEOF_SIGNED_LONG_LONG@
-
-/* The size of `unsigned char *', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_CHAR_P @SIZEOF_UNSIGNED_CHAR_P@
-
-/* The size of `unsigned int', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_INT @SIZEOF_UNSIGNED_INT@
-
-/* The size of `unsigned long', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_LONG @SIZEOF_UNSIGNED_LONG@
-
-/* The size of `unsigned long long', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_LONG_LONG @SIZEOF_UNSIGNED_LONG_LONG@
-
-/* The size of `unsigned short', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_SHORT @SIZEOF_UNSIGNED_SHORT@
 
 /* Default size of the strip in bytes (when strip chopping enabled) */
-#define STRIP_SIZE_DEFAULT @STRIP_SIZE_DEFAULT@
+#cmakedefine STRIP_SIZE_DEFAULT @STRIP_SIZE_DEFAULT@
 
-/* Signed 32-bit type formatter */
+/** Maximum number of TIFF IFDs that libtiff can iterate through in a file. */
-#define TIFF_INT32_FORMAT "@TIFF_INT32_FORMAT@"
+#define TIFF_MAX_DIR_COUNT @TIFF_MAX_DIR_COUNT@
-
-/* Signed 64-bit type formatter */
-#define TIFF_INT64_FORMAT "@TIFF_INT64_FORMAT@"
-
-/* Pointer difference type formatter */
-#define TIFF_PTRDIFF_FORMAT "@TIFF_PTRDIFF_FORMAT@"
-
-/* Unsigned size type formatter */
-#define TIFF_SIZE_FORMAT "@TIFF_SIZE_FORMAT@"
-
-/* Signed size type formatter */
-#define TIFF_SSIZE_FORMAT "@TIFF_SSIZE_FORMAT@"
-
-/* Unsigned 32-bit type formatter */
-#define TIFF_UINT32_FORMAT "@TIFF_UINT32_FORMAT@"
-
-/* Unsigned 64-bit type formatter */
-#define TIFF_UINT64_FORMAT "@TIFF_UINT64_FORMAT@"
-
-/* Unsigned 8-bit type */
-#define TIFF_UINT8_T @TIFF_UINT8_T@
-
-/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
-#undef TIME_WITH_SYS_TIME
-
-/* Define to 1 if your <sys/time.h> declares `struct tm'. */
-#cmakedefine TM_IN_SYS_TIME 1
 
 /* define to use win32 IO system */
 #cmakedefine USE_WIN32_FILEIO 1
 
-/* Version number of package */
+/* Support WEBP compression */
-#define VERSION "@PACKAGE_VERSION@"
+#cmakedefine WEBP_SUPPORT 1
+
+/* Support ZSTD compression */
+#cmakedefine ZSTD_SUPPORT 1
+
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */
@@ -215,17 +119,21 @@
 # endif
 #endif
 
-/* Number of bits in a file offset, on hosts where this is settable. */
+#if !defined(__MINGW32__)
-#define _FILE_OFFSET_BITS @FILE_OFFSET_BITS@
+#  define TIFF_SIZE_FORMAT "zu"
-
+#endif
-/* Define to `__inline__' or `__inline' if that's what the C compiler
+#if SIZEOF_SIZE_T == 8
-   calls it, or to nothing if 'inline' is not supported under any name.  */
+#  define TIFF_SSIZE_FORMAT PRId64
-#ifndef __cplusplus
+#  if defined(__MINGW32__)
-#define inline @INLINE_KEYWORD@
+#    define TIFF_SIZE_FORMAT PRIu64
+#  endif
+#elif SIZEOF_SIZE_T == 4
+#  define TIFF_SSIZE_FORMAT PRId32
+#  if defined(__MINGW32__)
+#    define TIFF_SIZE_FORMAT PRIu32
+#  endif
+#else
+#  error "Unsupported size_t size; please submit a bug report"
 #endif
 
-/* Define to `long int' if <sys/types.h> does not define. */
+/* clang-format on */
-#undef off_t
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t

3rdparty/libtiff/tif_dir.h

@@ -23,7 +23,7 @@
  */
 
 #ifndef _TIFFDIR_
-#define	_TIFFDIR_
+#define _TIFFDIR_
 
 #include "tiff.h"
 #include "tiffio.h"
@@ -32,10 +32,11 @@
  * ``Library-private'' Directory-related Definitions.
  */
 
-typedef struct {
+typedef struct
-	const TIFFField *info;
+{
-	int             count;
+    const TIFFField *info;
-	void           *value;
+    int count;
+    void *value;
 } TIFFTagValue;
 
 /*
@@ -49,79 +50,91 @@ typedef struct {
  * BigTIFF, then it is placed in the offset field to save space. If so,
  * it is left-justified in the offset field.
  */
-typedef struct {
+typedef struct
-	uint16 tdir_tag;        /* see below */
+{
-	uint16 tdir_type;       /* data type; see below */
+    uint16_t tdir_tag;   /* see below */
-	uint64 tdir_count;      /* number of items; length in spec */
+    uint16_t tdir_type;  /* data type; see below */
-	union {
+    uint64_t tdir_count; /* number of items; length in spec */
-		uint16 toff_short;
+    union
-		uint32 toff_long;
+    {
-		uint64 toff_long8;
+        uint16_t toff_short;
-	} tdir_offset;		/* either offset or the data itself if fits */
+        uint32_t toff_long;
-	uint8  tdir_ignore;	/* flag status to ignore tag when parsing tags in tif_dirread.c */
+        uint64_t toff_long8;
+    } tdir_offset;       /* either offset or the data itself if fits */
+    uint8_t tdir_ignore; /* flag status to ignore tag when parsing tags in
+                            tif_dirread.c */
 } TIFFDirEntry;
 
 /*
  * Internal format of a TIFF directory entry.
  */
-typedef struct {
+typedef struct
-#define FIELD_SETLONGS 4
+{
-	/* bit vector of fields that are set */
+#define FIELDSET_ITEMS 4
-	unsigned long td_fieldsset[FIELD_SETLONGS];
+    /* bit vector of fields that are set */
+    uint32_t td_fieldsset[FIELDSET_ITEMS];
 
-	uint32  td_imagewidth, td_imagelength, td_imagedepth;
+    uint32_t td_imagewidth, td_imagelength, td_imagedepth;
-	uint32  td_tilewidth, td_tilelength, td_tiledepth;
+    uint32_t td_tilewidth, td_tilelength, td_tiledepth;
-	uint32  td_subfiletype;
+    uint32_t td_subfiletype;
-	uint16  td_bitspersample;
+    uint16_t td_bitspersample;
-	uint16  td_sampleformat;
+    uint16_t td_sampleformat;
-	uint16  td_compression;
+    uint16_t td_compression;
-	uint16  td_photometric;
+    uint16_t td_photometric;
-	uint16  td_threshholding;
+    uint16_t td_threshholding;
-	uint16  td_fillorder;
+    uint16_t td_fillorder;
-	uint16  td_orientation;
+    uint16_t td_orientation;
-	uint16  td_samplesperpixel;
+    uint16_t td_samplesperpixel;
-	uint32  td_rowsperstrip;
+    uint32_t td_rowsperstrip;
-	uint16  td_minsamplevalue, td_maxsamplevalue;
+    uint16_t td_minsamplevalue, td_maxsamplevalue;
-	double* td_sminsamplevalue;
+    double *td_sminsamplevalue;
-	double* td_smaxsamplevalue;
+    double *td_smaxsamplevalue;
-	float   td_xresolution, td_yresolution;
+    float td_xresolution, td_yresolution;
-	uint16  td_resolutionunit;
+    uint16_t td_resolutionunit;
-	uint16  td_planarconfig;
+    uint16_t td_planarconfig;
-	float   td_xposition, td_yposition;
+    float td_xposition, td_yposition;
-	uint16  td_pagenumber[2];
+    uint16_t td_pagenumber[2];
-	uint16* td_colormap[3];
+    uint16_t *td_colormap[3];
-	uint16  td_halftonehints[2];
+    uint16_t td_halftonehints[2];
-	uint16  td_extrasamples;
+    uint16_t td_extrasamples;
-	uint16* td_sampleinfo;
+    uint16_t *td_sampleinfo;
-	/* even though the name is misleading, td_stripsperimage is the number
+    /* even though the name is misleading, td_stripsperimage is the number
-	 * of striles (=strips or tiles) per plane, and td_nstrips the total
+     * of striles (=strips or tiles) per plane, and td_nstrips the total
-	 * number of striles */
+     * number of striles */
-	uint32  td_stripsperimage;  
+    uint32_t td_stripsperimage;
-	uint32  td_nstrips;              /* size of offset & bytecount arrays */
+    uint32_t td_nstrips; /* size of offset & bytecount arrays */
-	uint64* td_stripoffset_p;        /* should be accessed with TIFFGetStrileOffset */
+    uint64_t
-	uint64* td_stripbytecount_p;     /* should be accessed with TIFFGetStrileByteCount */
+        *td_stripoffset_p; /* should be accessed with TIFFGetStrileOffset */
-        uint32  td_stripoffsetbyteallocsize; /* number of elements currently allocated for td_stripoffset/td_stripbytecount. Only used if TIFF_LAZYSTRILELOAD is set */
+    uint64_t *td_stripbytecount_p; /* should be accessed with
+                                      TIFFGetStrileByteCount */
+    uint32_t
+        td_stripoffsetbyteallocsize; /* number of elements currently allocated
+                                        for td_stripoffset/td_stripbytecount.
+                                        Only used if TIFF_LAZYSTRILELOAD is set
+                                      */
 #ifdef STRIPBYTECOUNTSORTED_UNUSED
-	int     td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
+    int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
 #endif
-        TIFFDirEntry td_stripoffset_entry;    /* for deferred loading */
+    TIFFDirEntry td_stripoffset_entry;    /* for deferred loading */
-        TIFFDirEntry td_stripbytecount_entry; /* for deferred loading */
+    TIFFDirEntry td_stripbytecount_entry; /* for deferred loading */
-	uint16  td_nsubifd;
+    uint16_t td_nsubifd;
-	uint64* td_subifd;
+    uint64_t *td_subifd;
-	/* YCbCr parameters */
+    /* YCbCr parameters */
-	uint16  td_ycbcrsubsampling[2];
+    uint16_t td_ycbcrsubsampling[2];
-	uint16  td_ycbcrpositioning;
+    uint16_t td_ycbcrpositioning;
-	/* Colorimetry parameters */
+    /* Colorimetry parameters */
-	uint16* td_transferfunction[3];
+    uint16_t *td_transferfunction[3];
-	float*	td_refblackwhite;
+    float *td_refblackwhite;
-	/* CMYK parameters */
+    /* CMYK parameters */
-	int     td_inknameslen;
+    int td_inknameslen;
-	char*   td_inknames;
+    char *td_inknames;
+    uint16_t td_numberofinks; /* number of inks in InkNames string */
 
-	int     td_customValueCount;
+    int td_customValueCount;
-        TIFFTagValue *td_customValues;
+    TIFFTagValue *td_customValues;
 
-        unsigned char td_deferstrilearraywriting; /* see TIFFDeferStrileArrayWriting() */
+    unsigned char
+        td_deferstrilearraywriting; /* see TIFFDeferStrileArrayWriting() */
 } TIFFDirectory;
 
 /*
@@ -135,49 +148,49 @@ typedef struct {
  * Note that a bit *is* allocated for ignored tags; this is understood by the
  * directory reading logic which uses this fact to avoid special-case handling
  */
-#define FIELD_IGNORE                   0
+#define FIELD_IGNORE 0
 
 /* multi-item fields */
-#define FIELD_IMAGEDIMENSIONS          1
+#define FIELD_IMAGEDIMENSIONS 1
-#define FIELD_TILEDIMENSIONS           2
+#define FIELD_TILEDIMENSIONS 2
-#define FIELD_RESOLUTION               3
+#define FIELD_RESOLUTION 3
-#define FIELD_POSITION                 4
+#define FIELD_POSITION 4
 
 /* single-item fields */
-#define FIELD_SUBFILETYPE              5
+#define FIELD_SUBFILETYPE 5
-#define FIELD_BITSPERSAMPLE            6
+#define FIELD_BITSPERSAMPLE 6
-#define FIELD_COMPRESSION              7
+#define FIELD_COMPRESSION 7
-#define FIELD_PHOTOMETRIC              8
+#define FIELD_PHOTOMETRIC 8
-#define FIELD_THRESHHOLDING            9
+#define FIELD_THRESHHOLDING 9
-#define FIELD_FILLORDER                10
+#define FIELD_FILLORDER 10
-#define FIELD_ORIENTATION              15
+#define FIELD_ORIENTATION 15
-#define FIELD_SAMPLESPERPIXEL          16
+#define FIELD_SAMPLESPERPIXEL 16
-#define FIELD_ROWSPERSTRIP             17
+#define FIELD_ROWSPERSTRIP 17
-#define FIELD_MINSAMPLEVALUE           18
+#define FIELD_MINSAMPLEVALUE 18
-#define FIELD_MAXSAMPLEVALUE           19
+#define FIELD_MAXSAMPLEVALUE 19
-#define FIELD_PLANARCONFIG             20
+#define FIELD_PLANARCONFIG 20
-#define FIELD_RESOLUTIONUNIT           22
+#define FIELD_RESOLUTIONUNIT 22
-#define FIELD_PAGENUMBER               23
+#define FIELD_PAGENUMBER 23
-#define FIELD_STRIPBYTECOUNTS          24
+#define FIELD_STRIPBYTECOUNTS 24
-#define FIELD_STRIPOFFSETS             25
+#define FIELD_STRIPOFFSETS 25
-#define FIELD_COLORMAP                 26
+#define FIELD_COLORMAP 26
-#define FIELD_EXTRASAMPLES             31
+#define FIELD_EXTRASAMPLES 31
-#define FIELD_SAMPLEFORMAT             32
+#define FIELD_SAMPLEFORMAT 32
-#define FIELD_SMINSAMPLEVALUE          33
+#define FIELD_SMINSAMPLEVALUE 33
-#define FIELD_SMAXSAMPLEVALUE          34
+#define FIELD_SMAXSAMPLEVALUE 34
-#define FIELD_IMAGEDEPTH               35
+#define FIELD_IMAGEDEPTH 35
-#define FIELD_TILEDEPTH                36
+#define FIELD_TILEDEPTH 36
-#define FIELD_HALFTONEHINTS            37
+#define FIELD_HALFTONEHINTS 37
-#define FIELD_YCBCRSUBSAMPLING         39
+#define FIELD_YCBCRSUBSAMPLING 39
-#define FIELD_YCBCRPOSITIONING         40
+#define FIELD_YCBCRPOSITIONING 40
-#define	FIELD_REFBLACKWHITE            41
+#define FIELD_REFBLACKWHITE 41
-#define FIELD_TRANSFERFUNCTION         44
+#define FIELD_TRANSFERFUNCTION 44
-#define FIELD_INKNAMES                 46
+#define FIELD_INKNAMES 46
-#define FIELD_SUBIFD                   49
+#define FIELD_SUBIFD 49
+#define FIELD_NUMBEROFINKS 50
 /*      FIELD_CUSTOM (see tiffio.h)    65 */
 /* end of support for well-known tags; codec-private tags follow */
-#define FIELD_CODEC                    66  /* base of codec-private tags */
+#define FIELD_CODEC 66 /* base of codec-private tags */
-
 
 /*
  * Pseudo-tags don't normally need field bits since they are not written to an
@@ -187,131 +200,141 @@ typedef struct {
  * or ``unset'' then it can do using internal state flags without polluting
  * the field bit space defined for real tags.
  */
-#define FIELD_PSEUDO			0
+#define FIELD_PSEUDO 0
 
-#define FIELD_LAST			(32*FIELD_SETLONGS-1)
+#define FIELD_LAST (32 * FIELDSET_ITEMS - 1)
 
-#define BITn(n)				(((unsigned long)1L)<<((n)&0x1f))
+#define BITn(n) (((uint32_t)1L) << ((n)&0x1f))
-#define BITFIELDn(tif, n)		((tif)->tif_dir.td_fieldsset[(n)/32])
+#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n) / 32])
-#define TIFFFieldSet(tif, field)	(BITFIELDn(tif, field) & BITn(field))
+#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
-#define TIFFSetFieldBit(tif, field)	(BITFIELDn(tif, field) |= BITn(field))
+#define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field))
-#define TIFFClrFieldBit(tif, field)	(BITFIELDn(tif, field) &= ~BITn(field))
+#define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field))
 
-#define FieldSet(fields, f)		(fields[(f)/32] & BITn(f))
+#define FieldSet(fields, f) (fields[(f) / 32] & BITn(f))
-#define ResetFieldBit(fields, f)	(fields[(f)/32] &= ~BITn(f))
+#define ResetFieldBit(fields, f) (fields[(f) / 32] &= ~BITn(f))
 
-typedef enum {
+typedef enum
-	TIFF_SETGET_UNDEFINED = 0,
+{
-	TIFF_SETGET_ASCII = 1,
+    TIFF_SETGET_UNDEFINED = 0,
-	TIFF_SETGET_UINT8 = 2,
+    TIFF_SETGET_ASCII = 1,
-	TIFF_SETGET_SINT8 = 3,
+    TIFF_SETGET_UINT8 = 2,
-	TIFF_SETGET_UINT16 = 4,
+    TIFF_SETGET_SINT8 = 3,
-	TIFF_SETGET_SINT16 = 5,
+    TIFF_SETGET_UINT16 = 4,
-	TIFF_SETGET_UINT32 = 6,
+    TIFF_SETGET_SINT16 = 5,
-	TIFF_SETGET_SINT32 = 7,
+    TIFF_SETGET_UINT32 = 6,
-	TIFF_SETGET_UINT64 = 8,
+    TIFF_SETGET_SINT32 = 7,
-	TIFF_SETGET_SINT64 = 9,
+    TIFF_SETGET_UINT64 = 8,
-	TIFF_SETGET_FLOAT = 10,
+    TIFF_SETGET_SINT64 = 9,
-	TIFF_SETGET_DOUBLE = 11,
+    TIFF_SETGET_FLOAT = 10,
-	TIFF_SETGET_IFD8 = 12,
+    TIFF_SETGET_DOUBLE = 11,
-	TIFF_SETGET_INT = 13,
+    TIFF_SETGET_IFD8 = 12,
-	TIFF_SETGET_UINT16_PAIR = 14,
+    TIFF_SETGET_INT = 13,
-	TIFF_SETGET_C0_ASCII = 15,
+    TIFF_SETGET_UINT16_PAIR = 14,
-	TIFF_SETGET_C0_UINT8 = 16,
+    TIFF_SETGET_C0_ASCII = 15,
-	TIFF_SETGET_C0_SINT8 = 17,
+    TIFF_SETGET_C0_UINT8 = 16,
-	TIFF_SETGET_C0_UINT16 = 18,
+    TIFF_SETGET_C0_SINT8 = 17,
-	TIFF_SETGET_C0_SINT16 = 19,
+    TIFF_SETGET_C0_UINT16 = 18,
-	TIFF_SETGET_C0_UINT32 = 20,
+    TIFF_SETGET_C0_SINT16 = 19,
-	TIFF_SETGET_C0_SINT32 = 21,
+    TIFF_SETGET_C0_UINT32 = 20,
-	TIFF_SETGET_C0_UINT64 = 22,
+    TIFF_SETGET_C0_SINT32 = 21,
-	TIFF_SETGET_C0_SINT64 = 23,
+    TIFF_SETGET_C0_UINT64 = 22,
-	TIFF_SETGET_C0_FLOAT = 24,
+    TIFF_SETGET_C0_SINT64 = 23,
-	TIFF_SETGET_C0_DOUBLE = 25,
+    TIFF_SETGET_C0_FLOAT = 24,
-	TIFF_SETGET_C0_IFD8 = 26,
+    TIFF_SETGET_C0_DOUBLE = 25,
-	TIFF_SETGET_C16_ASCII = 27,
+    TIFF_SETGET_C0_IFD8 = 26,
-	TIFF_SETGET_C16_UINT8 = 28,
+    TIFF_SETGET_C16_ASCII = 27,
-	TIFF_SETGET_C16_SINT8 = 29,
+    TIFF_SETGET_C16_UINT8 = 28,
-	TIFF_SETGET_C16_UINT16 = 30,
+    TIFF_SETGET_C16_SINT8 = 29,
-	TIFF_SETGET_C16_SINT16 = 31,
+    TIFF_SETGET_C16_UINT16 = 30,
-	TIFF_SETGET_C16_UINT32 = 32,
+    TIFF_SETGET_C16_SINT16 = 31,
-	TIFF_SETGET_C16_SINT32 = 33,
+    TIFF_SETGET_C16_UINT32 = 32,
-	TIFF_SETGET_C16_UINT64 = 34,
+    TIFF_SETGET_C16_SINT32 = 33,
-	TIFF_SETGET_C16_SINT64 = 35,
+    TIFF_SETGET_C16_UINT64 = 34,
-	TIFF_SETGET_C16_FLOAT = 36,
+    TIFF_SETGET_C16_SINT64 = 35,
-	TIFF_SETGET_C16_DOUBLE = 37,
+    TIFF_SETGET_C16_FLOAT = 36,
-	TIFF_SETGET_C16_IFD8 = 38,
+    TIFF_SETGET_C16_DOUBLE = 37,
-	TIFF_SETGET_C32_ASCII = 39,
+    TIFF_SETGET_C16_IFD8 = 38,
-	TIFF_SETGET_C32_UINT8 = 40,
+    TIFF_SETGET_C32_ASCII = 39,
-	TIFF_SETGET_C32_SINT8 = 41,
+    TIFF_SETGET_C32_UINT8 = 40,
-	TIFF_SETGET_C32_UINT16 = 42,
+    TIFF_SETGET_C32_SINT8 = 41,
-	TIFF_SETGET_C32_SINT16 = 43,
+    TIFF_SETGET_C32_UINT16 = 42,
-	TIFF_SETGET_C32_UINT32 = 44,
+    TIFF_SETGET_C32_SINT16 = 43,
-	TIFF_SETGET_C32_SINT32 = 45,
+    TIFF_SETGET_C32_UINT32 = 44,
-	TIFF_SETGET_C32_UINT64 = 46,
+    TIFF_SETGET_C32_SINT32 = 45,
-	TIFF_SETGET_C32_SINT64 = 47,
+    TIFF_SETGET_C32_UINT64 = 46,
-	TIFF_SETGET_C32_FLOAT = 48,
+    TIFF_SETGET_C32_SINT64 = 47,
-	TIFF_SETGET_C32_DOUBLE = 49,
+    TIFF_SETGET_C32_FLOAT = 48,
-	TIFF_SETGET_C32_IFD8 = 50,
+    TIFF_SETGET_C32_DOUBLE = 49,
-	TIFF_SETGET_OTHER = 51
+    TIFF_SETGET_C32_IFD8 = 50,
+    TIFF_SETGET_OTHER = 51
 } TIFFSetGetFieldType;
 
 #if defined(__cplusplus)
-extern "C" {
+extern "C"
+{
 #endif
 
-extern const TIFFFieldArray* _TIFFGetFields(void);
+    extern const TIFFFieldArray *_TIFFGetFields(void);
-extern const TIFFFieldArray* _TIFFGetExifFields(void);
+    extern const TIFFFieldArray *_TIFFGetExifFields(void);
-extern const TIFFFieldArray* _TIFFGetGpsFields(void);
+    extern const TIFFFieldArray *_TIFFGetGpsFields(void);
-extern void _TIFFSetupFields(TIFF* tif, const TIFFFieldArray* infoarray);
+    extern void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *infoarray);
-extern void _TIFFPrintFieldInfo(TIFF*, FILE*);
+    extern void _TIFFPrintFieldInfo(TIFF *, FILE *);
 
-extern int _TIFFFillStriles(TIFF*);        
+    extern int _TIFFFillStriles(TIFF *);
 
-typedef enum {
+    typedef enum
-	tfiatImage,
+    {
-	tfiatExif,
+        tfiatImage,
-	tfiatGps,		/* EXIF-GPS fields array type */
+        tfiatExif,
-	tfiatOther
+        tfiatGps, /* EXIF-GPS fields array type */
-} TIFFFieldArrayType;
+        tfiatOther
+    } TIFFFieldArrayType;
 
-struct _TIFFFieldArray {
+    struct _TIFFFieldArray
-	TIFFFieldArrayType type;    /* array type, will be used to determine if IFD is image and such */
+    {
-	uint32 allocated_size;      /* 0 if array is constant, other if modified by future definition extension support */
+        TIFFFieldArrayType type; /* array type, will be used to determine if IFD
-	uint32 count;               /* number of elements in fields array */
+                                    is image and such */
-	TIFFField* fields;          /* actual field info */
+        uint32_t allocated_size; /* 0 if array is constant, other if modified by
-};
+                                    future definition extension support */
+        uint32_t count;          /* number of elements in fields array */
+        TIFFField *fields;       /* actual field info */
+    };
 
-struct _TIFFField {
+    struct _TIFFField
-	uint32 field_tag;                       /* field's tag */
+    {
-	short field_readcount;                  /* read count/TIFF_VARIABLE/TIFF_SPP */
+        uint32_t field_tag;      /* field's tag */
-	short field_writecount;                 /* write count/TIFF_VARIABLE */
+        short field_readcount;   /* read count/TIFF_VARIABLE/TIFF_SPP */
-	TIFFDataType field_type;                /* type of associated data */
+        short field_writecount;  /* write count/TIFF_VARIABLE */
-	uint32 reserved;                        /* reserved for future extension */
+        TIFFDataType field_type; /* type of associated data */
-	TIFFSetGetFieldType set_field_type;     /* type to be passed to TIFFSetField */
+        uint32_t
-	TIFFSetGetFieldType get_field_type;     /* type to be passed to TIFFGetField */
+            field_anonymous; /* if true, this is a unknown / anonymous tag */
-	unsigned short field_bit;               /* bit in fieldsset bit vector */
+        TIFFSetGetFieldType
-	unsigned char field_oktochange;         /* if true, can change while writing */
+            set_field_type; /* type to be passed to TIFFSetField */
-	unsigned char field_passcount;          /* if true, pass dir count on set */
+        TIFFSetGetFieldType
-	char* field_name;                       /* ASCII name */
+            get_field_type;              /* type to be passed to TIFFGetField */
-	TIFFFieldArray* field_subfields;        /* if field points to child ifds, child ifd field definition array */
+        unsigned short field_bit;        /* bit in fieldsset bit vector */
-};
+        unsigned char field_oktochange;  /* if true, can change while writing */
+        unsigned char field_passcount;   /* if true, pass dir count on set */
+        char *field_name;                /* ASCII name */
+        TIFFFieldArray *field_subfields; /* if field points to child ifds, child
+                                            ifd field definition array */
+    };
 
-extern int _TIFFMergeFields(TIFF*, const TIFFField[], uint32);
+    extern int _TIFFMergeFields(TIFF *, const TIFFField[], uint32_t);
-extern const TIFFField* _TIFFFindOrRegisterField(TIFF *, uint32, TIFFDataType);
+    extern const TIFFField *_TIFFFindOrRegisterField(TIFF *, uint32_t,
-extern  TIFFField* _TIFFCreateAnonField(TIFF *, uint32, TIFFDataType);
+                                                     TIFFDataType);
-extern int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag);
+    extern TIFFField *_TIFFCreateAnonField(TIFF *, uint32_t, TIFFDataType);
+    extern int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag);
+    extern int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn,
+                                            uint64_t diroff);
+    extern int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff,
+                                           tdir_t *dirn);
+    extern int _TIFFGetOffsetFromDirNumber(TIFF *tif, tdir_t dirn,
+                                           uint64_t *diroff);
+    extern int _TIFFRemoveEntryFromDirectoryListByOffset(TIFF *tif,
+                                                         uint64_t diroff);
 
 #if defined(__cplusplus)
 }
 #endif
 #endif /* _TIFFDIR_ */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_dumpmode.c

@@ -29,113 +29,94 @@
  */
 #include "tiffiop.h"
 
-static int
+static int DumpFixupTags(TIFF *tif)
-DumpFixupTags(TIFF* tif)
 {
-	(void) tif;
+    (void)tif;
-	return (1);
+    return (1);
 }
 
 /*
  * Encode a hunk of pixels.
  */
-static int
+static int DumpModeEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
-DumpModeEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
 {
-	(void) s;
+    (void)s;
-	while (cc > 0) {
+    while (cc > 0)
-		tmsize_t n;
+    {
+        tmsize_t n;
 
-		n = cc;
+        n = cc;
-		if (tif->tif_rawcc + n > tif->tif_rawdatasize)
+        if (tif->tif_rawcc + n > tif->tif_rawdatasize)
-			n = tif->tif_rawdatasize - tif->tif_rawcc;
+            n = tif->tif_rawdatasize - tif->tif_rawcc;
 
-		assert( n > 0 );
+        assert(n > 0);
 
-		/*
+        /*
-		 * Avoid copy if client has setup raw
+         * Avoid copy if client has setup raw
-		 * data buffer to avoid extra copy.
+         * data buffer to avoid extra copy.
-		 */
+         */
-		if (tif->tif_rawcp != pp)
+        if (tif->tif_rawcp != pp)
-			_TIFFmemcpy(tif->tif_rawcp, pp, n);
+            _TIFFmemcpy(tif->tif_rawcp, pp, n);
-		tif->tif_rawcp += n;
+        tif->tif_rawcp += n;
-		tif->tif_rawcc += n;
+        tif->tif_rawcc += n;
-		pp += n;
+        pp += n;
-		cc -= n;
+        cc -= n;
-		if (tif->tif_rawcc >= tif->tif_rawdatasize &&
+        if (tif->tif_rawcc >= tif->tif_rawdatasize && !TIFFFlushData1(tif))
-		    !TIFFFlushData1(tif))
+            return (0);
-			return (0);
+    }
-	}
+    return (1);
-	return (1);
 }
 
 /*
  * Decode a hunk of pixels.
  */
-static int
+static int DumpModeDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
-DumpModeDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 {
-	static const char module[] = "DumpModeDecode";
+    static const char module[] = "DumpModeDecode";
-	(void) s;
+    (void)s;
-	if (tif->tif_rawcc < cc) {
+    if (tif->tif_rawcc < cc)
-#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
+    {
-		TIFFErrorExt(tif->tif_clientdata, module,
+        TIFFErrorExtR(tif, module,
-"Not enough data for scanline %lu, expected a request for at most %I64d bytes, got a request for %I64d bytes",
+                      "Not enough data for scanline %" PRIu32
-		             (unsigned long) tif->tif_row,
+                      ", expected a request for at most %" TIFF_SSIZE_FORMAT
-		             (signed __int64) tif->tif_rawcc,
+                      " bytes, got a request for %" TIFF_SSIZE_FORMAT " bytes",
-		             (signed __int64) cc);
+                      tif->tif_row, tif->tif_rawcc, cc);
-#else
+        return (0);
-		TIFFErrorExt(tif->tif_clientdata, module,
+    }
-"Not enough data for scanline %lu, expected a request for at most %lld bytes, got a request for %lld bytes",
+    /*
-		             (unsigned long) tif->tif_row,
+     * Avoid copy if client has setup raw
-		             (signed long long) tif->tif_rawcc,
+     * data buffer to avoid extra copy.
-		             (signed long long) cc);
+     */
-#endif
+    if (tif->tif_rawcp != buf)
-		return (0);
+        _TIFFmemcpy(buf, tif->tif_rawcp, cc);
-	}
+    tif->tif_rawcp += cc;
-	/*
+    tif->tif_rawcc -= cc;
-	 * Avoid copy if client has setup raw
+    return (1);
-	 * data buffer to avoid extra copy.
-	 */
-	if (tif->tif_rawcp != buf)
-		_TIFFmemcpy(buf, tif->tif_rawcp, cc);
-	tif->tif_rawcp += cc;
-	tif->tif_rawcc -= cc;  
-	return (1);
 }
 
 /*
  * Seek forwards nrows in the current strip.
  */
-static int
+static int DumpModeSeek(TIFF *tif, uint32_t nrows)
-DumpModeSeek(TIFF* tif, uint32 nrows)
 {
-	tif->tif_rawcp += nrows * tif->tif_scanlinesize;
+    tif->tif_rawcp += nrows * tif->tif_scanlinesize;
-	tif->tif_rawcc -= nrows * tif->tif_scanlinesize;
+    tif->tif_rawcc -= nrows * tif->tif_scanlinesize;
-	return (1);
+    return (1);
 }
 
 /*
  * Initialize dump mode.
  */
-int
+int TIFFInitDumpMode(TIFF *tif, int scheme)
-TIFFInitDumpMode(TIFF* tif, int scheme)
 {
-	(void) scheme;
+    (void)scheme;
-	tif->tif_fixuptags = DumpFixupTags;  
+    tif->tif_fixuptags = DumpFixupTags;
-	tif->tif_decoderow = DumpModeDecode;
+    tif->tif_decoderow = DumpModeDecode;
-	tif->tif_decodestrip = DumpModeDecode;
+    tif->tif_decodestrip = DumpModeDecode;
-	tif->tif_decodetile = DumpModeDecode;
+    tif->tif_decodetile = DumpModeDecode;
-	tif->tif_encoderow = DumpModeEncode;
+    tif->tif_encoderow = DumpModeEncode;
-	tif->tif_encodestrip = DumpModeEncode;
+    tif->tif_encodestrip = DumpModeEncode;
-	tif->tif_encodetile = DumpModeEncode; 
+    tif->tif_encodetile = DumpModeEncode;
-	tif->tif_seek = DumpModeSeek;
+    tif->tif_seek = DumpModeSeek;
-	return (1);
+    return (1);
 }
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_error.c

@@ -29,58 +29,104 @@
 
 TIFFErrorHandlerExt _TIFFerrorHandlerExt = NULL;
 
-TIFFErrorHandler
+TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler handler)
-TIFFSetErrorHandler(TIFFErrorHandler handler)
 {
-	TIFFErrorHandler prev = _TIFFerrorHandler;
+    TIFFErrorHandler prev = _TIFFerrorHandler;
-	_TIFFerrorHandler = handler;
+    _TIFFerrorHandler = handler;
-	return (prev);
+    return (prev);
 }
 
-TIFFErrorHandlerExt
+TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt handler)
-TIFFSetErrorHandlerExt(TIFFErrorHandlerExt handler)
 {
-	TIFFErrorHandlerExt prev = _TIFFerrorHandlerExt;
+    TIFFErrorHandlerExt prev = _TIFFerrorHandlerExt;
-	_TIFFerrorHandlerExt = handler;
+    _TIFFerrorHandlerExt = handler;
-	return (prev);
+    return (prev);
 }
 
-void
+void TIFFError(const char *module, const char *fmt, ...)
-TIFFError(const char* module, const char* fmt, ...)
 {
-	va_list ap;
+    va_list ap;
-	if (_TIFFerrorHandler) {
+    if (_TIFFerrorHandler)
-		va_start(ap, fmt);	
+    {
-		(*_TIFFerrorHandler)(module, fmt, ap);
+        va_start(ap, fmt);
-		va_end(ap);
+        (*_TIFFerrorHandler)(module, fmt, ap);
-	}
+        va_end(ap);
-	if (_TIFFerrorHandlerExt) {
+    }
-		va_start(ap, fmt);
+    if (_TIFFerrorHandlerExt)
-		(*_TIFFerrorHandlerExt)(0, module, fmt, ap);
+    {
-		va_end(ap);
+        va_start(ap, fmt);
-	}
+        (*_TIFFerrorHandlerExt)(0, module, fmt, ap);
+        va_end(ap);
+    }
 }
 
-void
+void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt, ...)
-TIFFErrorExt(thandle_t fd, const char* module, const char* fmt, ...)
 {
-	va_list ap;
+    va_list ap;
-	if (_TIFFerrorHandler) {
+    if (_TIFFerrorHandler)
-		va_start(ap, fmt);
+    {
-		(*_TIFFerrorHandler)(module, fmt, ap);
+        va_start(ap, fmt);
-		va_end(ap);
+        (*_TIFFerrorHandler)(module, fmt, ap);
-	}
+        va_end(ap);
-	if (_TIFFerrorHandlerExt) {
+    }
-		va_start(ap, fmt);
+    if (_TIFFerrorHandlerExt)
-		(*_TIFFerrorHandlerExt)(fd, module, fmt, ap);
+    {
-		va_end(ap);
+        va_start(ap, fmt);
-	}
+        (*_TIFFerrorHandlerExt)(fd, module, fmt, ap);
+        va_end(ap);
+    }
 }
 
-/*
+void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata,
- * Local Variables:
+                     const char *module, const char *fmt, ...)
- * mode: c
+{
- * c-basic-offset: 8
+    va_list ap;
- * fill-column: 78
+    if (opts && opts->errorhandler)
- * End:
+    {
- */
+        va_start(ap, fmt);
+        int stop = opts->errorhandler(NULL, opts->errorhandler_user_data,
+                                      module, fmt, ap);
+        va_end(ap);
+        if (stop)
+            return;
+    }
+    if (_TIFFerrorHandler)
+    {
+        va_start(ap, fmt);
+        (*_TIFFerrorHandler)(module, fmt, ap);
+        va_end(ap);
+    }
+    if (_TIFFerrorHandlerExt)
+    {
+        va_start(ap, fmt);
+        (*_TIFFerrorHandlerExt)(clientdata, module, fmt, ap);
+        va_end(ap);
+    }
+}
+
+void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt, ...)
+{
+    va_list ap;
+    if (tif && tif->tif_errorhandler)
+    {
+        va_start(ap, fmt);
+        int stop = (*tif->tif_errorhandler)(
+            tif, tif->tif_errorhandler_user_data, module, fmt, ap);
+        va_end(ap);
+        if (stop)
+            return;
+    }
+    if (_TIFFerrorHandler)
+    {
+        va_start(ap, fmt);
+        (*_TIFFerrorHandler)(module, fmt, ap);
+        va_end(ap);
+    }
+    if (_TIFFerrorHandlerExt)
+    {
+        va_start(ap, fmt);
+        (*_TIFFerrorHandlerExt)(tif ? tif->tif_clientdata : NULL, module, fmt,
+                                ap);
+        va_end(ap);
+    }
+}

3rdparty/libtiff/tif_extension.c

@@ -31,21 +31,21 @@
 
 #include "tiffiop.h"
 
-int TIFFGetTagListCount( TIFF *tif )
+int TIFFGetTagListCount(TIFF *tif)
 
 {
-    TIFFDirectory* td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
 
     return td->td_customValueCount;
 }
 
-uint32 TIFFGetTagListEntry( TIFF *tif, int tag_index )
+uint32_t TIFFGetTagListEntry(TIFF *tif, int tag_index)
 
 {
-    TIFFDirectory* td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
 
-    if( tag_index < 0 || tag_index >= td->td_customValueCount )
+    if (tag_index < 0 || tag_index >= td->td_customValueCount)
-        return (uint32)(-1);
+        return (uint32_t)(-1);
     else
         return td->td_customValues[tag_index].info->field_tag;
 }
@@ -55,27 +55,27 @@ uint32 TIFFGetTagListEntry( TIFF *tif, int tag_index )
 ** structure to application code without giving access to the private
 ** TIFF structure.
 */
-TIFFTagMethods *TIFFAccessTagMethods( TIFF *tif )
+TIFFTagMethods *TIFFAccessTagMethods(TIFF *tif)
 
 {
     return &(tif->tif_tagmethods);
 }
 
-void *TIFFGetClientInfo( TIFF *tif, const char *name )
+void *TIFFGetClientInfo(TIFF *tif, const char *name)
 
 {
     TIFFClientInfoLink *psLink = tif->tif_clientinfo;
 
-    while( psLink != NULL && strcmp(psLink->name,name) != 0 )
+    while (psLink != NULL && strcmp(psLink->name, name) != 0)
         psLink = psLink->next;
 
-    if( psLink != NULL )
+    if (psLink != NULL)
         return psLink->data;
     else
         return NULL;
 }
 
-void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
+void TIFFSetClientInfo(TIFF *tif, void *data, const char *name)
 
 {
     TIFFClientInfoLink *psLink = tif->tif_clientinfo;
@@ -84,10 +84,10 @@ void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
     ** Do we have an existing link with this name?  If so, just
     ** set it.
     */
-    while( psLink != NULL && strcmp(psLink->name,name) != 0 )
+    while (psLink != NULL && strcmp(psLink->name, name) != 0)
         psLink = psLink->next;
 
-    if( psLink != NULL )
+    if (psLink != NULL)
     {
         psLink->data = data;
         return;
@@ -97,20 +97,14 @@ void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
     ** Create a new link.
     */
 
-    psLink = (TIFFClientInfoLink *) _TIFFmalloc(sizeof(TIFFClientInfoLink));
+    psLink =
-    assert (psLink != NULL);
+        (TIFFClientInfoLink *)_TIFFmallocExt(tif, sizeof(TIFFClientInfoLink));
+    assert(psLink != NULL);
     psLink->next = tif->tif_clientinfo;
-    psLink->name = (char *) _TIFFmalloc((tmsize_t)(strlen(name)+1));
+    psLink->name = (char *)_TIFFmallocExt(tif, (tmsize_t)(strlen(name) + 1));
-    assert (psLink->name != NULL);
+    assert(psLink->name != NULL);
     strcpy(psLink->name, name);
     psLink->data = data;
 
     tif->tif_clientinfo = psLink;
 }
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_fax3.h

@@ -23,7 +23,7 @@
  */
 
 #ifndef _FAX3_
-#define	_FAX3_
+#define _FAX3_
 /*
  * TIFF Library.
  *
@@ -41,7 +41,7 @@
  * The routine must have the type signature given below;
  * for example:
  *
- * fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx)
+ * fillruns(unsigned char* buf, uint32_t* runs, uint32_t* erun, uint32_t lastx)
  *
  * where buf is place to set the bits, runs is the array of b&w run
  * lengths (white then black), erun is the last run in the array, and
@@ -50,41 +50,47 @@
  * data in the run array as needed (e.g. to append zero runs to bring
  * the count up to a nice multiple).
  */
-typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
+typedef void (*TIFFFaxFillFunc)(unsigned char *, uint32_t *, uint32_t *,
+                                uint32_t);
 
 /*
  * The default run filler; made external for other decoders.
  */
 #if defined(__cplusplus)
-extern "C" {
+extern "C"
+{
 #endif
-extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32);
+    extern void _TIFFFax3fillruns(unsigned char *, uint32_t *, uint32_t *,
+                                  uint32_t);
 #if defined(__cplusplus)
 }
 #endif
 
-
 /* finite state machine codes */
-#define S_Null     0
+#define S_Null 0
-#define S_Pass     1
+#define S_Pass 1
-#define S_Horiz    2
+#define S_Horiz 2
-#define S_V0       3
+#define S_V0 3
-#define S_VR       4
+#define S_VR 4
-#define S_VL       5
+#define S_VL 5
-#define S_Ext      6
+#define S_Ext 6
-#define S_TermW    7
+#define S_TermW 7
-#define S_TermB    8
+#define S_TermB 8
-#define S_MakeUpW  9
+#define S_MakeUpW 9
-#define S_MakeUpB  10
+#define S_MakeUpB 10
-#define S_MakeUp   11
+#define S_MakeUp 11
-#define S_EOL      12
+#define S_EOL 12
 
-/* WARNING: do not change the layout of this structure as the HylaFAX software */
+/* WARNING: do not change the layout of this structure as the HylaFAX software
-/* really depends on it. See http://bugzilla.maptools.org/show_bug.cgi?id=2636 */
+ */
-typedef struct {                /* state table entry */
+/* really depends on it. See http://bugzilla.maptools.org/show_bug.cgi?id=2636
-	unsigned char State;    /* see above */
+ */
-	unsigned char Width;    /* width of code in bits */
+typedef struct
-	uint32 Param;           /* unsigned 32-bit run length in bits (holds on 16 bit actually, but cannot be changed. See above warning) */
+{                        /* state table entry */
+    unsigned char State; /* see above */
+    unsigned char Width; /* width of code in bits */
+    uint32_t Param;      /* unsigned 32-bit run length in bits (holds on 16 bit
+                            actually, but cannot be changed. See above warning) */
 } TIFFFaxTabEnt;
 
 extern const TIFFFaxTabEnt TIFFFaxMainTable[];
@@ -108,7 +114,7 @@ extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
  */
 
 #ifndef EndOfData
-#define EndOfData()	(cp >= ep)
+#define EndOfData() (cp >= ep)
 #endif
 /*
  * Need <=8 or <=16 bits of input data.  Unlike viewfax we
@@ -134,121 +140,143 @@ extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
  * otherwise we should get the right answer.
  */
 #ifndef NeedBits8
-#define NeedBits8(n,eoflab) do {					\
+#define NeedBits8(n, eoflab)                                                   \
-    if (BitsAvail < (n)) {						\
+    do                                                                         \
-	if (EndOfData()) {						\
+    {                                                                          \
-	    if (BitsAvail == 0)			/* no valid bits */	\
+        if (BitsAvail < (n))                                                   \
-		goto eoflab;						\
+        {                                                                      \
-	    BitsAvail = (n);			/* pad with zeros */	\
+            if (EndOfData())                                                   \
-	} else {							\
+            {                                                                  \
-	    BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail;		\
+                if (BitsAvail == 0) /* no valid bits */                        \
-	    BitsAvail += 8;						\
+                    goto eoflab;                                               \
-	}								\
+                BitsAvail = (n); /* pad with zeros */                          \
-    }									\
+            }                                                                  \
-} while (0)
+            else                                                               \
+            {                                                                  \
+                BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail;              \
+                BitsAvail += 8;                                                \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
 #endif
 #ifndef NeedBits16
-#define NeedBits16(n,eoflab) do {					\
+#define NeedBits16(n, eoflab)                                                  \
-    if (BitsAvail < (n)) {						\
+    do                                                                         \
-	if (EndOfData()) {						\
+    {                                                                          \
-	    if (BitsAvail == 0)			/* no valid bits */	\
+        if (BitsAvail < (n))                                                   \
-		goto eoflab;						\
+        {                                                                      \
-	    BitsAvail = (n);			/* pad with zeros */	\
+            if (EndOfData())                                                   \
-	} else {							\
+            {                                                                  \
-	    BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail;		\
+                if (BitsAvail == 0) /* no valid bits */                        \
-	    if ((BitsAvail += 8) < (n)) {				\
+                    goto eoflab;                                               \
-		if (EndOfData()) {					\
+                BitsAvail = (n); /* pad with zeros */                          \
-		    /* NB: we know BitsAvail is non-zero here */	\
+            }                                                                  \
-		    BitsAvail = (n);		/* pad with zeros */	\
+            else                                                               \
-		} else {						\
+            {                                                                  \
-		    BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail;	\
+                BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail;              \
-		    BitsAvail += 8;					\
+                if ((BitsAvail += 8) < (n))                                    \
-		}							\
+                {                                                              \
-	    }								\
+                    if (EndOfData())                                           \
-	}								\
+                    {                                                          \
-    }									\
+                        /* NB: we know BitsAvail is non-zero here */           \
-} while (0)
+                        BitsAvail = (n); /* pad with zeros */                  \
+                    }                                                          \
+                    else                                                       \
+                    {                                                          \
+                        BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail;      \
+                        BitsAvail += 8;                                        \
+                    }                                                          \
+                }                                                              \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
 #endif
-#define GetBits(n)	(BitAcc & ((1<<(n))-1))
+#define GetBits(n) (BitAcc & ((1 << (n)) - 1))
-#define ClrBits(n) do {							\
+#define ClrBits(n)                                                             \
-    BitsAvail -= (n);							\
+    do                                                                         \
-    BitAcc >>= (n);							\
+    {                                                                          \
-} while (0)
+        BitsAvail -= (n);                                                      \
+        BitAcc >>= (n);                                                        \
+    } while (0)
 
 #ifdef FAX3_DEBUG
-static const char* StateNames[] = {
+static const char *StateNames[] = {
-    "Null   ",
+    "Null   ", "Pass   ", "Horiz  ", "V0     ", "VR     ", "VL     ", "Ext    ",
-    "Pass   ",
+    "TermW  ", "TermB  ", "MakeUpW", "MakeUpB", "MakeUp ", "EOL    ",
-    "Horiz  ",
-    "V0     ",
-    "VR     ",
-    "VL     ",
-    "Ext    ",
-    "TermW  ",
-    "TermB  ",
-    "MakeUpW",
-    "MakeUpB",
-    "MakeUp ",
-    "EOL    ",
 };
 #define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0')
-#define LOOKUP8(wid,tab,eoflab) do {					\
+#define LOOKUP8(wid, tab, eoflab)                                              \
-    int t;								\
+    do                                                                         \
-    NeedBits8(wid,eoflab);						\
+    {                                                                          \
-    TabEnt = tab + GetBits(wid);					\
+        int t;                                                                 \
-    printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail,		\
+        NeedBits8(wid, eoflab);                                                \
-	   StateNames[TabEnt->State], TabEnt->Param);			\
+        TabEnt = tab + GetBits(wid);                                           \
-    for (t = 0; t < TabEnt->Width; t++)					\
+        printf("%08lX/%d: %s%5d\t", (long)BitAcc, BitsAvail,                   \
-	DEBUG_SHOW;							\
+               StateNames[TabEnt->State], TabEnt->Param);                      \
-    putchar('\n');							\
+        for (t = 0; t < TabEnt->Width; t++)                                    \
-    fflush(stdout);							\
+            DEBUG_SHOW;                                                        \
-    ClrBits(TabEnt->Width);						\
+        putchar('\n');                                                         \
-} while (0)
+        fflush(stdout);                                                        \
-#define LOOKUP16(wid,tab,eoflab) do {					\
+        ClrBits(TabEnt->Width);                                                \
-    int t;								\
+    } while (0)
-    NeedBits16(wid,eoflab);						\
+#define LOOKUP16(wid, tab, eoflab)                                             \
-    TabEnt = tab + GetBits(wid);					\
+    do                                                                         \
-    printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail,		\
+    {                                                                          \
-	   StateNames[TabEnt->State], TabEnt->Param);			\
+        int t;                                                                 \
-    for (t = 0; t < TabEnt->Width; t++)					\
+        NeedBits16(wid, eoflab);                                               \
-	DEBUG_SHOW;							\
+        TabEnt = tab + GetBits(wid);                                           \
-    putchar('\n');							\
+        printf("%08lX/%d: %s%5d\t", (long)BitAcc, BitsAvail,                   \
-    fflush(stdout);							\
+               StateNames[TabEnt->State], TabEnt->Param);                      \
-    ClrBits(TabEnt->Width);						\
+        for (t = 0; t < TabEnt->Width; t++)                                    \
-} while (0)
+            DEBUG_SHOW;                                                        \
+        putchar('\n');                                                         \
+        fflush(stdout);                                                        \
+        ClrBits(TabEnt->Width);                                                \
+    } while (0)
 
-#define SETVALUE(x) do {							\
+#define SETVALUE(x)                                                            \
-    *pa++ = RunLength + (x);						\
+    do                                                                         \
-    printf("SETVALUE: %d\t%d\n", RunLength + (x), a0);			\
+    {                                                                          \
-    a0 += x;								\
+        *pa++ = RunLength + (x);                                               \
-    RunLength = 0;							\
+        printf("SETVALUE: %d\t%d\n", RunLength + (x), a0);                     \
-} while (0)
+        a0 += x;                                                               \
+        RunLength = 0;                                                         \
+    } while (0)
 #else
-#define LOOKUP8(wid,tab,eoflab) do {					\
+#define LOOKUP8(wid, tab, eoflab)                                              \
-    NeedBits8(wid,eoflab);						\
+    do                                                                         \
-    TabEnt = tab + GetBits(wid);					\
+    {                                                                          \
-    ClrBits(TabEnt->Width);						\
+        NeedBits8(wid, eoflab);                                                \
-} while (0)
+        TabEnt = tab + GetBits(wid);                                           \
-#define LOOKUP16(wid,tab,eoflab) do {					\
+        ClrBits(TabEnt->Width);                                                \
-    NeedBits16(wid,eoflab);						\
+    } while (0)
-    TabEnt = tab + GetBits(wid);					\
+#define LOOKUP16(wid, tab, eoflab)                                             \
-    ClrBits(TabEnt->Width);						\
+    do                                                                         \
-} while (0)
+    {                                                                          \
+        NeedBits16(wid, eoflab);                                               \
+        TabEnt = tab + GetBits(wid);                                           \
+        ClrBits(TabEnt->Width);                                                \
+    } while (0)
 
 /*
  * Append a run to the run length array for the
  * current row and reset decoding state.
  */
-#define SETVALUE(x) do {							\
+#define SETVALUE(x)                                                            \
-    if (pa >= thisrun + sp->nruns) {					\
+    do                                                                         \
-        TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u",	\
+    {                                                                          \
-                    sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);	\
+        if (pa >= thisrun + sp->nruns)                                         \
-        return (-1);							\
+        {                                                                      \
-    }									\
+            TIFFErrorExtR(tif, module, "Buffer overflow at line %u of %s %u",  \
-    *pa++ = RunLength + (x);						\
+                          sp->line, isTiled(tif) ? "tile" : "strip",           \
-    a0 += (x);								\
+                          isTiled(tif) ? tif->tif_curtile                      \
-    RunLength = 0;							\
+                                       : tif->tif_curstrip);                   \
-} while (0)
+            return (-1);                                                       \
+        }                                                                      \
+        *pa++ = RunLength + (x);                                               \
+        a0 += (x);                                                             \
+        RunLength = 0;                                                         \
+    } while (0)
 #endif
 
 /*
@@ -261,51 +289,62 @@ static const char* StateNames[] = {
  * is non-zero then we still need to scan for the final flag
  * bit that is part of the EOL code.
  */
-#define	SYNC_EOL(eoflab) do {						\
+#define SYNC_EOL(eoflab)                                                       \
-    if (EOLcnt == 0) {							\
+    do                                                                         \
-	for (;;) {							\
+    {                                                                          \
-	    NeedBits16(11,eoflab);					\
+        if (EOLcnt == 0)                                                       \
-	    if (GetBits(11) == 0)					\
+        {                                                                      \
-		break;							\
+            for (;;)                                                           \
-	    ClrBits(1);							\
+            {                                                                  \
-	}								\
+                NeedBits16(11, eoflab);                                        \
-    }									\
+                if (GetBits(11) == 0)                                          \
-    for (;;) {								\
+                    break;                                                     \
-	NeedBits8(8,eoflab);						\
+                ClrBits(1);                                                    \
-	if (GetBits(8))							\
+            }                                                                  \
-	    break;							\
+        }                                                                      \
-	ClrBits(8);							\
+        for (;;)                                                               \
-    }									\
+        {                                                                      \
-    while (GetBits(1) == 0)						\
+            NeedBits8(8, eoflab);                                              \
-	ClrBits(1);							\
+            if (GetBits(8))                                                    \
-    ClrBits(1);				/* EOL bit */			\
+                break;                                                         \
-    EOLcnt = 0;				/* reset EOL counter/flag */	\
+            ClrBits(8);                                                        \
-} while (0)
+        }                                                                      \
+        while (GetBits(1) == 0)                                                \
+            ClrBits(1);                                                        \
+        ClrBits(1); /* EOL bit */                                              \
+        EOLcnt = 0; /* reset EOL counter/flag */                               \
+    } while (0)
 
 /*
  * Cleanup the array of runs after decoding a row.
  * We adjust final runs to insure the user buffer is not
  * overwritten and/or undecoded area is white filled.
  */
-#define	CLEANUP_RUNS() do {						\
+#define CLEANUP_RUNS()                                                         \
-    if (RunLength)							\
+    do                                                                         \
-	SETVALUE(0);							\
+    {                                                                          \
-    if (a0 != lastx) {							\
+        if (RunLength)                                                         \
-	badlength(a0, lastx);						\
+            SETVALUE(0);                                                       \
-	while (a0 > lastx && pa > thisrun)				\
+        if (a0 != lastx)                                                       \
-	    a0 -= *--pa;						\
+        {                                                                      \
-	if (a0 < lastx) {						\
+            badlength(a0, lastx);                                              \
-	    if (a0 < 0)							\
+            while (a0 > lastx && pa > thisrun)                                 \
-		a0 = 0;							\
+                a0 -= *--pa;                                                   \
-	    if ((pa-thisrun)&1)						\
+            if (a0 < lastx)                                                    \
-		SETVALUE(0);						\
+            {                                                                  \
-	    SETVALUE(lastx - a0);						\
+                if (a0 < 0)                                                    \
-	} else if (a0 > lastx) {					\
+                    a0 = 0;                                                    \
-	    SETVALUE(lastx);						\
+                if ((pa - thisrun) & 1)                                        \
-	    SETVALUE(0);							\
+                    SETVALUE(0);                                               \
-	}								\
+                SETVALUE(lastx - a0);                                          \
-    }									\
+            }                                                                  \
-} while (0)
+            else if (a0 > lastx)                                               \
+            {                                                                  \
+                SETVALUE(lastx);                                               \
+                SETVALUE(0);                                                   \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
 
 /*
  * Decode a line of 1D-encoded data.
@@ -319,249 +358,291 @@ static const char* StateNames[] = {
  * the original code depended on the input data being zero-padded to
  * insure the decoder recognized an EOL before running out of data.
  */
-#define EXPAND1D(eoflab) do {						\
+#define EXPAND1D(eoflab)                                                       \
-    for (;;) {								\
+    do                                                                         \
-	for (;;) {							\
+    {                                                                          \
-	    LOOKUP16(12, TIFFFaxWhiteTable, eof1d);			\
+        for (;;)                                                               \
-	    switch (TabEnt->State) {					\
+        {                                                                      \
-	    case S_EOL:							\
+            for (;;)                                                           \
-		EOLcnt = 1;						\
+            {                                                                  \
-		goto done1d;						\
+                LOOKUP16(12, TIFFFaxWhiteTable, eof1d);                        \
-	    case S_TermW:						\
+                switch (TabEnt->State)                                         \
-		SETVALUE(TabEnt->Param);					\
+                {                                                              \
-		goto doneWhite1d;					\
+                    case S_EOL:                                                \
-	    case S_MakeUpW:						\
+                        EOLcnt = 1;                                            \
-	    case S_MakeUp:						\
+                        goto done1d;                                           \
-		a0 += TabEnt->Param;					\
+                    case S_TermW:                                              \
-		RunLength += TabEnt->Param;				\
+                        SETVALUE(TabEnt->Param);                               \
-		break;							\
+                        goto doneWhite1d;                                      \
-	    default:							\
+                    case S_MakeUpW:                                            \
-		unexpected("WhiteTable", a0);				\
+                    case S_MakeUp:                                             \
-		goto done1d;						\
+                        a0 += TabEnt->Param;                                   \
-	    }								\
+                        RunLength += TabEnt->Param;                            \
-	}								\
+                        break;                                                 \
-    doneWhite1d:							\
+                    default:                                                   \
-	if (a0 >= lastx)						\
+                        unexpected("WhiteTable", a0);                          \
-	    goto done1d;						\
+                        goto done1d;                                           \
-	for (;;) {							\
+                }                                                              \
-	    LOOKUP16(13, TIFFFaxBlackTable, eof1d);			\
+            }                                                                  \
-	    switch (TabEnt->State) {					\
+        doneWhite1d:                                                           \
-	    case S_EOL:							\
+            if (a0 >= lastx)                                                   \
-		EOLcnt = 1;						\
+                goto done1d;                                                   \
-		goto done1d;						\
+            for (;;)                                                           \
-	    case S_TermB:						\
+            {                                                                  \
-		SETVALUE(TabEnt->Param);					\
+                LOOKUP16(13, TIFFFaxBlackTable, eof1d);                        \
-		goto doneBlack1d;					\
+                switch (TabEnt->State)                                         \
-	    case S_MakeUpB:						\
+                {                                                              \
-	    case S_MakeUp:						\
+                    case S_EOL:                                                \
-		a0 += TabEnt->Param;					\
+                        EOLcnt = 1;                                            \
-		RunLength += TabEnt->Param;				\
+                        goto done1d;                                           \
-		break;							\
+                    case S_TermB:                                              \
-	    default:							\
+                        SETVALUE(TabEnt->Param);                               \
-		unexpected("BlackTable", a0);				\
+                        goto doneBlack1d;                                      \
-		goto done1d;						\
+                    case S_MakeUpB:                                            \
-	    }								\
+                    case S_MakeUp:                                             \
-	}								\
+                        a0 += TabEnt->Param;                                   \
-    doneBlack1d:							\
+                        RunLength += TabEnt->Param;                            \
-	if (a0 >= lastx)						\
+                        break;                                                 \
-	    goto done1d;						\
+                    default:                                                   \
-        if( *(pa-1) == 0 && *(pa-2) == 0 )				\
+                        unexpected("BlackTable", a0);                          \
-            pa -= 2;                                                    \
+                        goto done1d;                                           \
-    }									\
+                }                                                              \
-eof1d:									\
+            }                                                                  \
-    prematureEOF(a0);							\
+        doneBlack1d:                                                           \
-    CLEANUP_RUNS();							\
+            if (a0 >= lastx)                                                   \
-    goto eoflab;							\
+                goto done1d;                                                   \
-done1d:									\
+            if (*(pa - 1) == 0 && *(pa - 2) == 0)                              \
-    CLEANUP_RUNS();							\
+                pa -= 2;                                                       \
-} while (0)
+        }                                                                      \
+    eof1d:                                                                     \
+        prematureEOF(a0);                                                      \
+        CLEANUP_RUNS();                                                        \
+        goto eoflab;                                                           \
+    done1d:                                                                    \
+        CLEANUP_RUNS();                                                        \
+    } while (0)
 
 /*
  * Update the value of b1 using the array
  * of runs for the reference line.
  */
-#define CHECK_b1 do {							\
+#define CHECK_b1                                                               \
-    if (pa != thisrun) while (b1 <= a0 && b1 < lastx) {			\
+    do                                                                         \
-	if( pb + 1 >= sp->refruns + sp->nruns) { 			\
+    {                                                                          \
-	    TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u",	\
+        if (pa != thisrun)                                                     \
-	                sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);	\
+            while (b1 <= a0 && b1 < lastx)                                     \
-	    return (-1);						\
+            {                                                                  \
-	}								\
+                if (pb + 1 >= sp->refruns + sp->nruns)                         \
-	b1 += pb[0] + pb[1];						\
+                {                                                              \
-	pb += 2;							\
+                    TIFFErrorExtR(                                             \
-    }									\
+                        tif, module, "Buffer overflow at line %u of %s %u",    \
-} while (0)
+                        sp->line, isTiled(tif) ? "tile" : "strip",             \
+                        isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);  \
+                    return (-1);                                               \
+                }                                                              \
+                b1 += pb[0] + pb[1];                                           \
+                pb += 2;                                                       \
+            }                                                                  \
+    } while (0)
 
 /*
  * Expand a row of 2D-encoded data.
  */
-#define EXPAND2D(eoflab) do {						\
+#define EXPAND2D(eoflab)                                                       \
-    while (a0 < lastx) {						\
+    do                                                                         \
-	if (pa >= thisrun + sp->nruns) {				\
+    {                                                                          \
-		TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u",	\
+        while (a0 < lastx)                                                     \
-		             sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);	\
+        {                                                                      \
-		return (-1);						\
+            if (pa >= thisrun + sp->nruns)                                     \
-	}								\
+            {                                                                  \
-	LOOKUP8(7, TIFFFaxMainTable, eof2d);				\
+                TIFFErrorExtR(                                                 \
-	switch (TabEnt->State) {					\
+                    tif, module, "Buffer overflow at line %u of %s %u",        \
-	case S_Pass:							\
+                    sp->line, isTiled(tif) ? "tile" : "strip",                 \
-	    CHECK_b1;							\
+                    isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);      \
-	    if( pb + 1 >= sp->refruns + sp->nruns) { 			\
+                return (-1);                                                   \
-	        TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u",	\
+            }                                                                  \
-	                sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);	\
+            LOOKUP8(7, TIFFFaxMainTable, eof2d);                               \
-	        return (-1);						\
+            switch (TabEnt->State)                                             \
-	    }								\
+            {                                                                  \
-	    b1 += *pb++;						\
+                case S_Pass:                                                   \
-	    RunLength += b1 - a0;					\
+                    CHECK_b1;                                                  \
-	    a0 = b1;							\
+                    if (pb + 1 >= sp->refruns + sp->nruns)                     \
-	    b1 += *pb++;						\
+                    {                                                          \
-	    break;							\
+                        TIFFErrorExtR(tif, module,                             \
-	case S_Horiz:							\
+                                      "Buffer overflow at line %u of %s %u",   \
-	    if ((pa-thisrun)&1) {					\
+                                      sp->line,                                \
-		for (;;) {	/* black first */			\
+                                      isTiled(tif) ? "tile" : "strip",         \
-		    LOOKUP16(13, TIFFFaxBlackTable, eof2d);		\
+                                      isTiled(tif) ? tif->tif_curtile          \
-		    switch (TabEnt->State) {				\
+                                                   : tif->tif_curstrip);       \
-		    case S_TermB:					\
+                        return (-1);                                           \
-			SETVALUE(TabEnt->Param);				\
+                    }                                                          \
-			goto doneWhite2da;				\
+                    b1 += *pb++;                                               \
-		    case S_MakeUpB:					\
+                    RunLength += b1 - a0;                                      \
-		    case S_MakeUp:					\
+                    a0 = b1;                                                   \
-			a0 += TabEnt->Param;				\
+                    b1 += *pb++;                                               \
-			RunLength += TabEnt->Param;			\
+                    break;                                                     \
-			break;						\
+                case S_Horiz:                                                  \
-		    default:						\
+                    if ((pa - thisrun) & 1)                                    \
-			goto badBlack2d;				\
+                    {                                                          \
-		    }							\
+                        for (;;)                                               \
-		}							\
+                        { /* black first */                                    \
-	    doneWhite2da:;						\
+                            LOOKUP16(13, TIFFFaxBlackTable, eof2d);            \
-		for (;;) {	/* then white */			\
+                            switch (TabEnt->State)                             \
-		    LOOKUP16(12, TIFFFaxWhiteTable, eof2d);		\
+                            {                                                  \
-		    switch (TabEnt->State) {				\
+                                case S_TermB:                                  \
-		    case S_TermW:					\
+                                    SETVALUE(TabEnt->Param);                   \
-			SETVALUE(TabEnt->Param);				\
+                                    goto doneWhite2da;                         \
-			goto doneBlack2da;				\
+                                case S_MakeUpB:                                \
-		    case S_MakeUpW:					\
+                                case S_MakeUp:                                 \
-		    case S_MakeUp:					\
+                                    a0 += TabEnt->Param;                       \
-			a0 += TabEnt->Param;				\
+                                    RunLength += TabEnt->Param;                \
-			RunLength += TabEnt->Param;			\
+                                    break;                                     \
-			break;						\
+                                default:                                       \
-		    default:						\
+                                    goto badBlack2d;                           \
-			goto badWhite2d;				\
+                            }                                                  \
-		    }							\
+                        }                                                      \
-		}							\
+                    doneWhite2da:;                                             \
-	    doneBlack2da:;						\
+                        for (;;)                                               \
-	    } else {							\
+                        { /* then white */                                     \
-		for (;;) {	/* white first */			\
+                            LOOKUP16(12, TIFFFaxWhiteTable, eof2d);            \
-		    LOOKUP16(12, TIFFFaxWhiteTable, eof2d);		\
+                            switch (TabEnt->State)                             \
-		    switch (TabEnt->State) {				\
+                            {                                                  \
-		    case S_TermW:					\
+                                case S_TermW:                                  \
-			SETVALUE(TabEnt->Param);				\
+                                    SETVALUE(TabEnt->Param);                   \
-			goto doneWhite2db;				\
+                                    goto doneBlack2da;                         \
-		    case S_MakeUpW:					\
+                                case S_MakeUpW:                                \
-		    case S_MakeUp:					\
+                                case S_MakeUp:                                 \
-			a0 += TabEnt->Param;				\
+                                    a0 += TabEnt->Param;                       \
-			RunLength += TabEnt->Param;			\
+                                    RunLength += TabEnt->Param;                \
-			break;						\
+                                    break;                                     \
-		    default:						\
+                                default:                                       \
-			goto badWhite2d;				\
+                                    goto badWhite2d;                           \
-		    }							\
+                            }                                                  \
-		}							\
+                        }                                                      \
-	    doneWhite2db:;						\
+                    doneBlack2da:;                                             \
-		for (;;) {	/* then black */			\
+                    }                                                          \
-		    LOOKUP16(13, TIFFFaxBlackTable, eof2d);		\
+                    else                                                       \
-		    switch (TabEnt->State) {				\
+                    {                                                          \
-		    case S_TermB:					\
+                        for (;;)                                               \
-			SETVALUE(TabEnt->Param);				\
+                        { /* white first */                                    \
-			goto doneBlack2db;				\
+                            LOOKUP16(12, TIFFFaxWhiteTable, eof2d);            \
-		    case S_MakeUpB:					\
+                            switch (TabEnt->State)                             \
-		    case S_MakeUp:					\
+                            {                                                  \
-			a0 += TabEnt->Param;				\
+                                case S_TermW:                                  \
-			RunLength += TabEnt->Param;			\
+                                    SETVALUE(TabEnt->Param);                   \
-			break;						\
+                                    goto doneWhite2db;                         \
-		    default:						\
+                                case S_MakeUpW:                                \
-			goto badBlack2d;				\
+                                case S_MakeUp:                                 \
-		    }							\
+                                    a0 += TabEnt->Param;                       \
-		}							\
+                                    RunLength += TabEnt->Param;                \
-	    doneBlack2db:;						\
+                                    break;                                     \
-	    }								\
+                                default:                                       \
-	    CHECK_b1;							\
+                                    goto badWhite2d;                           \
-	    break;							\
+                            }                                                  \
-	case S_V0:							\
+                        }                                                      \
-	    CHECK_b1;							\
+                    doneWhite2db:;                                             \
-	    SETVALUE(b1 - a0);						\
+                        for (;;)                                               \
-	    if( pb >= sp->refruns + sp->nruns) { 			\
+                        { /* then black */                                     \
-	        TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u",	\
+                            LOOKUP16(13, TIFFFaxBlackTable, eof2d);            \
-	                sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);	\
+                            switch (TabEnt->State)                             \
-	        return (-1);						\
+                            {                                                  \
-	    }								\
+                                case S_TermB:                                  \
-	    b1 += *pb++;						\
+                                    SETVALUE(TabEnt->Param);                   \
-	    break;							\
+                                    goto doneBlack2db;                         \
-	case S_VR:							\
+                                case S_MakeUpB:                                \
-	    CHECK_b1;							\
+                                case S_MakeUp:                                 \
-	    SETVALUE(b1 - a0 + TabEnt->Param);				\
+                                    a0 += TabEnt->Param;                       \
-	    if( pb >= sp->refruns + sp->nruns) { 			\
+                                    RunLength += TabEnt->Param;                \
-	        TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u",	\
+                                    break;                                     \
-	                sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip);	\
+                                default:                                       \
-	        return (-1);						\
+                                    goto badBlack2d;                           \
-	    }								\
+                            }                                                  \
-	    b1 += *pb++;						\
+                        }                                                      \
-	    break;							\
+                    doneBlack2db:;                                             \
-	case S_VL:							\
+                    }                                                          \
-	    CHECK_b1;							\
+                    CHECK_b1;                                                  \
-	    if (b1 < (int) (a0 + TabEnt->Param)) {			\
+                    break;                                                     \
-		unexpected("VL", a0);				\
+                case S_V0:                                                     \
-		goto eol2d;						\
+                    CHECK_b1;                                                  \
-	    }								\
+                    SETVALUE(b1 - a0);                                         \
-	    SETVALUE(b1 - a0 - TabEnt->Param);				\
+                    if (pb >= sp->refruns + sp->nruns)                         \
-	    b1 -= *--pb;						\
+                    {                                                          \
-	    break;							\
+                        TIFFErrorExtR(tif, module,                             \
-	case S_Ext:							\
+                                      "Buffer overflow at line %u of %s %u",   \
-	    *pa++ = lastx - a0;						\
+                                      sp->line,                                \
-	    extension(a0);						\
+                                      isTiled(tif) ? "tile" : "strip",         \
-	    goto eol2d;							\
+                                      isTiled(tif) ? tif->tif_curtile          \
-	case S_EOL:							\
+                                                   : tif->tif_curstrip);       \
-	    *pa++ = lastx - a0;						\
+                        return (-1);                                           \
-	    NeedBits8(4,eof2d);						\
+                    }                                                          \
-	    if (GetBits(4))						\
+                    b1 += *pb++;                                               \
-		unexpected("EOL", a0);					\
+                    break;                                                     \
-            ClrBits(4);                                                 \
+                case S_VR:                                                     \
-	    EOLcnt = 1;							\
+                    CHECK_b1;                                                  \
-	    goto eol2d;							\
+                    SETVALUE(b1 - a0 + TabEnt->Param);                         \
-	default:							\
+                    if (pb >= sp->refruns + sp->nruns)                         \
-	badMain2d:							\
+                    {                                                          \
-	    unexpected("MainTable", a0);				\
+                        TIFFErrorExtR(tif, module,                             \
-	    goto eol2d;							\
+                                      "Buffer overflow at line %u of %s %u",   \
-	badBlack2d:							\
+                                      sp->line,                                \
-	    unexpected("BlackTable", a0);				\
+                                      isTiled(tif) ? "tile" : "strip",         \
-	    goto eol2d;							\
+                                      isTiled(tif) ? tif->tif_curtile          \
-	badWhite2d:							\
+                                                   : tif->tif_curstrip);       \
-	    unexpected("WhiteTable", a0);				\
+                        return (-1);                                           \
-	    goto eol2d;							\
+                    }                                                          \
-	eof2d:								\
+                    b1 += *pb++;                                               \
-	    prematureEOF(a0);						\
+                    break;                                                     \
-	    CLEANUP_RUNS();						\
+                case S_VL:                                                     \
-	    goto eoflab;						\
+                    CHECK_b1;                                                  \
-	}								\
+                    if (b1 < (int)(a0 + TabEnt->Param))                        \
-    }									\
+                    {                                                          \
-    if (RunLength) {							\
+                        unexpected("VL", a0);                                  \
-	if (RunLength + a0 < lastx) {					\
+                        goto eol2d;                                            \
-	    /* expect a final V0 */					\
+                    }                                                          \
-	    NeedBits8(1,eof2d);						\
+                    SETVALUE(b1 - a0 - TabEnt->Param);                         \
-	    if (!GetBits(1))						\
+                    b1 -= *--pb;                                               \
-		goto badMain2d;						\
+                    break;                                                     \
-	    ClrBits(1);							\
+                case S_Ext:                                                    \
-	}								\
+                    *pa++ = lastx - a0;                                        \
-	SETVALUE(0);							\
+                    extension(a0);                                             \
-    }									\
+                    goto eol2d;                                                \
-eol2d:									\
+                case S_EOL:                                                    \
-    CLEANUP_RUNS();							\
+                    *pa++ = lastx - a0;                                        \
-} while (0)
+                    NeedBits8(4, eof2d);                                       \
+                    if (GetBits(4))                                            \
+                        unexpected("EOL", a0);                                 \
+                    ClrBits(4);                                                \
+                    EOLcnt = 1;                                                \
+                    goto eol2d;                                                \
+                default:                                                       \
+                badMain2d:                                                     \
+                    unexpected("MainTable", a0);                               \
+                    goto eol2d;                                                \
+                badBlack2d:                                                    \
+                    unexpected("BlackTable", a0);                              \
+                    goto eol2d;                                                \
+                badWhite2d:                                                    \
+                    unexpected("WhiteTable", a0);                              \
+                    goto eol2d;                                                \
+                eof2d:                                                         \
+                    prematureEOF(a0);                                          \
+                    CLEANUP_RUNS();                                            \
+                    goto eoflab;                                               \
+            }                                                                  \
+        }                                                                      \
+        if (RunLength)                                                         \
+        {                                                                      \
+            if (RunLength + a0 < lastx)                                        \
+            {                                                                  \
+                /* expect a final V0 */                                        \
+                NeedBits8(1, eof2d);                                           \
+                if (!GetBits(1))                                               \
+                    goto badMain2d;                                            \
+                ClrBits(1);                                                    \
+            }                                                                  \
+            SETVALUE(0);                                                       \
+        }                                                                      \
+    eol2d:                                                                     \
+        CLEANUP_RUNS();                                                        \
+    } while (0)
 #endif /* _FAX3_ */
-/* vim: set ts=8 sts=4 sw=4 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_flush.c

@@ -27,10 +27,9 @@
  */
 #include "tiffiop.h"
 
-int
+int TIFFFlush(TIFF *tif)
-TIFFFlush(TIFF* tif)
 {
-    if( tif->tif_mode == O_RDONLY )
+    if (tif->tif_mode == O_RDONLY)
         return 1;
 
     if (!TIFFFlushData(tif))
@@ -41,16 +40,15 @@ TIFFFlush(TIFF* tif)
        rewrite only that portion of the directory without
        making any other changes */
 
-    if( (tif->tif_flags & TIFF_DIRTYSTRIP)
+    if ((tif->tif_flags & TIFF_DIRTYSTRIP) &&
-        && !(tif->tif_flags & TIFF_DIRTYDIRECT) 
+        !(tif->tif_flags & TIFF_DIRTYDIRECT) && tif->tif_mode == O_RDWR)
-        && tif->tif_mode == O_RDWR )
     {
-        if( TIFFForceStrileArrayWriting(tif) )
+        if (TIFFForceStrileArrayWriting(tif))
             return 1;
     }
 
-    if ((tif->tif_flags & (TIFF_DIRTYDIRECT|TIFF_DIRTYSTRIP)) 
+    if ((tif->tif_flags & (TIFF_DIRTYDIRECT | TIFF_DIRTYSTRIP)) &&
-        && !TIFFRewriteDirectory(tif))
+        !TIFFRewriteDirectory(tif))
         return (0);
 
     return (1);
@@ -75,45 +73,43 @@ TIFFFlush(TIFF* tif)
  *
  * Returns 1 in case of success, 0 otherwise.
  */
-int TIFFForceStrileArrayWriting(TIFF* tif)
+int TIFFForceStrileArrayWriting(TIFF *tif)
 {
     static const char module[] = "TIFFForceStrileArrayWriting";
     const int isTiled = TIFFIsTiled(tif);
 
     if (tif->tif_mode == O_RDONLY)
     {
-        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+        TIFFErrorExtR(tif, tif->tif_name, "File opened in read-only mode");
-                     "File opened in read-only mode");
         return 0;
     }
-    if( tif->tif_diroff == 0 )
+    if (tif->tif_diroff == 0)
     {
-        TIFFErrorExt(tif->tif_clientdata, module,
+        TIFFErrorExtR(tif, module, "Directory has not yet been written");
-                     "Directory has not yet been written");
         return 0;
     }
-    if( (tif->tif_flags & TIFF_DIRTYDIRECT) != 0 )
+    if ((tif->tif_flags & TIFF_DIRTYDIRECT) != 0)
     {
-        TIFFErrorExt(tif->tif_clientdata, module,
+        TIFFErrorExtR(tif, module,
-                     "Directory has changes other than the strile arrays. "
+                      "Directory has changes other than the strile arrays. "
-                     "TIFFRewriteDirectory() should be called instead");
+                      "TIFFRewriteDirectory() should be called instead");
         return 0;
     }
 
-    if( !(tif->tif_flags & TIFF_DIRTYSTRIP) )
+    if (!(tif->tif_flags & TIFF_DIRTYSTRIP))
     {
-        if( !(tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
+        if (!(tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
-             tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
+              tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
-             tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
+              tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
-             tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
+              tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
-             tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
+              tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
-             tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
+              tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
-             tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
+              tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
-             tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0) )
+              tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0))
         {
-            TIFFErrorExt(tif->tif_clientdata, module,
+            TIFFErrorExtR(tif, module,
-                        "Function not called together with "
+                          "Function not called together with "
-                        "TIFFDeferStrileArrayWriting()");
+                          "TIFFDeferStrileArrayWriting()");
             return 0;
         }
 
@@ -121,18 +117,14 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
             return 0;
     }
 
-    if( _TIFFRewriteField( tif,
+    if (_TIFFRewriteField(tif,
-                           isTiled ? TIFFTAG_TILEOFFSETS :
+                          isTiled ? TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS,
-                                     TIFFTAG_STRIPOFFSETS,
+                          TIFF_LONG8, tif->tif_dir.td_nstrips,
-                           TIFF_LONG8,
+                          tif->tif_dir.td_stripoffset_p) &&
-                           tif->tif_dir.td_nstrips,
+        _TIFFRewriteField(
-                           tif->tif_dir.td_stripoffset_p )
+            tif, isTiled ? TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS,
-        && _TIFFRewriteField( tif,
+            TIFF_LONG8, tif->tif_dir.td_nstrips,
-                              isTiled ? TIFFTAG_TILEBYTECOUNTS :
+            tif->tif_dir.td_stripbytecount_p))
-                                        TIFFTAG_STRIPBYTECOUNTS,
-                              TIFF_LONG8,
-                              tif->tif_dir.td_nstrips,
-                              tif->tif_dir.td_stripbytecount_p ) )
     {
         tif->tif_flags &= ~TIFF_DIRTYSTRIP;
         tif->tif_flags &= ~TIFF_BEENWRITING;
@@ -151,24 +143,15 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
  * been writing isn't exactly a an error.  Hopefully this doesn't cause
  * problems for other people.
  */
-int
+int TIFFFlushData(TIFF *tif)
-TIFFFlushData(TIFF* tif)
 {
-	if ((tif->tif_flags & TIFF_BEENWRITING) == 0)
+    if ((tif->tif_flags & TIFF_BEENWRITING) == 0)
-		return (1);
+        return (1);
-	if (tif->tif_flags & TIFF_POSTENCODE) {
+    if (tif->tif_flags & TIFF_POSTENCODE)
-		tif->tif_flags &= ~TIFF_POSTENCODE;
+    {
-		if (!(*tif->tif_postencode)(tif))
+        tif->tif_flags &= ~TIFF_POSTENCODE;
-			return (0);
+        if (!(*tif->tif_postencode)(tif))
-	}
+            return (0);
-	return (TIFFFlushData1(tif));
+    }
+    return (TIFFFlushData1(tif));
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_hash_set.c

@@ -0,0 +1,603 @@
+/**********************************************************************
+ *
+ * Name:     tif_hash_set.c
+ * Purpose:  Hash set functions.
+ * Author:   Even Rouault, <even dot rouault at spatialys.com>
+ *
+ **********************************************************************
+ * Copyright (c) 2008-2009, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ ****************************************************************************/
+
+#include "tif_config.h"
+
+#include "tif_hash_set.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/** List element structure. */
+typedef struct _TIFFList TIFFList;
+
+/** List element structure. */
+struct _TIFFList
+{
+    /*! Pointer to the data object. Should be allocated and freed by the
+     * caller.
+     * */
+    void *pData;
+    /*! Pointer to the next element in list. NULL, if current element is the
+     * last one.
+     */
+    struct _TIFFList *psNext;
+};
+
+struct _TIFFHashSet
+{
+    TIFFHashSetHashFunc fnHashFunc;
+    TIFFHashSetEqualFunc fnEqualFunc;
+    TIFFHashSetFreeEltFunc fnFreeEltFunc;
+    TIFFList **tabList;
+    int nSize;
+    int nIndiceAllocatedSize;
+    int nAllocatedSize;
+    TIFFList *psRecyclingList;
+    int nRecyclingListSize;
+    bool bRehash;
+#ifdef HASH_DEBUG
+    int nCollisions;
+#endif
+};
+
+static const int anPrimes[] = {
+    53,        97,        193,       389,       769,       1543,     3079,
+    6151,      12289,     24593,     49157,     98317,     196613,   393241,
+    786433,    1572869,   3145739,   6291469,   12582917,  25165843, 50331653,
+    100663319, 201326611, 402653189, 805306457, 1610612741};
+
+/************************************************************************/
+/*                    TIFFHashSetHashPointer()                          */
+/************************************************************************/
+
+/**
+ * Hash function for an arbitrary pointer
+ *
+ * @param elt the arbitrary pointer to hash
+ *
+ * @return the hash value of the pointer
+ */
+
+static unsigned long TIFFHashSetHashPointer(const void *elt)
+{
+    return (unsigned long)(uintptr_t)((void *)(elt));
+}
+
+/************************************************************************/
+/*                   TIFFHashSetEqualPointer()                          */
+/************************************************************************/
+
+/**
+ * Equality function for arbitrary pointers
+ *
+ * @param elt1 the first arbitrary pointer to compare
+ * @param elt2 the second arbitrary pointer to compare
+ *
+ * @return true if the pointers are equal
+ */
+
+static bool TIFFHashSetEqualPointer(const void *elt1, const void *elt2)
+{
+    return elt1 == elt2;
+}
+
+/************************************************************************/
+/*                          TIFFHashSetNew()                             */
+/************************************************************************/
+
+/**
+ * Creates a new hash set
+ *
+ * The hash function must return a hash value for the elements to insert.
+ * If fnHashFunc is NULL, TIFFHashSetHashPointer will be used.
+ *
+ * The equal function must return if two elements are equal.
+ * If fnEqualFunc is NULL, TIFFHashSetEqualPointer will be used.
+ *
+ * The free function is used to free elements inserted in the hash set,
+ * when the hash set is destroyed, when elements are removed or replaced.
+ * If fnFreeEltFunc is NULL, elements inserted into the hash set will not be
+ * freed.
+ *
+ * @param fnHashFunc hash function. May be NULL.
+ * @param fnEqualFunc equal function. May be NULL.
+ * @param fnFreeEltFunc element free function. May be NULL.
+ *
+ * @return a new hash set
+ */
+
+TIFFHashSet *TIFFHashSetNew(TIFFHashSetHashFunc fnHashFunc,
+                            TIFFHashSetEqualFunc fnEqualFunc,
+                            TIFFHashSetFreeEltFunc fnFreeEltFunc)
+{
+    TIFFHashSet *set = (TIFFHashSet *)malloc(sizeof(TIFFHashSet));
+    if (set == NULL)
+        return NULL;
+    set->fnHashFunc = fnHashFunc ? fnHashFunc : TIFFHashSetHashPointer;
+    set->fnEqualFunc = fnEqualFunc ? fnEqualFunc : TIFFHashSetEqualPointer;
+    set->fnFreeEltFunc = fnFreeEltFunc;
+    set->nSize = 0;
+    set->tabList = (TIFFList **)(calloc(sizeof(TIFFList *), 53));
+    if (set->tabList == NULL)
+    {
+        free(set);
+        return NULL;
+    }
+    set->nIndiceAllocatedSize = 0;
+    set->nAllocatedSize = 53;
+    set->psRecyclingList = NULL;
+    set->nRecyclingListSize = 0;
+    set->bRehash = false;
+#ifdef HASH_DEBUG
+    set->nCollisions = 0;
+#endif
+    return set;
+}
+
+/************************************************************************/
+/*                          TIFFHashSetSize()                            */
+/************************************************************************/
+
+/**
+ * Returns the number of elements inserted in the hash set
+ *
+ * Note: this is not the internal size of the hash set
+ *
+ * @param set the hash set
+ *
+ * @return the number of elements in the hash set
+ */
+
+int TIFFHashSetSize(const TIFFHashSet *set)
+{
+    assert(set != NULL);
+    return set->nSize;
+}
+
+/************************************************************************/
+/*                       TIFFHashSetGetNewListElt()                      */
+/************************************************************************/
+
+static TIFFList *TIFFHashSetGetNewListElt(TIFFHashSet *set)
+{
+    if (set->psRecyclingList)
+    {
+        TIFFList *psRet = set->psRecyclingList;
+        psRet->pData = NULL;
+        set->nRecyclingListSize--;
+        set->psRecyclingList = psRet->psNext;
+        return psRet;
+    }
+
+    return (TIFFList *)malloc(sizeof(TIFFList));
+}
+
+/************************************************************************/
+/*                       TIFFHashSetReturnListElt()                      */
+/************************************************************************/
+
+static void TIFFHashSetReturnListElt(TIFFHashSet *set, TIFFList *psList)
+{
+    if (set->nRecyclingListSize < 128)
+    {
+        psList->psNext = set->psRecyclingList;
+        set->psRecyclingList = psList;
+        set->nRecyclingListSize++;
+    }
+    else
+    {
+        free(psList);
+    }
+}
+
+/************************************************************************/
+/*                   TIFFHashSetClearInternal()                          */
+/************************************************************************/
+
+static void TIFFHashSetClearInternal(TIFFHashSet *set, bool bFinalize)
+{
+    assert(set != NULL);
+    for (int i = 0; i < set->nAllocatedSize; i++)
+    {
+        TIFFList *cur = set->tabList[i];
+        while (cur)
+        {
+            if (set->fnFreeEltFunc)
+                set->fnFreeEltFunc(cur->pData);
+            TIFFList *psNext = cur->psNext;
+            if (bFinalize)
+                free(cur);
+            else
+                TIFFHashSetReturnListElt(set, cur);
+            cur = psNext;
+        }
+        set->tabList[i] = NULL;
+    }
+    set->bRehash = false;
+}
+
+/************************************************************************/
+/*                         TIFFListDestroy()                            */
+/************************************************************************/
+
+/**
+ * Destroy a list. Caller responsible for freeing data objects contained in
+ * list elements.
+ *
+ * @param psList pointer to list head.
+ *
+ */
+
+static void TIFFListDestroy(TIFFList *psList)
+{
+    TIFFList *psCurrent = psList;
+
+    while (psCurrent)
+    {
+        TIFFList *const psNext = psCurrent->psNext;
+        free(psCurrent);
+        psCurrent = psNext;
+    }
+}
+
+/************************************************************************/
+/*                        TIFFHashSetDestroy()                          */
+/************************************************************************/
+
+/**
+ * Destroys an allocated hash set.
+ *
+ * This function also frees the elements if a free function was
+ * provided at the creation of the hash set.
+ *
+ * @param set the hash set
+ */
+
+void TIFFHashSetDestroy(TIFFHashSet *set)
+{
+    if (set)
+    {
+        TIFFHashSetClearInternal(set, true);
+        free(set->tabList);
+        TIFFListDestroy(set->psRecyclingList);
+        free(set);
+    }
+}
+
+#ifdef notused
+/************************************************************************/
+/*                        TIFFHashSetClear()                             */
+/************************************************************************/
+
+/**
+ * Clear all elements from a hash set.
+ *
+ * This function also frees the elements if a free function was
+ * provided at the creation of the hash set.
+ *
+ * @param set the hash set
+ */
+
+void TIFFHashSetClear(TIFFHashSet *set)
+{
+    TIFFHashSetClearInternal(set, false);
+    set->nIndiceAllocatedSize = 0;
+    set->nAllocatedSize = 53;
+#ifdef HASH_DEBUG
+    set->nCollisions = 0;
+#endif
+    set->nSize = 0;
+}
+
+/************************************************************************/
+/*                       TIFFHashSetForeach()                           */
+/************************************************************************/
+
+/**
+ * Walk through the hash set and runs the provided function on all the
+ * elements
+ *
+ * This function is provided the user_data argument of TIFFHashSetForeach.
+ * It must return true to go on the walk through the hash set, or FALSE to
+ * make it stop.
+ *
+ * Note : the structure of the hash set must *NOT* be modified during the
+ * walk.
+ *
+ * @param set the hash set.
+ * @param fnIterFunc the function called on each element.
+ * @param user_data the user data provided to the function.
+ */
+
+void TIFFHashSetForeach(TIFFHashSet *set, TIFFHashSetIterEltFunc fnIterFunc,
+                        void *user_data)
+{
+    assert(set != NULL);
+    if (!fnIterFunc)
+        return;
+
+    for (int i = 0; i < set->nAllocatedSize; i++)
+    {
+        TIFFList *cur = set->tabList[i];
+        while (cur)
+        {
+            if (!fnIterFunc(cur->pData, user_data))
+                return;
+
+            cur = cur->psNext;
+        }
+    }
+}
+#endif
+
+/************************************************************************/
+/*                        TIFFHashSetRehash()                           */
+/************************************************************************/
+
+static bool TIFFHashSetRehash(TIFFHashSet *set)
+{
+    int nNewAllocatedSize = anPrimes[set->nIndiceAllocatedSize];
+    TIFFList **newTabList =
+        (TIFFList **)(calloc(sizeof(TIFFList *), nNewAllocatedSize));
+    if (newTabList == NULL)
+        return false;
+#ifdef HASH_DEBUG
+    TIFFDebug("TIFFHASH",
+              "hashSet=%p, nSize=%d, nCollisions=%d, "
+              "fCollisionRate=%.02f",
+              set, set->nSize, set->nCollisions,
+              set->nCollisions * 100.0 / set->nSize);
+    set->nCollisions = 0;
+#endif
+    for (int i = 0; i < set->nAllocatedSize; i++)
+    {
+        TIFFList *cur = set->tabList[i];
+        while (cur)
+        {
+            const unsigned long nNewHashVal =
+                set->fnHashFunc(cur->pData) % nNewAllocatedSize;
+#ifdef HASH_DEBUG
+            if (newTabList[nNewHashVal])
+                set->nCollisions++;
+#endif
+            TIFFList *psNext = cur->psNext;
+            cur->psNext = newTabList[nNewHashVal];
+            newTabList[nNewHashVal] = cur;
+            cur = psNext;
+        }
+    }
+    free(set->tabList);
+    set->tabList = newTabList;
+    set->nAllocatedSize = nNewAllocatedSize;
+    set->bRehash = false;
+    return true;
+}
+
+/************************************************************************/
+/*                        TIFFHashSetFindPtr()                          */
+/************************************************************************/
+
+static void **TIFFHashSetFindPtr(TIFFHashSet *set, const void *elt)
+{
+    const unsigned long nHashVal = set->fnHashFunc(elt) % set->nAllocatedSize;
+    TIFFList *cur = set->tabList[nHashVal];
+    while (cur)
+    {
+        if (set->fnEqualFunc(cur->pData, elt))
+            return &cur->pData;
+        cur = cur->psNext;
+    }
+    return NULL;
+}
+
+/************************************************************************/
+/*                         TIFFHashSetInsert()                          */
+/************************************************************************/
+
+/**
+ * Inserts an element into a hash set.
+ *
+ * If the element was already inserted in the hash set, the previous
+ * element is replaced by the new element. If a free function was provided,
+ * it is used to free the previously inserted element
+ *
+ * @param set the hash set
+ * @param elt the new element to insert in the hash set
+ *
+ * @return true if success. If false is returned, elt has not been inserted,
+ * but TIFFHashSetInsert() will have run the free function if provided.
+ */
+
+bool TIFFHashSetInsert(TIFFHashSet *set, void *elt)
+{
+    assert(set != NULL);
+    void **pElt = TIFFHashSetFindPtr(set, elt);
+    if (pElt)
+    {
+        if (set->fnFreeEltFunc)
+            set->fnFreeEltFunc(*pElt);
+
+        *pElt = elt;
+        return true;
+    }
+
+    if (set->nSize >= 2 * set->nAllocatedSize / 3 ||
+        (set->bRehash && set->nIndiceAllocatedSize > 0 &&
+         set->nSize <= set->nAllocatedSize / 2))
+    {
+        set->nIndiceAllocatedSize++;
+        if (!TIFFHashSetRehash(set))
+        {
+            set->nIndiceAllocatedSize--;
+            if (set->fnFreeEltFunc)
+                set->fnFreeEltFunc(elt);
+            return false;
+        }
+    }
+
+    const unsigned long nHashVal = set->fnHashFunc(elt) % set->nAllocatedSize;
+#ifdef HASH_DEBUG
+    if (set->tabList[nHashVal])
+        set->nCollisions++;
+#endif
+
+    TIFFList *new_elt = TIFFHashSetGetNewListElt(set);
+    if (new_elt == NULL)
+    {
+        if (set->fnFreeEltFunc)
+            set->fnFreeEltFunc(elt);
+        return false;
+    }
+    new_elt->pData = elt;
+    new_elt->psNext = set->tabList[nHashVal];
+    set->tabList[nHashVal] = new_elt;
+    set->nSize++;
+
+    return true;
+}
+
+/************************************************************************/
+/*                        TIFFHashSetLookup()                           */
+/************************************************************************/
+
+/**
+ * Returns the element found in the hash set corresponding to the element to
+ * look up The element must not be modified.
+ *
+ * @param set the hash set
+ * @param elt the element to look up in the hash set
+ *
+ * @return the element found in the hash set or NULL
+ */
+
+void *TIFFHashSetLookup(TIFFHashSet *set, const void *elt)
+{
+    assert(set != NULL);
+    void **pElt = TIFFHashSetFindPtr(set, elt);
+    if (pElt)
+        return *pElt;
+
+    return NULL;
+}
+
+/************************************************************************/
+/*                     TIFFHashSetRemoveInternal()                      */
+/************************************************************************/
+
+static bool TIFFHashSetRemoveInternal(TIFFHashSet *set, const void *elt,
+                                      bool bDeferRehash)
+{
+    assert(set != NULL);
+    if (set->nIndiceAllocatedSize > 0 && set->nSize <= set->nAllocatedSize / 2)
+    {
+        set->nIndiceAllocatedSize--;
+        if (bDeferRehash)
+            set->bRehash = true;
+        else
+        {
+            if (!TIFFHashSetRehash(set))
+            {
+                set->nIndiceAllocatedSize++;
+                return false;
+            }
+        }
+    }
+
+    int nHashVal = (int)(set->fnHashFunc(elt) % set->nAllocatedSize);
+    TIFFList *cur = set->tabList[nHashVal];
+    TIFFList *prev = NULL;
+    while (cur)
+    {
+        if (set->fnEqualFunc(cur->pData, elt))
+        {
+            if (prev)
+                prev->psNext = cur->psNext;
+            else
+                set->tabList[nHashVal] = cur->psNext;
+
+            if (set->fnFreeEltFunc)
+                set->fnFreeEltFunc(cur->pData);
+
+            TIFFHashSetReturnListElt(set, cur);
+#ifdef HASH_DEBUG
+            if (set->tabList[nHashVal])
+                set->nCollisions--;
+#endif
+            set->nSize--;
+            return true;
+        }
+        prev = cur;
+        cur = cur->psNext;
+    }
+    return false;
+}
+
+/************************************************************************/
+/*                         TIFFHashSetRemove()                          */
+/************************************************************************/
+
+/**
+ * Removes an element from a hash set
+ *
+ * @param set the hash set
+ * @param elt the new element to remove from the hash set
+ *
+ * @return true if the element was in the hash set
+ */
+
+bool TIFFHashSetRemove(TIFFHashSet *set, const void *elt)
+{
+    return TIFFHashSetRemoveInternal(set, elt, false);
+}
+
+#ifdef notused
+/************************************************************************/
+/*                     TIFFHashSetRemoveDeferRehash()                   */
+/************************************************************************/
+
+/**
+ * Removes an element from a hash set.
+ *
+ * This will defer potential rehashing of the set to later calls to
+ * TIFFHashSetInsert() or TIFFHashSetRemove().
+ *
+ * @param set the hash set
+ * @param elt the new element to remove from the hash set
+ *
+ * @return true if the element was in the hash set
+ */
+
+bool TIFFHashSetRemoveDeferRehash(TIFFHashSet *set, const void *elt)
+{
+    return TIFFHashSetRemoveInternal(set, elt, true);
+}
+#endif

3rdparty/libtiff/tif_hash_set.h

@@ -0,0 +1,100 @@
+/**********************************************************************
+ * $Id$
+ *
+ * Name:     tif_hash_set.h
+ * Project:  TIFF - Common Portability Library
+ * Purpose:  Hash set functions.
+ * Author:   Even Rouault, <even dot rouault at spatialys.com>
+ *
+ **********************************************************************
+ * Copyright (c) 2008-2009, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ ****************************************************************************/
+
+#ifndef TIFF_HASH_SET_H_INCLUDED
+#define TIFF_HASH_SET_H_INCLUDED
+
+#include <stdbool.h>
+
+/**
+ * \file tif_hash_set.h
+ *
+ * Hash set implementation.
+ *
+ * An hash set is a data structure that holds elements that are unique
+ * according to a comparison function. Operations on the hash set, such as
+ * insertion, removal or lookup, are supposed to be fast if an efficient
+ * "hash" function is provided.
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /* Types */
+
+    /** Opaque type for a hash set */
+    typedef struct _TIFFHashSet TIFFHashSet;
+
+    /** TIFFHashSetHashFunc */
+    typedef unsigned long (*TIFFHashSetHashFunc)(const void *elt);
+
+    /** TIFFHashSetEqualFunc */
+    typedef bool (*TIFFHashSetEqualFunc)(const void *elt1, const void *elt2);
+
+    /** TIFFHashSetFreeEltFunc */
+    typedef void (*TIFFHashSetFreeEltFunc)(void *elt);
+
+    /* Functions */
+
+    TIFFHashSet *TIFFHashSetNew(TIFFHashSetHashFunc fnHashFunc,
+                                TIFFHashSetEqualFunc fnEqualFunc,
+                                TIFFHashSetFreeEltFunc fnFreeEltFunc);
+
+    void TIFFHashSetDestroy(TIFFHashSet *set);
+
+    int TIFFHashSetSize(const TIFFHashSet *set);
+
+#ifdef notused
+    void TIFFHashSetClear(TIFFHashSet *set);
+
+    /** TIFFHashSetIterEltFunc */
+    typedef int (*TIFFHashSetIterEltFunc)(void *elt, void *user_data);
+
+    void TIFFHashSetForeach(TIFFHashSet *set, TIFFHashSetIterEltFunc fnIterFunc,
+                            void *user_data);
+#endif
+
+    bool TIFFHashSetInsert(TIFFHashSet *set, void *elt);
+
+    void *TIFFHashSetLookup(TIFFHashSet *set, const void *elt);
+
+    bool TIFFHashSetRemove(TIFFHashSet *set, const void *elt);
+
+#ifdef notused
+    bool TIFFHashSetRemoveDeferRehash(TIFFHashSet *set, const void *elt);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TIFF_HASH_SET_H_INCLUDED */

3rdparty/libtiff/tif_jbig.c

@@ -35,199 +35,197 @@
 #ifdef JBIG_SUPPORT
 #include "jbig.h"
 
-static int JBIGSetupDecode(TIFF* tif)
+static int JBIGSetupDecode(TIFF *tif)
 {
-	if (TIFFNumberOfStrips(tif) != 1)
+    if (TIFFNumberOfStrips(tif) != 1)
-	{
+    {
-		TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in decoder");
+        TIFFErrorExtR(tif, "JBIG",
-		return 0;
+                      "Multistrip images not supported in decoder");
-	}
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
-static int JBIGDecode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s)
+static int JBIGDecode(TIFF *tif, uint8_t *buffer, tmsize_t size, uint16_t s)
 {
-	struct jbg_dec_state decoder;
+    struct jbg_dec_state decoder;
-	int decodeStatus = 0;
+    int decodeStatus = 0;
-	unsigned char* pImage = NULL;
+    unsigned char *pImage = NULL;
-	unsigned long decodedSize;
+    unsigned long decodedSize;
-	(void) s;
+    (void)s;
 
-	if (isFillOrder(tif, tif->tif_dir.td_fillorder))
+    if (isFillOrder(tif, tif->tif_dir.td_fillorder))
-	{
+    {
-		TIFFReverseBits(tif->tif_rawcp, tif->tif_rawcc);
+        TIFFReverseBits(tif->tif_rawcp, tif->tif_rawcc);
-	}
+    }
 
-	jbg_dec_init(&decoder);
+    jbg_dec_init(&decoder);
 
 #if defined(HAVE_JBG_NEWLEN)
-	jbg_newlen(tif->tif_rawcp, (size_t)tif->tif_rawcc);
+    jbg_newlen(tif->tif_rawcp, (size_t)tif->tif_rawcc);
-	/*
+    /*
-	 * I do not check the return status of jbg_newlen because even if this
+     * I do not check the return status of jbg_newlen because even if this
-	 * function fails it does not necessarily mean that decoding the image
+     * function fails it does not necessarily mean that decoding the image
-	 * will fail.  It is generally only needed for received fax images
+     * will fail.  It is generally only needed for received fax images
-	 * that do not contain the actual length of the image in the BIE
+     * that do not contain the actual length of the image in the BIE
-	 * header.  I do not log when an error occurs because that will cause
+     * header.  I do not log when an error occurs because that will cause
-	 * problems when converting JBIG encoded TIFF's to
+     * problems when converting JBIG encoded TIFF's to
-	 * PostScript.  As long as the actual image length is contained in the
+     * PostScript.  As long as the actual image length is contained in the
-	 * BIE header jbg_dec_in should succeed.
+     * BIE header jbg_dec_in should succeed.
-	 */
+     */
 #endif /* HAVE_JBG_NEWLEN */
 
-	decodeStatus = jbg_dec_in(&decoder, (unsigned char*)tif->tif_rawcp,
+    decodeStatus = jbg_dec_in(&decoder, (unsigned char *)tif->tif_rawcp,
-				  (size_t)tif->tif_rawcc, NULL);
+                              (size_t)tif->tif_rawcc, NULL);
-	if (JBG_EOK != decodeStatus)
+    if (JBG_EOK != decodeStatus)
-	{
+    {
-		/*
+        /*
-		 * XXX: JBG_EN constant was defined in pre-2.0 releases of the
+         * XXX: JBG_EN constant was defined in pre-2.0 releases of the
-		 * JBIG-KIT. Since the 2.0 the error reporting functions were
+         * JBIG-KIT. Since the 2.0 the error reporting functions were
-		 * changed. We will handle both cases here.
+         * changed. We will handle both cases here.
-		 */
+         */
-		TIFFErrorExt(tif->tif_clientdata,
+        TIFFErrorExtR(tif, "JBIG", "Error (%d) decoding: %s", decodeStatus,
-			     "JBIG", "Error (%d) decoding: %s",
-			     decodeStatus,
 #if defined(JBG_EN)
-			     jbg_strerror(decodeStatus, JBG_EN)
+                      jbg_strerror(decodeStatus, JBG_EN)
 #else
-			     jbg_strerror(decodeStatus)
+                      jbg_strerror(decodeStatus)
 #endif
-			     );
+        );
-		jbg_dec_free(&decoder);
+        jbg_dec_free(&decoder);
-		return 0;
+        return 0;
-	}
+    }
 
-	decodedSize = jbg_dec_getsize(&decoder);
+    decodedSize = jbg_dec_getsize(&decoder);
-	if( (tmsize_t)decodedSize < size )
+    if ((tmsize_t)decodedSize < size)
-	{
+    {
-	    TIFFWarningExt(tif->tif_clientdata, "JBIG",
+        TIFFWarningExtR(tif, "JBIG",
-	                   "Only decoded %lu bytes, whereas %lu requested",
+                        "Only decoded %lu bytes, whereas %" TIFF_SSIZE_FORMAT
-	                   decodedSize, (unsigned long)size);
+                        " requested",
-	}
+                        decodedSize, size);
-	else if( (tmsize_t)decodedSize > size )
+    }
-	{
+    else if ((tmsize_t)decodedSize > size)
-	    TIFFErrorExt(tif->tif_clientdata, "JBIG",
+    {
-	                 "Decoded %lu bytes, whereas %lu were requested",
+        TIFFErrorExtR(tif, "JBIG",
-	                 decodedSize, (unsigned long)size);
+                      "Decoded %lu bytes, whereas %" TIFF_SSIZE_FORMAT
-	    jbg_dec_free(&decoder);
+                      " were requested",
-	    return 0;
+                      decodedSize, size);
-	}
+        jbg_dec_free(&decoder);
-	pImage = jbg_dec_getimage(&decoder, 0);
+        return 0;
-	_TIFFmemcpy(buffer, pImage, decodedSize);
+    }
-	jbg_dec_free(&decoder);
+    pImage = jbg_dec_getimage(&decoder, 0);
+    _TIFFmemcpy(buffer, pImage, decodedSize);
+    jbg_dec_free(&decoder);
 
-        tif->tif_rawcp += tif->tif_rawcc;
+    tif->tif_rawcp += tif->tif_rawcc;
-        tif->tif_rawcc = 0;
+    tif->tif_rawcc = 0;
 
-	return 1;
+    return 1;
 }
 
-static int JBIGSetupEncode(TIFF* tif)
+static int JBIGSetupEncode(TIFF *tif)
 {
-	if (TIFFNumberOfStrips(tif) != 1)
+    if (TIFFNumberOfStrips(tif) != 1)
-	{
+    {
-		TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in encoder");
+        TIFFErrorExtR(tif, "JBIG",
-		return 0;
+                      "Multistrip images not supported in encoder");
-	}
+        return 0;
+    }
 
-	return 1;
+    return 1;
 }
 
-static int JBIGCopyEncodedData(TIFF* tif, unsigned char* pp, size_t cc, uint16 s)
+static int JBIGCopyEncodedData(TIFF *tif, unsigned char *pp, size_t cc,
+                               uint16_t s)
 {
-	(void) s;
+    (void)s;
-	while (cc > 0)
+    while (cc > 0)
-	{
+    {
-		tmsize_t n = (tmsize_t)cc;
+        tmsize_t n = (tmsize_t)cc;
 
-		if (tif->tif_rawcc + n > tif->tif_rawdatasize)
+        if (tif->tif_rawcc + n > tif->tif_rawdatasize)
-		{
+        {
-			n = tif->tif_rawdatasize - tif->tif_rawcc;
+            n = tif->tif_rawdatasize - tif->tif_rawcc;
-		}
+        }
 
-		assert(n > 0);
+        assert(n > 0);
-		_TIFFmemcpy(tif->tif_rawcp, pp, n);
+        _TIFFmemcpy(tif->tif_rawcp, pp, n);
-		tif->tif_rawcp += n;
+        tif->tif_rawcp += n;
-		tif->tif_rawcc += n;
+        tif->tif_rawcc += n;
-		pp += n;
+        pp += n;
-		cc -= (size_t)n;
+        cc -= (size_t)n;
-		if (tif->tif_rawcc >= tif->tif_rawdatasize &&
+        if (tif->tif_rawcc >= tif->tif_rawdatasize && !TIFFFlushData1(tif))
-		    !TIFFFlushData1(tif))
+        {
-		{
+            return (-1);
-			return (-1);
+        }
-		}
+    }
-	}
 
-	return (1);
+    return (1);
 }
 
-static void JBIGOutputBie(unsigned char* buffer, size_t len, void* userData)
+static void JBIGOutputBie(unsigned char *buffer, size_t len, void *userData)
 {
-	TIFF* tif = (TIFF*)userData;
+    TIFF *tif = (TIFF *)userData;
 
-	if (isFillOrder(tif, tif->tif_dir.td_fillorder))
+    if (isFillOrder(tif, tif->tif_dir.td_fillorder))
-	{
+    {
-		TIFFReverseBits(buffer, (tmsize_t)len);
+        TIFFReverseBits(buffer, (tmsize_t)len);
-	}
+    }
 
-	JBIGCopyEncodedData(tif, buffer, len, 0);
+    JBIGCopyEncodedData(tif, buffer, len, 0);
 }
 
-static int JBIGEncode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s)
+static int JBIGEncode(TIFF *tif, uint8_t *buffer, tmsize_t size, uint16_t s)
 {
-	TIFFDirectory* dir = &tif->tif_dir;
+    TIFFDirectory *dir = &tif->tif_dir;
-	struct jbg_enc_state encoder;
+    struct jbg_enc_state encoder;
 
-	(void) size, (void) s;
+    (void)size, (void)s;
 
-	jbg_enc_init(&encoder,
+    jbg_enc_init(&encoder, dir->td_imagewidth, dir->td_imagelength, 1, &buffer,
-		     dir->td_imagewidth,
+                 JBIGOutputBie, tif);
-		     dir->td_imagelength,
+    /*
-		     1,
+     * jbg_enc_out does the "real" encoding.  As data is encoded,
-		     &buffer,
+     * JBIGOutputBie is called, which writes the data to the directory.
-		     JBIGOutputBie,
+     */
-		     tif);
+    jbg_enc_out(&encoder);
-	/*
+    jbg_enc_free(&encoder);
-	 * jbg_enc_out does the "real" encoding.  As data is encoded,
-	 * JBIGOutputBie is called, which writes the data to the directory.
-	 */
-	jbg_enc_out(&encoder);
-	jbg_enc_free(&encoder);
 
-	return 1;
+    return 1;
 }
 
-int TIFFInitJBIG(TIFF* tif, int scheme)
+int TIFFInitJBIG(TIFF *tif, int scheme)
 {
-        (void)scheme;
+    (void)scheme;
-	assert(scheme == COMPRESSION_JBIG);
+    assert(scheme == COMPRESSION_JBIG);
 
-	/*
+    /*
-	 * These flags are set so the JBIG Codec can control when to reverse
+     * These flags are set so the JBIG Codec can control when to reverse
-	 * bits and when not to and to allow the jbig decoder and bit reverser
+     * bits and when not to and to allow the jbig decoder and bit reverser
-	 * to write to memory when necessary.
+     * to write to memory when necessary.
-	 */
+     */
-	tif->tif_flags |= TIFF_NOBITREV;
+    tif->tif_flags |= TIFF_NOBITREV;
-	tif->tif_flags &= ~TIFF_MAPPED;
+    tif->tif_flags &= ~TIFF_MAPPED;
+    /* We may have read from a previous IFD and thus set TIFF_BUFFERMMAP and
+     * cleared TIFF_MYBUFFER. It is necessary to restore them to their initial
+     * value to be consistent with the state of a non-memory mapped file.
+     */
+    if (tif->tif_flags & TIFF_BUFFERMMAP)
+    {
+        tif->tif_rawdata = NULL;
+        tif->tif_rawdatasize = 0;
+        tif->tif_flags &= ~TIFF_BUFFERMMAP;
+        tif->tif_flags |= TIFF_MYBUFFER;
+    }
 
-	/* Setup the function pointers for encode, decode, and cleanup. */
+    /* Setup the function pointers for encode, decode, and cleanup. */
-	tif->tif_setupdecode = JBIGSetupDecode;
+    tif->tif_setupdecode = JBIGSetupDecode;
-	tif->tif_decodestrip = JBIGDecode;
+    tif->tif_decodestrip = JBIGDecode;
 
-	tif->tif_setupencode = JBIGSetupEncode;
+    tif->tif_setupencode = JBIGSetupEncode;
-	tif->tif_encodestrip = JBIGEncode;
+    tif->tif_encodestrip = JBIGEncode;
 
-	return 1;
+    return 1;
 }
 
 #endif /* JBIG_SUPPORT */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_jpeg_12.c

@@ -1,69 +1,63 @@
 
 #include "tiffiop.h"
 
+#if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
+#define JPEG_DUAL_MODE_8_12
+#endif
+
 #if defined(JPEG_DUAL_MODE_8_12)
 
-#  define TIFFInitJPEG TIFFInitJPEG_12
+#define FROM_TIF_JPEG_12
-#  define TIFFJPEGIsFullStripRequired TIFFJPEGIsFullStripRequired_12
 
-int
+#ifdef TIFFInitJPEG
-TIFFInitJPEG_12(TIFF* tif, int scheme);
+#undef TIFFInitJPEG
+#endif
+#define TIFFInitJPEG TIFFInitJPEG_12
 
-#  include LIBJPEG_12_PATH
+#ifdef TIFFJPEGIsFullStripRequired
+#undef TIFFJPEGIsFullStripRequired
+#endif
+#define TIFFJPEGIsFullStripRequired TIFFJPEGIsFullStripRequired_12
 
-#  include "tif_jpeg.c"
+int TIFFInitJPEG_12(TIFF *tif, int scheme);
 
-int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode )
+#if !defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
+#include LIBJPEG_12_PATH
+#endif
 
+#include "tif_jpeg.c"
+
+int TIFFReInitJPEG_12(TIFF *tif, const JPEGOtherSettings *otherSettings,
+                      int scheme, int is_encode)
 {
-    JPEGState* sp;
+    JPEGState *sp;
+    uint8_t *new_tif_data;
 
+    (void)scheme;
     assert(scheme == COMPRESSION_JPEG);
 
+    new_tif_data =
+        (uint8_t *)_TIFFreallocExt(tif, tif->tif_data, sizeof(JPEGState));
+
+    if (new_tif_data == NULL)
+    {
+        TIFFErrorExtR(tif, "TIFFReInitJPEG_12",
+                      "No space for JPEG state block");
+        return 0;
+    }
+
+    tif->tif_data = new_tif_data;
+    _TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));
+
+    TIFFInitJPEGCommon(tif);
+
     sp = JState(tif);
-    sp->tif = tif;				/* back link */
+    sp->otherSettings = *otherSettings;
 
-    /*
+    if (is_encode)
-     * Override parent get/set field methods.
-     */
-    tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
-    tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
-    tif->tif_tagmethods.printdir = JPEGPrintDir;   /* hook for codec tags */
-
-    /*
-     * Install codec methods.
-     */
-    tif->tif_fixuptags = JPEGFixupTags;
-    tif->tif_setupdecode = JPEGSetupDecode;
-    tif->tif_predecode = JPEGPreDecode;
-    tif->tif_decoderow = JPEGDecode;
-    tif->tif_decodestrip = JPEGDecode;
-    tif->tif_decodetile = JPEGDecode;
-    tif->tif_setupencode = JPEGSetupEncode;
-    tif->tif_preencode = JPEGPreEncode;
-    tif->tif_postencode = JPEGPostEncode;
-    tif->tif_encoderow = JPEGEncode;
-    tif->tif_encodestrip = JPEGEncode;
-    tif->tif_encodetile = JPEGEncode;  
-    tif->tif_cleanup = JPEGCleanup;
-    tif->tif_defstripsize = JPEGDefaultStripSize;
-    tif->tif_deftilesize = JPEGDefaultTileSize;
-    tif->tif_flags |= TIFF_NOBITREV;	/* no bit reversal, please */
-
-    sp->cinfo_initialized = FALSE;
-
-    if( is_encode )
         return JPEGSetupEncode(tif);
     else
         return JPEGSetupDecode(tif);
 }
 
 #endif /* defined(JPEG_DUAL_MODE_8_12) */
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_lzma.c

@@ -33,471 +33,488 @@
  * The codec is derived from ZLIB codec (tif_zip.c).
  */
 
-#include "tif_predict.h"
 #include "lzma.h"
+#include "tif_predict.h"
 
 #include <stdio.h>
 
 /*
  * State block for each open TIFF file using LZMA2 compression/decompression.
  */
-typedef struct {
+typedef struct
-	TIFFPredictorState predict;
+{
-        lzma_stream	stream;
+    TIFFPredictorState predict;
-	lzma_filter	filters[LZMA_FILTERS_MAX + 1];
+    lzma_stream stream;
-	lzma_options_delta opt_delta;		/* delta filter options */
+    lzma_filter filters[LZMA_FILTERS_MAX + 1];
-	lzma_options_lzma opt_lzma;		/* LZMA2 filter options */
+    lzma_options_delta opt_delta; /* delta filter options */
-	int             preset;			/* compression level */
+    lzma_options_lzma opt_lzma;   /* LZMA2 filter options */
-	lzma_check	check;			/* type of the integrity check */
+    int preset;                   /* compression level */
-	int             state;			/* state flags */
+    lzma_check check;             /* type of the integrity check */
+    int state;                    /* state flags */
 #define LSTATE_INIT_DECODE 0x01
 #define LSTATE_INIT_ENCODE 0x02
 
-	TIFFVGetMethod  vgetparent;            /* super-class method */
+    TIFFVGetMethod vgetparent; /* super-class method */
-	TIFFVSetMethod  vsetparent;            /* super-class method */
+    TIFFVSetMethod vsetparent; /* super-class method */
 } LZMAState;
 
-#define LState(tif)             ((LZMAState*) (tif)->tif_data)
+#define LState(tif) ((LZMAState *)(tif)->tif_data)
-#define DecoderState(tif)       LState(tif)
+#define DecoderState(tif) LState(tif)
-#define EncoderState(tif)       LState(tif)
+#define EncoderState(tif) LState(tif)
 
-static int LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
+static int LZMAEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
-static int LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
+static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
 
-static const char *
+static const char *LZMAStrerror(lzma_ret ret)
-LZMAStrerror(lzma_ret ret)
 {
-	switch (ret) {
+    switch (ret)
-		case LZMA_OK:
+    {
-		    return "operation completed successfully";
+        case LZMA_OK:
-		case LZMA_STREAM_END:
+            return "operation completed successfully";
-		    return "end of stream was reached";
+        case LZMA_STREAM_END:
-		case LZMA_NO_CHECK:
+            return "end of stream was reached";
-		    return "input stream has no integrity check";
+        case LZMA_NO_CHECK:
-		case LZMA_UNSUPPORTED_CHECK:
+            return "input stream has no integrity check";
-		    return "cannot calculate the integrity check";
+        case LZMA_UNSUPPORTED_CHECK:
-		case LZMA_GET_CHECK:
+            return "cannot calculate the integrity check";
-		    return "integrity check type is now available";
+        case LZMA_GET_CHECK:
-		case LZMA_MEM_ERROR:
+            return "integrity check type is now available";
-		    return "cannot allocate memory";
+        case LZMA_MEM_ERROR:
-		case LZMA_MEMLIMIT_ERROR:
+            return "cannot allocate memory";
-		    return "memory usage limit was reached";
+        case LZMA_MEMLIMIT_ERROR:
-		case LZMA_FORMAT_ERROR:
+            return "memory usage limit was reached";
-		    return "file format not recognized";
+        case LZMA_FORMAT_ERROR:
-		case LZMA_OPTIONS_ERROR:
+            return "file format not recognized";
-		    return "invalid or unsupported options";
+        case LZMA_OPTIONS_ERROR:
-		case LZMA_DATA_ERROR:
+            return "invalid or unsupported options";
-		    return "data is corrupt";
+        case LZMA_DATA_ERROR:
-		case LZMA_BUF_ERROR:
+            return "data is corrupt";
-		    return "no progress is possible (stream is truncated or corrupt)";
+        case LZMA_BUF_ERROR:
-		case LZMA_PROG_ERROR:
+            return "no progress is possible (stream is truncated or corrupt)";
-		    return "programming error";
+        case LZMA_PROG_ERROR:
-		default:
+            return "programming error";
-		    return "unidentified liblzma error";
+        default:
-	}
+            return "unidentified liblzma error";
+    }
 }
 
-static int
+static int LZMAFixupTags(TIFF *tif)
-LZMAFixupTags(TIFF* tif)
 {
-	(void) tif;
+    (void)tif;
-	return 1;
+    return 1;
 }
 
-static int
+static int LZMASetupDecode(TIFF *tif)
-LZMASetupDecode(TIFF* tif)
 {
-	LZMAState* sp = DecoderState(tif);
+    LZMAState *sp = DecoderState(tif);
 
-	assert(sp != NULL);
+    assert(sp != NULL);
 
-        /* if we were last encoding, terminate this mode */
+    /* if we were last encoding, terminate this mode */
-	if (sp->state & LSTATE_INIT_ENCODE) {
+    if (sp->state & LSTATE_INIT_ENCODE)
-	    lzma_end(&sp->stream);
+    {
-	    sp->state = 0;
+        lzma_end(&sp->stream);
-	}
+        sp->state = 0;
+    }
 
-	sp->state |= LSTATE_INIT_DECODE;
+    sp->state |= LSTATE_INIT_DECODE;
-	return 1;
+    return 1;
 }
 
 /*
  * Setup state for decoding a strip.
  */
-static int
+static int LZMAPreDecode(TIFF *tif, uint16_t s)
-LZMAPreDecode(TIFF* tif, uint16 s)
 {
-	static const char module[] = "LZMAPreDecode";
+    static const char module[] = "LZMAPreDecode";
-	LZMAState* sp = DecoderState(tif);
+    LZMAState *sp = DecoderState(tif);
-	lzma_ret ret;
+    lzma_ret ret;
 
-	(void) s;
+    (void)s;
-	assert(sp != NULL);
+    assert(sp != NULL);
 
-	if( (sp->state & LSTATE_INIT_DECODE) == 0 )
+    if ((sp->state & LSTATE_INIT_DECODE) == 0)
-            tif->tif_setupdecode(tif);
+        tif->tif_setupdecode(tif);
 
-	sp->stream.next_in = tif->tif_rawdata;
+    sp->stream.next_in = tif->tif_rawdata;
-	sp->stream.avail_in = (size_t) tif->tif_rawcc;
+    sp->stream.avail_in = (size_t)tif->tif_rawcc;
-	if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc) {
+    if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)
-		TIFFErrorExt(tif->tif_clientdata, module,
+    {
-			     "Liblzma cannot deal with buffers this size");
+        TIFFErrorExtR(tif, module,
-		return 0;
+                      "Liblzma cannot deal with buffers this size");
-	}
+        return 0;
+    }
 
-	/*
+    /*
-	 * Disable memory limit when decoding. UINT64_MAX is a flag to disable
+     * Disable memory limit when decoding. UINT64_MAX is a flag to disable
-	 * the limit, we are passing (uint64_t)-1 which should be the same.
+     * the limit, we are passing (uint64_t)-1 which should be the same.
-	 */
+     */
-	ret = lzma_stream_decoder(&sp->stream, (uint64_t)-1, 0);
+    ret = lzma_stream_decoder(&sp->stream, (uint64_t)-1, 0);
-	if (ret != LZMA_OK) {
+    if (ret != LZMA_OK)
-		TIFFErrorExt(tif->tif_clientdata, module,
+    {
-			     "Error initializing the stream decoder, %s",
+        TIFFErrorExtR(tif, module, "Error initializing the stream decoder, %s",
-			     LZMAStrerror(ret));
+                      LZMAStrerror(ret));
-		return 0;
+        return 0;
-	}
+    }
-	return 1;
+    return 1;
 }
 
-static int
+static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
-LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 {
-	static const char module[] = "LZMADecode";
+    static const char module[] = "LZMADecode";
-	LZMAState* sp = DecoderState(tif);
+    LZMAState *sp = DecoderState(tif);
 
-	(void) s;
+    (void)s;
-	assert(sp != NULL);
+    assert(sp != NULL);
-	assert(sp->state == LSTATE_INIT_DECODE);
+    assert(sp->state == LSTATE_INIT_DECODE);
 
-        sp->stream.next_in = tif->tif_rawcp;
+    sp->stream.next_in = tif->tif_rawcp;
-        sp->stream.avail_in = (size_t) tif->tif_rawcc;
+    sp->stream.avail_in = (size_t)tif->tif_rawcc;
 
-	sp->stream.next_out = op;
+    sp->stream.next_out = op;
-	sp->stream.avail_out = (size_t) occ;
+    sp->stream.avail_out = (size_t)occ;
-	if ((tmsize_t)sp->stream.avail_out != occ) {
+    if ((tmsize_t)sp->stream.avail_out != occ)
-		TIFFErrorExt(tif->tif_clientdata, module,
+    {
-			     "Liblzma cannot deal with buffers this size");
+        TIFFErrorExtR(tif, module,
-		return 0;
+                      "Liblzma cannot deal with buffers this size");
-	}
+        return 0;
+    }
 
-	do {
+    do
-		/*
+    {
-		 * Save the current stream state to properly recover from the
+        /*
-		 * decoding errors later.
+         * Save the current stream state to properly recover from the
-		 */
+         * decoding errors later.
-		const uint8_t *next_in = sp->stream.next_in;
+         */
-		size_t avail_in = sp->stream.avail_in;
+        const uint8_t *next_in = sp->stream.next_in;
+        size_t avail_in = sp->stream.avail_in;
 
-		lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
+        lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
-		if (ret == LZMA_STREAM_END)
+        if (ret == LZMA_STREAM_END)
-			break;
+            break;
-		if (ret == LZMA_MEMLIMIT_ERROR) {
+        if (ret == LZMA_MEMLIMIT_ERROR)
-			lzma_ret r = lzma_stream_decoder(&sp->stream,
+        {
-							 lzma_memusage(&sp->stream), 0);
+            lzma_ret r =
-			if (r != LZMA_OK) {
+                lzma_stream_decoder(&sp->stream, lzma_memusage(&sp->stream), 0);
-				TIFFErrorExt(tif->tif_clientdata, module,
+            if (r != LZMA_OK)
-					     "Error initializing the stream decoder, %s",
+            {
-					     LZMAStrerror(r));
+                TIFFErrorExtR(tif, module,
-				break;
+                              "Error initializing the stream decoder, %s",
-			}
+                              LZMAStrerror(r));
-			sp->stream.next_in = next_in;
+                break;
-			sp->stream.avail_in = avail_in;
+            }
-			continue;
+            sp->stream.next_in = next_in;
-		}
+            sp->stream.avail_in = avail_in;
-		if (ret != LZMA_OK) {
+            continue;
-			TIFFErrorExt(tif->tif_clientdata, module,
+        }
-			    "Decoding error at scanline %lu, %s",
+        if (ret != LZMA_OK)
-			    (unsigned long) tif->tif_row, LZMAStrerror(ret));
+        {
-			break;
+            TIFFErrorExtR(tif, module,
-		}
+                          "Decoding error at scanline %" PRIu32 ", %s",
-	} while (sp->stream.avail_out > 0);
+                          tif->tif_row, LZMAStrerror(ret));
-	if (sp->stream.avail_out != 0) {
+            break;
-		TIFFErrorExt(tif->tif_clientdata, module,
+        }
-		    "Not enough data at scanline %lu (short %lu bytes)",
+    } while (sp->stream.avail_out > 0);
-		    (unsigned long) tif->tif_row, (unsigned long) sp->stream.avail_out);
+    if (sp->stream.avail_out != 0)
-		return 0;
+    {
-	}
+        TIFFErrorExtR(tif, module,
+                      "Not enough data at scanline %" PRIu32
+                      " (short %" TIFF_SIZE_FORMAT " bytes)",
+                      tif->tif_row, sp->stream.avail_out);
+        return 0;
+    }
 
-        tif->tif_rawcp = (uint8 *)sp->stream.next_in; /* cast away const */
+    tif->tif_rawcp = (uint8_t *)sp->stream.next_in; /* cast away const */
-        tif->tif_rawcc = sp->stream.avail_in;
+    tif->tif_rawcc = sp->stream.avail_in;
 
-	return 1;
+    return 1;
 }
 
-static int
+static int LZMASetupEncode(TIFF *tif)
-LZMASetupEncode(TIFF* tif)
 {
-	LZMAState* sp = EncoderState(tif);
+    LZMAState *sp = EncoderState(tif);
 
-	assert(sp != NULL);
+    assert(sp != NULL);
-	if (sp->state & LSTATE_INIT_DECODE) {
+    if (sp->state & LSTATE_INIT_DECODE)
-		lzma_end(&sp->stream);
+    {
-		sp->state = 0;
+        lzma_end(&sp->stream);
-	}
+        sp->state = 0;
+    }
 
-	sp->state |= LSTATE_INIT_ENCODE;
+    sp->state |= LSTATE_INIT_ENCODE;
-	return 1;
+    return 1;
 }
 
 /*
  * Reset encoding state at the start of a strip.
  */
-static int
+static int LZMAPreEncode(TIFF *tif, uint16_t s)
-LZMAPreEncode(TIFF* tif, uint16 s)
 {
-	static const char module[] = "LZMAPreEncode";
+    static const char module[] = "LZMAPreEncode";
-	LZMAState *sp = EncoderState(tif);
+    LZMAState *sp = EncoderState(tif);
-	lzma_ret ret;
+    lzma_ret ret;
 
-	(void) s;
+    (void)s;
-	assert(sp != NULL);
+    assert(sp != NULL);
-	if( sp->state != LSTATE_INIT_ENCODE )
+    if (sp->state != LSTATE_INIT_ENCODE)
-            tif->tif_setupencode(tif);
+        tif->tif_setupencode(tif);
 
-	sp->stream.next_out = tif->tif_rawdata;
+    sp->stream.next_out = tif->tif_rawdata;
-	sp->stream.avail_out = (size_t)tif->tif_rawdatasize;
+    sp->stream.avail_out = (size_t)tif->tif_rawdatasize;
-	if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) {
+    if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
-		TIFFErrorExt(tif->tif_clientdata, module,
+    {
-			     "Liblzma cannot deal with buffers this size");
+        TIFFErrorExtR(tif, module,
-		return 0;
+                      "Liblzma cannot deal with buffers this size");
-	}
+        return 0;
-	ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
+    }
-	if (ret != LZMA_OK) {
+    ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
-		TIFFErrorExt(tif->tif_clientdata, module,
+    if (ret != LZMA_OK)
-			"Error in lzma_stream_encoder(): %s", LZMAStrerror(ret));
+    {
-		return 0;
+        TIFFErrorExtR(tif, module, "Error in lzma_stream_encoder(): %s",
-	}
+                      LZMAStrerror(ret));
-	return 1;
+        return 0;
+    }
+    return 1;
 }
 
 /*
  * Encode a chunk of pixels.
  */
-static int
+static int LZMAEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
-LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 {
-	static const char module[] = "LZMAEncode";
+    static const char module[] = "LZMAEncode";
-	LZMAState *sp = EncoderState(tif);
+    LZMAState *sp = EncoderState(tif);
 
-	assert(sp != NULL);
+    assert(sp != NULL);
-	assert(sp->state == LSTATE_INIT_ENCODE);
+    assert(sp->state == LSTATE_INIT_ENCODE);
 
-	(void) s;
+    (void)s;
-	sp->stream.next_in = bp;
+    sp->stream.next_in = bp;
-	sp->stream.avail_in = (size_t) cc;
+    sp->stream.avail_in = (size_t)cc;
-	if ((tmsize_t)sp->stream.avail_in != cc) {
+    if ((tmsize_t)sp->stream.avail_in != cc)
-		TIFFErrorExt(tif->tif_clientdata, module,
+    {
-			     "Liblzma cannot deal with buffers this size");
+        TIFFErrorExtR(tif, module,
-		return 0;
+                      "Liblzma cannot deal with buffers this size");
-	}
+        return 0;
-	do {
+    }
-		lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
+    do
-		if (ret != LZMA_OK) {
+    {
-			TIFFErrorExt(tif->tif_clientdata, module,
+        lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
-				"Encoding error at scanline %lu, %s",
+        if (ret != LZMA_OK)
-				(unsigned long) tif->tif_row, LZMAStrerror(ret));
+        {
-			return 0;
+            TIFFErrorExtR(tif, module,
-		}
+                          "Encoding error at scanline %" PRIu32 ", %s",
-		if (sp->stream.avail_out == 0) {
+                          tif->tif_row, LZMAStrerror(ret));
-			tif->tif_rawcc = tif->tif_rawdatasize;
+            return 0;
-			if (!TIFFFlushData1(tif))
+        }
-				return 0;
+        if (sp->stream.avail_out == 0)
-			sp->stream.next_out = tif->tif_rawdata;
+        {
-			sp->stream.avail_out = (size_t)tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in LZMAPreEncode */
+            tif->tif_rawcc = tif->tif_rawdatasize;
-		}
+            if (!TIFFFlushData1(tif))
-	} while (sp->stream.avail_in > 0);
+                return 0;
-	return 1;
+            sp->stream.next_out = tif->tif_rawdata;
+            sp->stream.avail_out =
+                (size_t)
+                    tif->tif_rawdatasize; /* this is a safe typecast, as check
+                                             is made already in LZMAPreEncode */
+        }
+    } while (sp->stream.avail_in > 0);
+    return 1;
 }
 
 /*
  * Finish off an encoded strip by flushing the last
  * string and tacking on an End Of Information code.
  */
-static int
+static int LZMAPostEncode(TIFF *tif)
-LZMAPostEncode(TIFF* tif)
 {
-	static const char module[] = "LZMAPostEncode";
+    static const char module[] = "LZMAPostEncode";
-	LZMAState *sp = EncoderState(tif);
+    LZMAState *sp = EncoderState(tif);
-	lzma_ret ret;
+    lzma_ret ret;
 
-	sp->stream.avail_in = 0;
+    sp->stream.avail_in = 0;
-	do {
+    do
-		ret = lzma_code(&sp->stream, LZMA_FINISH);
+    {
-		switch (ret) {
+        ret = lzma_code(&sp->stream, LZMA_FINISH);
-		case LZMA_STREAM_END:
+        switch (ret)
-		case LZMA_OK:
+        {
-			if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) {
+            case LZMA_STREAM_END:
-				tif->tif_rawcc =
+            case LZMA_OK:
-					tif->tif_rawdatasize - sp->stream.avail_out;
+                if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
-				if (!TIFFFlushData1(tif))
+                {
-					return 0;
+                    tif->tif_rawcc =
-				sp->stream.next_out = tif->tif_rawdata;
+                        tif->tif_rawdatasize - sp->stream.avail_out;
-				sp->stream.avail_out = (size_t)tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in ZIPPreEncode */
+                    if (!TIFFFlushData1(tif))
-			}
+                        return 0;
-			break;
+                    sp->stream.next_out = tif->tif_rawdata;
-		default:
+                    sp->stream.avail_out =
-			TIFFErrorExt(tif->tif_clientdata, module, "Liblzma error: %s",
+                        (size_t)
-				     LZMAStrerror(ret));
+                            tif->tif_rawdatasize; /* this is a safe typecast, as
-			return 0;
+                                                     check is made already in
-		}
+                                                     ZIPPreEncode */
-	} while (ret != LZMA_STREAM_END);
+                }
-	return 1;
+                break;
+            default:
+                TIFFErrorExtR(tif, module, "Liblzma error: %s",
+                              LZMAStrerror(ret));
+                return 0;
+        }
+    } while (ret != LZMA_STREAM_END);
+    return 1;
 }
 
-static void
+static void LZMACleanup(TIFF *tif)
-LZMACleanup(TIFF* tif)
 {
-	LZMAState* sp = LState(tif);
+    LZMAState *sp = LState(tif);
 
-	assert(sp != 0);
+    assert(sp != 0);
 
-	(void)TIFFPredictorCleanup(tif);
+    (void)TIFFPredictorCleanup(tif);
 
-	tif->tif_tagmethods.vgetfield = sp->vgetparent;
+    tif->tif_tagmethods.vgetfield = sp->vgetparent;
-	tif->tif_tagmethods.vsetfield = sp->vsetparent;
+    tif->tif_tagmethods.vsetfield = sp->vsetparent;
 
-	if (sp->state) {
+    if (sp->state)
-		lzma_end(&sp->stream);
+    {
-		sp->state = 0;
+        lzma_end(&sp->stream);
-	}
+        sp->state = 0;
-	_TIFFfree(sp);
+    }
-	tif->tif_data = NULL;
+    _TIFFfreeExt(tif, sp);
+    tif->tif_data = NULL;
 
-	_TIFFSetDefaultCompressionState(tif);
+    _TIFFSetDefaultCompressionState(tif);
 }
 
-static int
+static int LZMAVSetField(TIFF *tif, uint32_t tag, va_list ap)
-LZMAVSetField(TIFF* tif, uint32 tag, va_list ap)
 {
-	static const char module[] = "LZMAVSetField";
+    static const char module[] = "LZMAVSetField";
-	LZMAState* sp = LState(tif);
+    LZMAState *sp = LState(tif);
 
-	switch (tag) {
+    switch (tag)
-	case TIFFTAG_LZMAPRESET:
+    {
-		sp->preset = (int) va_arg(ap, int);
+        case TIFFTAG_LZMAPRESET:
-		lzma_lzma_preset(&sp->opt_lzma, sp->preset);
+            sp->preset = (int)va_arg(ap, int);
-		if (sp->state & LSTATE_INIT_ENCODE) {
+            lzma_lzma_preset(&sp->opt_lzma, sp->preset);
-			lzma_ret ret = lzma_stream_encoder(&sp->stream,
+            if (sp->state & LSTATE_INIT_ENCODE)
-							   sp->filters,
+            {
-							   sp->check);
+                lzma_ret ret =
-			if (ret != LZMA_OK) {
+                    lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
-				TIFFErrorExt(tif->tif_clientdata, module,
+                if (ret != LZMA_OK)
-					     "Liblzma error: %s",
+                {
-					     LZMAStrerror(ret));
+                    TIFFErrorExtR(tif, module, "Liblzma error: %s",
-			}
+                                  LZMAStrerror(ret));
-		}
+                }
-		return 1;
+            }
-	default:
+            return 1;
-		return (*sp->vsetparent)(tif, tag, ap);
+        default:
-	}
+            return (*sp->vsetparent)(tif, tag, ap);
-	/*NOTREACHED*/
+    }
+    /*NOTREACHED*/
 }
 
-static int
+static int LZMAVGetField(TIFF *tif, uint32_t tag, va_list ap)
-LZMAVGetField(TIFF* tif, uint32 tag, va_list ap)
 {
-	LZMAState* sp = LState(tif);
+    LZMAState *sp = LState(tif);
 
-	switch (tag) {
+    switch (tag)
-	case TIFFTAG_LZMAPRESET:
+    {
-		*va_arg(ap, int*) = sp->preset;
+        case TIFFTAG_LZMAPRESET:
-		break;
+            *va_arg(ap, int *) = sp->preset;
-	default:
+            break;
-		return (*sp->vgetparent)(tif, tag, ap);
+        default:
-	}
+            return (*sp->vgetparent)(tif, tag, ap);
-	return 1;
+    }
+    return 1;
 }
 
 static const TIFFField lzmaFields[] = {
-	{ TIFFTAG_LZMAPRESET, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED,
+    {TIFFTAG_LZMAPRESET, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
-		FIELD_PSEUDO, TRUE, FALSE, "LZMA2 Compression Preset", NULL },
+     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE,
+     "LZMA2 Compression Preset", NULL},
 };
 
-int
+int TIFFInitLZMA(TIFF *tif, int scheme)
-TIFFInitLZMA(TIFF* tif, int scheme)
 {
-	static const char module[] = "TIFFInitLZMA";
+    static const char module[] = "TIFFInitLZMA";
-	LZMAState* sp;
+    LZMAState *sp;
-	lzma_stream tmp_stream = LZMA_STREAM_INIT;
+    lzma_stream tmp_stream = LZMA_STREAM_INIT;
 
-        (void)scheme;
+    (void)scheme;
-	assert( scheme == COMPRESSION_LZMA );
+    assert(scheme == COMPRESSION_LZMA);
 
-	/*
+    /*
-	 * Merge codec-specific tag information.
+     * Merge codec-specific tag information.
-	 */
+     */
-	if (!_TIFFMergeFields(tif, lzmaFields, TIFFArrayCount(lzmaFields))) {
+    if (!_TIFFMergeFields(tif, lzmaFields, TIFFArrayCount(lzmaFields)))
-		TIFFErrorExt(tif->tif_clientdata, module,
+    {
-			     "Merging LZMA2 codec-specific tags failed");
+        TIFFErrorExtR(tif, module, "Merging LZMA2 codec-specific tags failed");
-		return 0;
+        return 0;
-	}
+    }
 
-	/*
+    /*
-	 * Allocate state block so tag methods have storage to record values.
+     * Allocate state block so tag methods have storage to record values.
-	 */
+     */
-	tif->tif_data = (uint8*) _TIFFmalloc(sizeof(LZMAState));
+    tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(LZMAState));
-	if (tif->tif_data == NULL)
+    if (tif->tif_data == NULL)
-		goto bad;
+        goto bad;
-	sp = LState(tif);
+    sp = LState(tif);
-	memcpy(&sp->stream, &tmp_stream, sizeof(lzma_stream));
+    memcpy(&sp->stream, &tmp_stream, sizeof(lzma_stream));
 
-	/*
+    /*
-	 * Override parent get/set field methods.
+     * Override parent get/set field methods.
-	 */
+     */
-	sp->vgetparent = tif->tif_tagmethods.vgetfield;
+    sp->vgetparent = tif->tif_tagmethods.vgetfield;
-	tif->tif_tagmethods.vgetfield = LZMAVGetField;	/* hook for codec tags */
+    tif->tif_tagmethods.vgetfield = LZMAVGetField; /* hook for codec tags */
-	sp->vsetparent = tif->tif_tagmethods.vsetfield;
+    sp->vsetparent = tif->tif_tagmethods.vsetfield;
-	tif->tif_tagmethods.vsetfield = LZMAVSetField;	/* hook for codec tags */
+    tif->tif_tagmethods.vsetfield = LZMAVSetField; /* hook for codec tags */
 
-	/* Default values for codec-specific fields */
+    /* Default values for codec-specific fields */
-	sp->preset = LZMA_PRESET_DEFAULT;		/* default comp. level */
+    sp->preset = LZMA_PRESET_DEFAULT; /* default comp. level */
-	sp->check = LZMA_CHECK_NONE;
+    sp->check = LZMA_CHECK_NONE;
-	sp->state = 0;
+    sp->state = 0;
 
-	/* Data filters. So far we are using delta and LZMA2 filters only. */
+    /* Data filters. So far we are using delta and LZMA2 filters only. */
-	sp->opt_delta.type = LZMA_DELTA_TYPE_BYTE;
+    sp->opt_delta.type = LZMA_DELTA_TYPE_BYTE;
-	/*
+    /*
-	 * The sample size in bytes seems to be reasonable distance for delta
+     * The sample size in bytes seems to be reasonable distance for delta
-	 * filter.
+     * filter.
-	 */
+     */
-	sp->opt_delta.dist = (tif->tif_dir.td_bitspersample % 8) ?
+    sp->opt_delta.dist = (tif->tif_dir.td_bitspersample % 8)
-		1 : tif->tif_dir.td_bitspersample / 8;
+                             ? 1
-	sp->filters[0].id = LZMA_FILTER_DELTA;
+                             : tif->tif_dir.td_bitspersample / 8;
-	sp->filters[0].options = &sp->opt_delta;
+    sp->filters[0].id = LZMA_FILTER_DELTA;
+    sp->filters[0].options = &sp->opt_delta;
 
-	lzma_lzma_preset(&sp->opt_lzma, sp->preset);
+    lzma_lzma_preset(&sp->opt_lzma, sp->preset);
-	sp->filters[1].id = LZMA_FILTER_LZMA2;
+    sp->filters[1].id = LZMA_FILTER_LZMA2;
-	sp->filters[1].options = &sp->opt_lzma;
+    sp->filters[1].options = &sp->opt_lzma;
 
-	sp->filters[2].id = LZMA_VLI_UNKNOWN;
+    sp->filters[2].id = LZMA_VLI_UNKNOWN;
-	sp->filters[2].options = NULL;
+    sp->filters[2].options = NULL;
 
-	/*
+    /*
-	 * Install codec methods.
+     * Install codec methods.
-	 */
+     */
-	tif->tif_fixuptags = LZMAFixupTags;
+    tif->tif_fixuptags = LZMAFixupTags;
-	tif->tif_setupdecode = LZMASetupDecode;
+    tif->tif_setupdecode = LZMASetupDecode;
-	tif->tif_predecode = LZMAPreDecode;
+    tif->tif_predecode = LZMAPreDecode;
-	tif->tif_decoderow = LZMADecode;
+    tif->tif_decoderow = LZMADecode;
-	tif->tif_decodestrip = LZMADecode;
+    tif->tif_decodestrip = LZMADecode;
-	tif->tif_decodetile = LZMADecode;
+    tif->tif_decodetile = LZMADecode;
-	tif->tif_setupencode = LZMASetupEncode;
+    tif->tif_setupencode = LZMASetupEncode;
-	tif->tif_preencode = LZMAPreEncode;
+    tif->tif_preencode = LZMAPreEncode;
-	tif->tif_postencode = LZMAPostEncode;
+    tif->tif_postencode = LZMAPostEncode;
-	tif->tif_encoderow = LZMAEncode;
+    tif->tif_encoderow = LZMAEncode;
-	tif->tif_encodestrip = LZMAEncode;
+    tif->tif_encodestrip = LZMAEncode;
-	tif->tif_encodetile = LZMAEncode;
+    tif->tif_encodetile = LZMAEncode;
-	tif->tif_cleanup = LZMACleanup;
+    tif->tif_cleanup = LZMACleanup;
-	/*
+    /*
-	 * Setup predictor setup.
+     * Setup predictor setup.
-	 */
+     */
-	(void) TIFFPredictorInit(tif);
+    (void)TIFFPredictorInit(tif);
-	return 1;
+    return 1;
 bad:
-	TIFFErrorExt(tif->tif_clientdata, module,
+    TIFFErrorExtR(tif, module, "No space for LZMA2 state block");
-		     "No space for LZMA2 state block");
+    return 0;
-	return 0;
 }
 #endif /* LZMA_SUPPORT */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */

3rdparty/libtiff/tif_next.c

@@ -30,158 +30,165 @@
  * NeXT 2-bit Grey Scale Compression Algorithm Support
  */
 
-#define SETPIXEL(op, v) {			\
+#define SETPIXEL(op, v)                                                        \
-	switch (npixels++ & 3) {		\
+    {                                                                          \
-	case 0:	op[0]  = (unsigned char) ((v) << 6); break;	\
+        switch (npixels++ & 3)                                                 \
-	case 1:	op[0] |= (v) << 4; break;	\
+        {                                                                      \
-	case 2:	op[0] |= (v) << 2; break;	\
+            case 0:                                                            \
-	case 3:	*op++ |= (v);	   op_offset++; break;	\
+                op[0] = (unsigned char)((v) << 6);                             \
-	}					\
+                break;                                                         \
-}
+            case 1:                                                            \
+                op[0] |= (v) << 4;                                             \
+                break;                                                         \
+            case 2:                                                            \
+                op[0] |= (v) << 2;                                             \
+                break;                                                         \
+            case 3:                                                            \
+                *op++ |= (v);                                                  \
+                op_offset++;                                                   \
+                break;                                                         \
+        }                                                                      \
+    }
 
-#define LITERALROW	0x00
+#define LITERALROW 0x00
-#define LITERALSPAN	0x40
+#define LITERALSPAN 0x40
-#define WHITE   	((1<<2)-1)
+#define WHITE ((1 << 2) - 1)
 
-static int
+static int NeXTDecode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
-NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
 {
-	static const char module[] = "NeXTDecode";
+    static const char module[] = "NeXTDecode";
-	unsigned char *bp, *op;
+    unsigned char *bp, *op;
-	tmsize_t cc;
+    tmsize_t cc;
-	uint8* row;
+    uint8_t *row;
-	tmsize_t scanline, n;
+    tmsize_t scanline, n;
 
-	(void) s;
+    (void)s;
-	/*
+    /*
-	 * Each scanline is assumed to start off as all
+     * Each scanline is assumed to start off as all
-	 * white (we assume a PhotometricInterpretation
+     * white (we assume a PhotometricInterpretation
-	 * of ``min-is-black'').
+     * of ``min-is-black'').
-	 */
+     */
-	for (op = (unsigned char*) buf, cc = occ; cc-- > 0;)
+    for (op = (unsigned char *)buf, cc = occ; cc-- > 0;)
-		*op++ = 0xff;
+        *op++ = 0xff;
 
-	bp = (unsigned char *)tif->tif_rawcp;
+    bp = (unsigned char *)tif->tif_rawcp;
-	cc = tif->tif_rawcc;
+    cc = tif->tif_rawcc;
-	scanline = tif->tif_scanlinesize;
+    scanline = tif->tif_scanlinesize;
-	if (occ % scanline)
+    if (occ % scanline)
-	{
+    {
-		TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
+        TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
-		return (0);
+        return (0);
-	}
+    }
-	for (row = buf; cc > 0 && occ > 0; occ -= scanline, row += scanline) {
+    for (row = buf; cc > 0 && occ > 0; occ -= scanline, row += scanline)
-		n = *bp++;
+    {
-		cc--;
+        n = *bp++;
-		switch (n) {
+        cc--;
-		case LITERALROW:
+        switch (n)
-			/*
+        {
-			 * The entire scanline is given as literal values.
+            case LITERALROW:
-			 */
+                /*
-			if (cc < scanline)
+                 * The entire scanline is given as literal values.
-				goto bad;
+                 */
-			_TIFFmemcpy(row, bp, scanline);
+                if (cc < scanline)
-			bp += scanline;
+                    goto bad;
-			cc -= scanline;
+                _TIFFmemcpy(row, bp, scanline);
-			break;
+                bp += scanline;
-		case LITERALSPAN: {
+                cc -= scanline;
-			tmsize_t off;
+                break;
-			/*
+            case LITERALSPAN:
-			 * The scanline has a literal span that begins at some
+            {
-			 * offset.
+                tmsize_t off;
-			 */
+                /*
-			if( cc < 4 )
+                 * The scanline has a literal span that begins at some
-				goto bad;
+                 * offset.
-			off = (bp[0] * 256) + bp[1];
+                 */
-			n = (bp[2] * 256) + bp[3];
+                if (cc < 4)
-			if (cc < 4+n || off+n > scanline)
+                    goto bad;
-				goto bad;
+                off = (bp[0] * 256) + bp[1];
-			_TIFFmemcpy(row+off, bp+4, n);
+                n = (bp[2] * 256) + bp[3];
-			bp += 4+n;
+                if (cc < 4 + n || off + n > scanline)
-			cc -= 4+n;
+                    goto bad;
-			break;
+                _TIFFmemcpy(row + off, bp + 4, n);
-		}
+                bp += 4 + n;
-		default: {
+                cc -= 4 + n;
-			uint32 npixels = 0, grey;
+                break;
-			tmsize_t op_offset = 0;
+            }
-			uint32 imagewidth = tif->tif_dir.td_imagewidth;
+            default:
-            if( isTiled(tif) )
+            {
-                imagewidth = tif->tif_dir.td_tilewidth;
+                uint32_t npixels = 0, grey;
+                tmsize_t op_offset = 0;
+                uint32_t imagewidth = tif->tif_dir.td_imagewidth;
+                if (isTiled(tif))
+                    imagewidth = tif->tif_dir.td_tilewidth;
 
-			/*
+                /*
-			 * The scanline is composed of a sequence of constant
+                 * The scanline is composed of a sequence of constant
-			 * color ``runs''.  We shift into ``run mode'' and
+                 * color ``runs''.  We shift into ``run mode'' and
-			 * interpret bytes as codes of the form
+                 * interpret bytes as codes of the form
-			 * <color><npixels> until we've filled the scanline.
+                 * <color><npixels> until we've filled the scanline.
-			 */
+                 */
-			op = row;
+                op = row;
-			for (;;) {
+                for (;;)
-				grey = (uint32)((n>>6) & 0x3);
+                {
-				n &= 0x3f;
+                    grey = (uint32_t)((n >> 6) & 0x3);
-				/*
+                    n &= 0x3f;
-				 * Ensure the run does not exceed the scanline
+                    /*
-				 * bounds, potentially resulting in a security
+                     * Ensure the run does not exceed the scanline
-				 * issue.
+                     * bounds, potentially resulting in a security
-				 */
+                     * issue.
-				while (n-- > 0 && npixels < imagewidth && op_offset < scanline)
+                     */
-					SETPIXEL(op, grey);
+                    while (n-- > 0 && npixels < imagewidth &&
-				if (npixels >= imagewidth)
+                           op_offset < scanline)
-					break;
+                        SETPIXEL(op, grey);
-                if (op_offset >= scanline ) {
+                    if (npixels >= imagewidth)
-                    TIFFErrorExt(tif->tif_clientdata, module, "Invalid data for scanline %ld",
+                        break;
-                        (long) tif->tif_row);
+                    if (op_offset >= scanline)
-                    return (0);
+                    {
+                        TIFFErrorExtR(tif, module,
+                                      "Invalid data for scanline %" PRIu32,
+                                      tif->tif_row);
+                        return (0);
+                    }
+                    if (cc == 0)
+                        goto bad;
+                    n = *bp++;
+                    cc--;
                 }
-				if (cc == 0)
+                break;
-					goto bad;
+            }
-				n = *bp++;
+        }
-				cc--;
+    }
-			}
+    tif->tif_rawcp = (uint8_t *)bp;
-			break;
+    tif->tif_rawcc = cc;
-		}
+    return (1);
-		}
-	}
-	tif->tif_rawcp = (uint8*) bp;
-	tif->tif_rawcc = cc;
-	return (1);
 bad:
-	TIFFErrorExt(tif->tif_clientdata, module, "Not enough data for scanline %ld",
+    TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
-	    (long) tif->tif_row);
+                  tif->tif_row);
-	return (0);
+    return (0);
 }
 
-static int
+static int NeXTPreDecode(TIFF *tif, uint16_t s)
-NeXTPreDecode(TIFF* tif, uint16 s)
 {
-	static const char module[] = "NeXTPreDecode";
+    static const char module[] = "NeXTPreDecode";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	(void)s;
+    (void)s;
 
-	if( td->td_bitspersample != 2 )
+    if (td->td_bitspersample != 2)
-	{
+    {
-		TIFFErrorExt(tif->tif_clientdata, module, "Unsupported BitsPerSample = %d",
+        TIFFErrorExtR(tif, module, "Unsupported BitsPerSample = %" PRIu16,
-					 td->td_bitspersample);
+                      td->td_bitspersample);
-		return (0);
+        return (0);
-	}
+    }
-	return (1);
+    return (1);
 }
 
-int
+int TIFFInitNeXT(TIFF *tif, int scheme)
-TIFFInitNeXT(TIFF* tif, int scheme)
 {
-	(void) scheme;
+    (void)scheme;
-	tif->tif_predecode = NeXTPreDecode;  
+    tif->tif_predecode = NeXTPreDecode;
-	tif->tif_decoderow = NeXTDecode;  
+    tif->tif_decoderow = NeXTDecode;
-	tif->tif_decodestrip = NeXTDecode;  
+    tif->tif_decodestrip = NeXTDecode;
-	tif->tif_decodetile = NeXTDecode;
+    tif->tif_decodetile = NeXTDecode;
-	return (1);
+    return (1);
 }
 #endif /* NEXT_SUPPORT */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_packbits.c

@@ -31,157 +31,178 @@
  */
 #include <stdio.h>
 
-static int
+static int PackBitsPreEncode(TIFF *tif, uint16_t s)
-PackBitsPreEncode(TIFF* tif, uint16 s)
 {
-	(void) s;
+    (void)s;
 
-        tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t));
+    tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(tmsize_t));
-	if (tif->tif_data == NULL)
+    if (tif->tif_data == NULL)
-		return (0);
+        return (0);
-	/*
+    /*
-	 * Calculate the scanline/tile-width size in bytes.
+     * Calculate the scanline/tile-width size in bytes.
-	 */
+     */
-	if (isTiled(tif))
+    if (isTiled(tif))
-		*(tmsize_t*)tif->tif_data = TIFFTileRowSize(tif);
+        *(tmsize_t *)tif->tif_data = TIFFTileRowSize(tif);
-	else
+    else
-		*(tmsize_t*)tif->tif_data = TIFFScanlineSize(tif);
+        *(tmsize_t *)tif->tif_data = TIFFScanlineSize(tif);
-	return (1);
+    return (1);
 }
 
-static int
+static int PackBitsPostEncode(TIFF *tif)
-PackBitsPostEncode(TIFF* tif)
 {
-        if (tif->tif_data)
+    if (tif->tif_data)
-            _TIFFfree(tif->tif_data);
+        _TIFFfreeExt(tif, tif->tif_data);
-	return (1);
+    return (1);
 }
 
 /*
  * Encode a run of pixels.
  */
-static int
+static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
-PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 {
-	unsigned char* bp = (unsigned char*) buf;
+    unsigned char *bp = (unsigned char *)buf;
-	uint8* op;
+    uint8_t *op;
-	uint8* ep;
+    uint8_t *ep;
-	uint8* lastliteral;
+    uint8_t *lastliteral;
-	long n, slop;
+    long n, slop;
-	int b;
+    int b;
-	enum { BASE, LITERAL, RUN, LITERAL_RUN } state;
+    enum
+    {
+        BASE,
+        LITERAL,
+        RUN,
+        LITERAL_RUN
+    } state;
 
-	(void) s;
+    (void)s;
-	op = tif->tif_rawcp;
+    op = tif->tif_rawcp;
-	ep = tif->tif_rawdata + tif->tif_rawdatasize;
+    ep = tif->tif_rawdata + tif->tif_rawdatasize;
-	state = BASE;
+    state = BASE;
-	lastliteral = 0;
+    lastliteral = 0;
-	while (cc > 0) {
+    while (cc > 0)
-		/*
+    {
-		 * Find the longest string of identical bytes.
+        /*
-		 */
+         * Find the longest string of identical bytes.
-		b = *bp++;
+         */
-		cc--;
+        b = *bp++;
-		n = 1;
+        cc--;
-		for (; cc > 0 && b == *bp; cc--, bp++)
+        n = 1;
-			n++;
+        for (; cc > 0 && b == *bp; cc--, bp++)
-	again:
+            n++;
-		if (op + 2 >= ep) {		/* insure space for new data */
+    again:
-			/*
+        if (op + 2 >= ep)
-			 * Be careful about writing the last
+        { /* insure space for new data */
-			 * literal.  Must write up to that point
+            /*
-			 * and then copy the remainder to the
+             * Be careful about writing the last
-			 * front of the buffer.
+             * literal.  Must write up to that point
-			 */
+             * and then copy the remainder to the
-			if (state == LITERAL || state == LITERAL_RUN) {
+             * front of the buffer.
-				slop = (long)(op - lastliteral);
+             */
-				tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
+            if (state == LITERAL || state == LITERAL_RUN)
-				if (!TIFFFlushData1(tif))
+            {
-					return (0);
+                slop = (long)(op - lastliteral);
-				op = tif->tif_rawcp;
+                tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
-				while (slop-- > 0)
+                if (!TIFFFlushData1(tif))
-					*op++ = *lastliteral++;
+                    return (0);
-				lastliteral = tif->tif_rawcp;
+                op = tif->tif_rawcp;
-			} else {
+                while (slop-- > 0)
-				tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
+                    *op++ = *lastliteral++;
-				if (!TIFFFlushData1(tif))
+                lastliteral = tif->tif_rawcp;
-					return (0);
+            }
-				op = tif->tif_rawcp;
+            else
-			}
+            {
-		}
+                tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
-		switch (state) {
+                if (!TIFFFlushData1(tif))
-		case BASE:		/* initial state, set run/literal */
+                    return (0);
-			if (n > 1) {
+                op = tif->tif_rawcp;
-				state = RUN;
+            }
-				if (n > 128) {
+        }
-					*op++ = (uint8) -127;
+        switch (state)
-					*op++ = (uint8) b;
+        {
-					n -= 128;
+            case BASE: /* initial state, set run/literal */
-					goto again;
+                if (n > 1)
-				}
+                {
-				*op++ = (uint8)(-(n-1));
+                    state = RUN;
-				*op++ = (uint8) b;
+                    if (n > 128)
-			} else {
+                    {
-				lastliteral = op;
+                        *op++ = (uint8_t)-127;
-				*op++ = 0;
+                        *op++ = (uint8_t)b;
-				*op++ = (uint8) b;
+                        n -= 128;
-				state = LITERAL;
+                        goto again;
-			}
+                    }
-			break;
+                    *op++ = (uint8_t)(-(n - 1));
-		case LITERAL:		/* last object was literal string */
+                    *op++ = (uint8_t)b;
-			if (n > 1) {
+                }
-				state = LITERAL_RUN;
+                else
-				if (n > 128) {
+                {
-					*op++ = (uint8) -127;
+                    lastliteral = op;
-					*op++ = (uint8) b;
+                    *op++ = 0;
-					n -= 128;
+                    *op++ = (uint8_t)b;
-					goto again;
+                    state = LITERAL;
-				}
+                }
-				*op++ = (uint8)(-(n-1));	/* encode run */
+                break;
-				*op++ = (uint8) b;
+            case LITERAL: /* last object was literal string */
-			} else {			/* extend literal */
+                if (n > 1)
-				if (++(*lastliteral) == 127)
+                {
-					state = BASE;
+                    state = LITERAL_RUN;
-				*op++ = (uint8) b;
+                    if (n > 128)
-			}
+                    {
-			break;
+                        *op++ = (uint8_t)-127;
-		case RUN:		/* last object was run */
+                        *op++ = (uint8_t)b;
-			if (n > 1) {
+                        n -= 128;
-				if (n > 128) {
+                        goto again;
-					*op++ = (uint8) -127;
+                    }
-					*op++ = (uint8) b;
+                    *op++ = (uint8_t)(-(n - 1)); /* encode run */
-					n -= 128;
+                    *op++ = (uint8_t)b;
-					goto again;
+                }
-				}
+                else
-				*op++ = (uint8)(-(n-1));
+                { /* extend literal */
-				*op++ = (uint8) b;
+                    if (++(*lastliteral) == 127)
-			} else {
+                        state = BASE;
-				lastliteral = op;
+                    *op++ = (uint8_t)b;
-				*op++ = 0;
+                }
-				*op++ = (uint8) b;
+                break;
-				state = LITERAL;
+            case RUN: /* last object was run */
-			}
+                if (n > 1)
-			break;
+                {
-		case LITERAL_RUN:	/* literal followed by a run */
+                    if (n > 128)
-			/*
+                    {
-			 * Check to see if previous run should
+                        *op++ = (uint8_t)-127;
-			 * be converted to a literal, in which
+                        *op++ = (uint8_t)b;
-			 * case we convert literal-run-literal
+                        n -= 128;
-			 * to a single literal.
+                        goto again;
-			 */
+                    }
-			if (n == 1 && op[-2] == (uint8) -1 &&
+                    *op++ = (uint8_t)(-(n - 1));
-			    *lastliteral < 126) {
+                    *op++ = (uint8_t)b;
-				state = (((*lastliteral) += 2) == 127 ?
+                }
-				    BASE : LITERAL);
+                else
-				op[-2] = op[-1];	/* replicate */
+                {
-			} else
+                    lastliteral = op;
-				state = RUN;
+                    *op++ = 0;
-			goto again;
+                    *op++ = (uint8_t)b;
-		}
+                    state = LITERAL;
-	}
+                }
-	tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
+                break;
-	tif->tif_rawcp = op;
+            case LITERAL_RUN: /* literal followed by a run */
-	return (1);
+                /*
+                 * Check to see if previous run should
+                 * be converted to a literal, in which
+                 * case we convert literal-run-literal
+                 * to a single literal.
+                 */
+                if (n == 1 && op[-2] == (uint8_t)-1 && *lastliteral < 126)
+                {
+                    state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL);
+                    op[-2] = op[-1]; /* replicate */
+                }
+                else
+                    state = RUN;
+                goto again;
+        }
+    }
+    tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
+    tif->tif_rawcp = op;
+    return (1);
 }
 
 /*
@@ -191,119 +212,112 @@ PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
  * the decoder if data is read, for example, by scanlines
  * when it was encoded by strips.
  */
-static int
+static int PackBitsEncodeChunk(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
-PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 {
-	tmsize_t rowsize = *(tmsize_t*)tif->tif_data;
+    tmsize_t rowsize = *(tmsize_t *)tif->tif_data;
 
-	while (cc > 0) {
+    while (cc > 0)
-		tmsize_t chunk = rowsize;
+    {
+        tmsize_t chunk = rowsize;
 
-		if( cc < chunk )
+        if (cc < chunk)
-		    chunk = cc;
+            chunk = cc;
 
-		if (PackBitsEncode(tif, bp, chunk, s) < 0)
+        if (PackBitsEncode(tif, bp, chunk, s) < 0)
-		    return (-1);
+            return (-1);
-		bp += chunk;
+        bp += chunk;
-		cc -= chunk;
+        cc -= chunk;
-	}
+    }
-	return (1);
+    return (1);
 }
 
-static int
+static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
-PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 {
-	static const char module[] = "PackBitsDecode";
+    static const char module[] = "PackBitsDecode";
-	char *bp;
+    int8_t *bp;
-	tmsize_t cc;
+    tmsize_t cc;
-	long n;
+    long n;
-	int b;
+    int b;
 
-	(void) s;
+    (void)s;
-	bp = (char*) tif->tif_rawcp;
+    bp = (int8_t *)tif->tif_rawcp;
-	cc = tif->tif_rawcc;
+    cc = tif->tif_rawcc;
-	while (cc > 0 && occ > 0) {
+    while (cc > 0 && occ > 0)
-		n = (long) *bp++;
+    {
-		cc--;
+        n = (long)*bp++;
-		/*
+        cc--;
-		 * Watch out for compilers that
+        if (n < 0)
-		 * don't sign extend chars...
+        {                  /* replicate next byte -n+1 times */
-		 */
+            if (n == -128) /* nop */
-		if (n >= 128)
+                continue;
-			n -= 256;
+            n = -n + 1;
-		if (n < 0) {		/* replicate next byte -n+1 times */
+            if (occ < (tmsize_t)n)
-			if (n == -128)	/* nop */
+            {
-				continue;
+                TIFFWarningExtR(tif, module,
-			n = -n + 1;
+                                "Discarding %" TIFF_SSIZE_FORMAT
-			if( occ < (tmsize_t)n )
+                                " bytes to avoid buffer overrun",
-			{
+                                (tmsize_t)n - occ);
-				TIFFWarningExt(tif->tif_clientdata, module,
+                n = (long)occ;
-				    "Discarding %lu bytes to avoid buffer overrun",
+            }
-				    (unsigned long) ((tmsize_t)n - occ));
+            if (cc == 0)
-				n = (long)occ;
+            {
-			}
+                TIFFWarningExtR(
-			if( cc == 0 )
+                    tif, module,
-			{
+                    "Terminating PackBitsDecode due to lack of data.");
-				TIFFWarningExt(tif->tif_clientdata, module,
+                break;
-					       "Terminating PackBitsDecode due to lack of data.");
+            }
-				break;
+            occ -= n;
-			}
+            b = *bp++;
-			occ -= n;
+            cc--;
-			b = *bp++;
+            while (n-- > 0)
-			cc--;
+                *op++ = (uint8_t)b;
-			while (n-- > 0)
+        }
-				*op++ = (uint8) b;
+        else
-		} else {		/* copy next n+1 bytes literally */
+        { /* copy next n+1 bytes literally */
-			if (occ < (tmsize_t)(n + 1))
+            if (occ < (tmsize_t)(n + 1))
-			{
+            {
-				TIFFWarningExt(tif->tif_clientdata, module,
+                TIFFWarningExtR(tif, module,
-				    "Discarding %lu bytes to avoid buffer overrun",
+                                "Discarding %" TIFF_SSIZE_FORMAT
-				    (unsigned long) ((tmsize_t)n - occ + 1));
+                                " bytes to avoid buffer overrun",
-				n = (long)occ - 1;
+                                (tmsize_t)n - occ + 1);
-			}
+                n = (long)occ - 1;
-			if (cc < (tmsize_t) (n+1)) 
+            }
-			{
+            if (cc < (tmsize_t)(n + 1))
-				TIFFWarningExt(tif->tif_clientdata, module,
+            {
-					       "Terminating PackBitsDecode due to lack of data.");
+                TIFFWarningExtR(
-				break;
+                    tif, module,
-			}
+                    "Terminating PackBitsDecode due to lack of data.");
-			_TIFFmemcpy(op, bp, ++n);
+                break;
-			op += n; occ -= n;
+            }
-			bp += n; cc -= n;
+            _TIFFmemcpy(op, bp, ++n);
-		}
+            op += n;
-	}
+            occ -= n;
-	tif->tif_rawcp = (uint8*) bp;
+            bp += n;
-	tif->tif_rawcc = cc;
+            cc -= n;
-	if (occ > 0) {
+        }
-		TIFFErrorExt(tif->tif_clientdata, module,
+    }
-		    "Not enough data for scanline %lu",
+    tif->tif_rawcp = (uint8_t *)bp;
-		    (unsigned long) tif->tif_row);
+    tif->tif_rawcc = cc;
-		return (0);
+    if (occ > 0)
-	}
+    {
-	return (1);
+        TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
+                      tif->tif_row);
+        return (0);
+    }
+    return (1);
 }
 
-int
+int TIFFInitPackBits(TIFF *tif, int scheme)
-TIFFInitPackBits(TIFF* tif, int scheme)
 {
-	(void) scheme;
+    (void)scheme;
-	tif->tif_decoderow = PackBitsDecode;
+    tif->tif_decoderow = PackBitsDecode;
-	tif->tif_decodestrip = PackBitsDecode;
+    tif->tif_decodestrip = PackBitsDecode;
-	tif->tif_decodetile = PackBitsDecode;
+    tif->tif_decodetile = PackBitsDecode;
-	tif->tif_preencode = PackBitsPreEncode;
+    tif->tif_preencode = PackBitsPreEncode;
-	tif->tif_postencode = PackBitsPostEncode;
+    tif->tif_postencode = PackBitsPostEncode;
-	tif->tif_encoderow = PackBitsEncode;
+    tif->tif_encoderow = PackBitsEncode;
-	tif->tif_encodestrip = PackBitsEncodeChunk;
+    tif->tif_encodestrip = PackBitsEncodeChunk;
-	tif->tif_encodetile = PackBitsEncodeChunk;
+    tif->tif_encodetile = PackBitsEncodeChunk;
-	return (1);
+    return (1);
 }
 #endif /* PACKBITS_SUPPORT */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_predict.h

@@ -23,7 +23,7 @@
  */
 
 #ifndef _TIFFPREDICT_
-#define	_TIFFPREDICT_
+#define _TIFFPREDICT_
 
 #include "tiffio.h"
 #include "tiffiop.h"
@@ -32,50 +32,43 @@
  * ``Library-private'' Support for the Predictor Tag
  */
 
-typedef int (*TIFFEncodeDecodeMethod)(TIFF* tif, uint8* buf, tmsize_t size);
+typedef int (*TIFFEncodeDecodeMethod)(TIFF *tif, uint8_t *buf, tmsize_t size);
 
 /*
  * Codecs that want to support the Predictor tag must place
  * this structure first in their private state block so that
  * the predictor code can cast tif_data to find its state.
  */
-typedef struct {
+typedef struct
-	int             predictor;	/* predictor tag value */
+{
-	tmsize_t        stride;		/* sample stride over data */
+    int predictor;    /* predictor tag value */
-	tmsize_t        rowsize;	/* tile/strip row size */
+    tmsize_t stride;  /* sample stride over data */
+    tmsize_t rowsize; /* tile/strip row size */
 
-	TIFFCodeMethod  encoderow;	/* parent codec encode/decode row */
+    TIFFCodeMethod encoderow;           /* parent codec encode/decode row */
-	TIFFCodeMethod  encodestrip;	/* parent codec encode/decode strip */
+    TIFFCodeMethod encodestrip;         /* parent codec encode/decode strip */
-	TIFFCodeMethod  encodetile;	/* parent codec encode/decode tile */ 
+    TIFFCodeMethod encodetile;          /* parent codec encode/decode tile */
-	TIFFEncodeDecodeMethod  encodepfunc;	/* horizontal differencer */
+    TIFFEncodeDecodeMethod encodepfunc; /* horizontal differencer */
 
-	TIFFCodeMethod  decoderow;	/* parent codec encode/decode row */
+    TIFFCodeMethod decoderow;           /* parent codec encode/decode row */
-	TIFFCodeMethod  decodestrip;	/* parent codec encode/decode strip */
+    TIFFCodeMethod decodestrip;         /* parent codec encode/decode strip */
-	TIFFCodeMethod  decodetile;	/* parent codec encode/decode tile */ 
+    TIFFCodeMethod decodetile;          /* parent codec encode/decode tile */
-	TIFFEncodeDecodeMethod  decodepfunc;	/* horizontal accumulator */
+    TIFFEncodeDecodeMethod decodepfunc; /* horizontal accumulator */
 
-	TIFFVGetMethod  vgetparent;	/* super-class method */
+    TIFFVGetMethod vgetparent;  /* super-class method */
-	TIFFVSetMethod  vsetparent;	/* super-class method */
+    TIFFVSetMethod vsetparent;  /* super-class method */
-	TIFFPrintMethod printdir;	/* super-class method */
+    TIFFPrintMethod printdir;   /* super-class method */
-	TIFFBoolMethod  setupdecode;	/* super-class method */
+    TIFFBoolMethod setupdecode; /* super-class method */
-	TIFFBoolMethod  setupencode;	/* super-class method */
+    TIFFBoolMethod setupencode; /* super-class method */
 } TIFFPredictorState;
 
 #if defined(__cplusplus)
-extern "C" {
+extern "C"
+{
 #endif
-extern int TIFFPredictorInit(TIFF*);
+    extern int TIFFPredictorInit(TIFF *);
-extern int TIFFPredictorCleanup(TIFF*);
+    extern int TIFFPredictorCleanup(TIFF *);
 #if defined(__cplusplus)
 }
 #endif
 #endif /* _TIFFPREDICT_ */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_stream.cxx

@@ -28,9 +28,7 @@
 #include "tiffiop.h"
 #include <iostream>
 
-#ifndef __VMS
 using namespace std;
-#endif
 
 /*
   ISO C++ uses a 'std::streamsize' type to define counts.  This makes
@@ -76,359 +74,331 @@ using namespace std;
 struct tiffis_data;
 struct tiffos_data;
 
-extern "C" {
+extern "C"
-
-	static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t);
-	static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size);
-	static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size);
-	static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t);
-	static uint64   _tiffosSeekProc(thandle_t fd, uint64 off, int whence);
-	static uint64   _tiffisSeekProc(thandle_t fd, uint64 off, int whence);
-	static uint64   _tiffosSizeProc(thandle_t fd);
-	static uint64   _tiffisSizeProc(thandle_t fd);
-	static int      _tiffosCloseProc(thandle_t fd);
-	static int      _tiffisCloseProc(thandle_t fd);
-	static int 	_tiffDummyMapProc(thandle_t , void** base, toff_t* size );
-	static void     _tiffDummyUnmapProc(thandle_t , void* base, toff_t size );
-	static TIFF*    _tiffStreamOpen(const char* name, const char* mode, void *fd);
-
-struct tiffis_data
 {
-	istream	*stream;
+
+    static tmsize_t _tiffosReadProc(thandle_t, void *, tmsize_t);
+    static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size);
+    static tmsize_t _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size);
+    static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t);
+    static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence);
+    static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence);
+    static uint64_t _tiffosSizeProc(thandle_t fd);
+    static uint64_t _tiffisSizeProc(thandle_t fd);
+    static int _tiffosCloseProc(thandle_t fd);
+    static int _tiffisCloseProc(thandle_t fd);
+    static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size);
+    static void _tiffDummyUnmapProc(thandle_t, void *base, toff_t size);
+    static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd);
+
+    struct tiffis_data
+    {
+        istream *stream;
         ios::pos_type start_pos;
-};
+    };
 
-struct tiffos_data
+    struct tiffos_data
-{
+    {
-	ostream	*stream;
+        ostream *stream;
-	ios::pos_type start_pos;
+        ios::pos_type start_pos;
-};
+    };
 
-static tmsize_t
+    static tmsize_t _tiffosReadProc(thandle_t, void *, tmsize_t) { return 0; }
-_tiffosReadProc(thandle_t, void*, tmsize_t)
-{
-        return 0;
-}
 
-static tmsize_t
+    static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size)
-_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size)
+    {
-{
+        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
-        tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
 
         // Verify that type does not overflow.
         streamsize request_size = size;
         if (static_cast<tmsize_t>(request_size) != size)
-          return static_cast<tmsize_t>(-1);
+            return static_cast<tmsize_t>(-1);
 
-        data->stream->read((char *) buf, request_size);
+        data->stream->read((char *)buf, request_size);
 
         return static_cast<tmsize_t>(data->stream->gcount());
-}
+    }
 
-static tmsize_t
+    static tmsize_t _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size)
-_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size)
+    {
-{
+        tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
-	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
+        ostream *os = data->stream;
-	ostream		*os = data->stream;
+        ios::pos_type pos = os->tellp();
-	ios::pos_type	pos = os->tellp();
 
         // Verify that type does not overflow.
         streamsize request_size = size;
         if (static_cast<tmsize_t>(request_size) != size)
-          return static_cast<tmsize_t>(-1);
+            return static_cast<tmsize_t>(-1);
 
-	os->write(reinterpret_cast<const char *>(buf), request_size);
+        os->write(reinterpret_cast<const char *>(buf), request_size);
 
-	return static_cast<tmsize_t>(os->tellp() - pos);
+        return static_cast<tmsize_t>(os->tellp() - pos);
-}
+    }
 
-static tmsize_t
+    static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t) { return 0; }
-_tiffisWriteProc(thandle_t, void*, tmsize_t)
-{
-	return 0;
-}
 
-static uint64
+    static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence)
-_tiffosSeekProc(thandle_t fd, uint64 off, int whence)
+    {
-{
+        tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
-	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
+        ostream *os = data->stream;
-	ostream		*os = data->stream;
 
-	// if the stream has already failed, don't do anything
+        // if the stream has already failed, don't do anything
-	if( os->fail() )
+        if (os->fail())
-		return static_cast<uint64>(-1);
+            return static_cast<uint64_t>(-1);
 
-	switch(whence) {
+        switch (whence)
-	case SEEK_SET:
+        {
-		{
+            case SEEK_SET:
-			// Compute 64-bit offset
+            {
-			uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
+                // Compute 64-bit offset
+                uint64_t new_offset =
+                    static_cast<uint64_t>(data->start_pos) + off;
 
-			// Verify that value does not overflow
+                // Verify that value does not overflow
-			ios::off_type offset = static_cast<ios::off_type>(new_offset);
+                ios::off_type offset = static_cast<ios::off_type>(new_offset);
-			if (static_cast<uint64>(offset) != new_offset)
+                if (static_cast<uint64_t>(offset) != new_offset)
-				return static_cast<uint64>(-1);
+                    return static_cast<uint64_t>(-1);
 
-			os->seekp(offset, ios::beg);
+                os->seekp(offset, ios::beg);
-		break;
+                break;
-		}
+            }
-	case SEEK_CUR:
+            case SEEK_CUR:
-		{
+            {
-			// Verify that value does not overflow
+                // Verify that value does not overflow
-			ios::off_type offset = static_cast<ios::off_type>(off);
+                ios::off_type offset = static_cast<ios::off_type>(off);
-			if (static_cast<uint64>(offset) != off)
+                if (static_cast<uint64_t>(offset) != off)
-				return static_cast<uint64>(-1);
+                    return static_cast<uint64_t>(-1);
 
-			os->seekp(offset, ios::cur);
+                os->seekp(offset, ios::cur);
-			break;
+                break;
-		}
+            }
-	case SEEK_END:
+            case SEEK_END:
-		{
+            {
-			// Verify that value does not overflow
+                // Verify that value does not overflow
-			ios::off_type offset = static_cast<ios::off_type>(off);
+                ios::off_type offset = static_cast<ios::off_type>(off);
-			if (static_cast<uint64>(offset) != off)
+                if (static_cast<uint64_t>(offset) != off)
-				return static_cast<uint64>(-1);
+                    return static_cast<uint64_t>(-1);
 
-			os->seekp(offset, ios::end);
+                os->seekp(offset, ios::end);
-			break;
+                break;
-		}
+            }
-	}
+        }
 
-	// Attempt to workaround problems with seeking past the end of the
+        // Attempt to workaround problems with seeking past the end of the
-	// stream.  ofstream doesn't have a problem with this but
+        // stream.  ofstream doesn't have a problem with this but
-	// ostrstream/ostringstream does. In that situation, add intermediate
+        // ostrstream/ostringstream does. In that situation, add intermediate
-	// '\0' characters.
+        // '\0' characters.
-	if( os->fail() ) {
+        if (os->fail())
-#ifdef __VMS
+        {
-		int		old_state;
+            ios::iostate old_state;
-#else
+            ios::pos_type origin;
-		ios::iostate	old_state;
-#endif
-		ios::pos_type	origin;
 
-		old_state = os->rdstate();
+            old_state = os->rdstate();
-		// reset the fail bit or else tellp() won't work below
+            // reset the fail bit or else tellp() won't work below
-		os->clear(os->rdstate() & ~ios::failbit);
+            os->clear(os->rdstate() & ~ios::failbit);
-		switch( whence ) {
+            switch (whence)
-			case SEEK_SET:
+            {
-                        default:
+                case SEEK_SET:
-				origin = data->start_pos;
+                default:
-				break;
+                    origin = data->start_pos;
-			case SEEK_CUR:
+                    break;
-				origin = os->tellp();
+                case SEEK_CUR:
-				break;
+                    origin = os->tellp();
-			case SEEK_END:
+                    break;
-				os->seekp(0, ios::end);
+                case SEEK_END:
-				origin = os->tellp();
+                    os->seekp(0, ios::end);
-				break;
+                    origin = os->tellp();
-		}
+                    break;
-		// restore original stream state
+            }
-		os->clear(old_state);	
+            // restore original stream state
+            os->clear(old_state);
 
-		// only do something if desired seek position is valid
+            // only do something if desired seek position is valid
-		if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) {
+            if ((static_cast<uint64_t>(origin) + off) >
-			uint64	num_fill;
+                static_cast<uint64_t>(data->start_pos))
+            {
+                uint64_t num_fill;
 
-			// clear the fail bit 
+                // clear the fail bit
-			os->clear(os->rdstate() & ~ios::failbit);
+                os->clear(os->rdstate() & ~ios::failbit);
 
-			// extend the stream to the expected size
+                // extend the stream to the expected size
-			os->seekp(0, ios::end);
+                os->seekp(0, ios::end);
-			num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
+                num_fill = (static_cast<uint64_t>(origin)) + off - os->tellp();
-			for( uint64 i = 0; i < num_fill; i++ )
+                for (uint64_t i = 0; i < num_fill; i++)
-				os->put('\0');
+                    os->put('\0');
 
-			// retry the seek
+                // retry the seek
-			os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg);
+                os->seekp(static_cast<ios::off_type>(
-		}
+                              static_cast<uint64_t>(origin) + off),
-	}
+                          ios::beg);
+            }
+        }
 
-	return static_cast<uint64>(os->tellp());
+        return static_cast<uint64_t>(os->tellp());
-}
+    }
 
-static uint64
+    static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence)
-_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
+    {
-{
+        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
-	tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
 
-	switch(whence) {
+        switch (whence)
-	case SEEK_SET:
+        {
-		{
+            case SEEK_SET:
-			// Compute 64-bit offset
+            {
-			uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
+                // Compute 64-bit offset
+                uint64_t new_offset =
+                    static_cast<uint64_t>(data->start_pos) + off;
 
-			// Verify that value does not overflow
+                // Verify that value does not overflow
-			ios::off_type offset = static_cast<ios::off_type>(new_offset);
+                ios::off_type offset = static_cast<ios::off_type>(new_offset);
-			if (static_cast<uint64>(offset) != new_offset)
+                if (static_cast<uint64_t>(offset) != new_offset)
-				return static_cast<uint64>(-1);
+                    return static_cast<uint64_t>(-1);
 
-			data->stream->seekg(offset, ios::beg);
+                data->stream->seekg(offset, ios::beg);
-			break;
+                break;
-		}
+            }
-	case SEEK_CUR:
+            case SEEK_CUR:
-		{
+            {
-			// Verify that value does not overflow
+                // Verify that value does not overflow
-			ios::off_type offset = static_cast<ios::off_type>(off);
+                ios::off_type offset = static_cast<ios::off_type>(off);
-			if (static_cast<uint64>(offset) != off)
+                if (static_cast<uint64_t>(offset) != off)
-				return static_cast<uint64>(-1);
+                    return static_cast<uint64_t>(-1);
 
-			data->stream->seekg(offset, ios::cur);
+                data->stream->seekg(offset, ios::cur);
-			break;
+                break;
-		}
+            }
-	case SEEK_END:
+            case SEEK_END:
-		{
+            {
-			// Verify that value does not overflow
+                // Verify that value does not overflow
-			ios::off_type offset = static_cast<ios::off_type>(off);
+                ios::off_type offset = static_cast<ios::off_type>(off);
-			if (static_cast<uint64>(offset) != off)
+                if (static_cast<uint64_t>(offset) != off)
-				return static_cast<uint64>(-1);
+                    return static_cast<uint64_t>(-1);
 
-			data->stream->seekg(offset, ios::end);
+                data->stream->seekg(offset, ios::end);
-			break;
+                break;
-		}
+            }
-	}
+        }
 
-	return (uint64) (data->stream->tellg() - data->start_pos);
+        return (uint64_t)(data->stream->tellg() - data->start_pos);
-}
+    }
 
-static uint64
+    static uint64_t _tiffosSizeProc(thandle_t fd)
-_tiffosSizeProc(thandle_t fd)
+    {
-{
+        tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
-	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
+        ostream *os = data->stream;
-	ostream		*os = data->stream;
+        ios::pos_type pos = os->tellp();
-	ios::pos_type	pos = os->tellp();
+        ios::pos_type len;
-	ios::pos_type	len;
 
-	os->seekp(0, ios::end);
+        os->seekp(0, ios::end);
-	len = os->tellp();
+        len = os->tellp();
-	os->seekp(pos);
+        os->seekp(pos);
 
-	return (uint64) len;
+        return (uint64_t)len;
-}
+    }
 
-static uint64
+    static uint64_t _tiffisSizeProc(thandle_t fd)
-_tiffisSizeProc(thandle_t fd)
+    {
-{
+        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
-	tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
+        ios::pos_type pos = data->stream->tellg();
-	ios::pos_type	pos = data->stream->tellg();
+        ios::pos_type len;
-	ios::pos_type	len;
 
-	data->stream->seekg(0, ios::end);
+        data->stream->seekg(0, ios::end);
-	len = data->stream->tellg();
+        len = data->stream->tellg();
-	data->stream->seekg(pos);
+        data->stream->seekg(pos);
 
-	return (uint64) len;
+        return (uint64_t)len;
-}
+    }
 
-static int
+    static int _tiffosCloseProc(thandle_t fd)
-_tiffosCloseProc(thandle_t fd)
+    {
-{
+        // Our stream was not allocated by us, so it shouldn't be closed by us.
-	// Our stream was not allocated by us, so it shouldn't be closed by us.
+        delete reinterpret_cast<tiffos_data *>(fd);
-	delete reinterpret_cast<tiffos_data *>(fd);
+        return 0;
-	return 0;
+    }
-}
 
-static int
+    static int _tiffisCloseProc(thandle_t fd)
-_tiffisCloseProc(thandle_t fd)
+    {
-{
+        // Our stream was not allocated by us, so it shouldn't be closed by us.
-	// Our stream was not allocated by us, so it shouldn't be closed by us.
+        delete reinterpret_cast<tiffis_data *>(fd);
-	delete reinterpret_cast<tiffis_data *>(fd);
+        return 0;
-	return 0;
+    }
-}
 
-static int
+    static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size)
-_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
+    {
-{
+        (void)base;
-	(void) base;
+        (void)size;
-	(void) size;
+        return (0);
-	return (0);
+    }
-}
 
-static void
+    static void _tiffDummyUnmapProc(thandle_t, void *base, toff_t size)
-_tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
+    {
-{
+        (void)base;
-	(void) base;
+        (void)size;
-	(void) size;
+    }
-}
 
-/*
+    /*
- * Open a TIFF file descriptor for read/writing.
+     * Open a TIFF file descriptor for read/writing.
- */
+     */
-static TIFF*
+    static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd)
-_tiffStreamOpen(const char* name, const char* mode, void *fd)
+    {
-{
+        TIFF *tif;
-	TIFF*	tif;
 
-	if( strchr(mode, 'w') ) {
+        if (strchr(mode, 'w'))
-		tiffos_data	*data = new tiffos_data;
+        {
-		data->stream = reinterpret_cast<ostream *>(fd);
+            tiffos_data *data = new tiffos_data;
-		data->start_pos = data->stream->tellp();
+            data->stream = reinterpret_cast<ostream *>(fd);
+            data->start_pos = data->stream->tellp();
 
-		// Open for writing.
+            // Open for writing.
-		tif = TIFFClientOpen(name, mode,
+            tif = TIFFClientOpen(
-				reinterpret_cast<thandle_t>(data),
+                name, mode, reinterpret_cast<thandle_t>(data), _tiffosReadProc,
-				_tiffosReadProc,
+                _tiffosWriteProc, _tiffosSeekProc, _tiffosCloseProc,
-                                _tiffosWriteProc,
+                _tiffosSizeProc, _tiffDummyMapProc, _tiffDummyUnmapProc);
-				_tiffosSeekProc,
+            if (!tif)
-                                _tiffosCloseProc,
+            {
-				_tiffosSizeProc,
+                delete data;
-				_tiffDummyMapProc,
+            }
-                                _tiffDummyUnmapProc);
+        }
-		if (!tif) {
+        else
-			delete data;
+        {
-		}
+            tiffis_data *data = new tiffis_data;
-	} else {
+            data->stream = reinterpret_cast<istream *>(fd);
-		tiffis_data	*data = new tiffis_data;
+            data->start_pos = data->stream->tellg();
-		data->stream = reinterpret_cast<istream *>(fd);
+            // Open for reading.
-		data->start_pos = data->stream->tellg();
+            tif = TIFFClientOpen(
-		// Open for reading.
+                name, mode, reinterpret_cast<thandle_t>(data), _tiffisReadProc,
-		tif = TIFFClientOpen(name, mode,
+                _tiffisWriteProc, _tiffisSeekProc, _tiffisCloseProc,
-				reinterpret_cast<thandle_t>(data),
+                _tiffisSizeProc, _tiffDummyMapProc, _tiffDummyUnmapProc);
-				_tiffisReadProc,
+            if (!tif)
-                                _tiffisWriteProc,
+            {
-				_tiffisSeekProc,
+                delete data;
-                                _tiffisCloseProc,
+            }
-				_tiffisSizeProc,
+        }
-				_tiffDummyMapProc,
-                                _tiffDummyUnmapProc);
-		if (!tif) {
-			delete data;
-		}
-	}
 
-	return (tif);
+        return (tif);
-}
+    }
 
 } /* extern "C" */
 
-TIFF*
+TIFF *TIFFStreamOpen(const char *name, ostream *os)
-TIFFStreamOpen(const char* name, ostream *os)
 {
-	// If os is either a ostrstream or ostringstream, and has no data
+    // If os is either a ostrstream or ostringstream, and has no data
-	// written to it yet, then tellp() will return -1 which will break us.
+    // written to it yet, then tellp() will return -1 which will break us.
-	// We workaround this by writing out a dummy character and
+    // We workaround this by writing out a dummy character and
-	// then seek back to the beginning.
+    // then seek back to the beginning.
-	if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) {
+    if (!os->fail() && static_cast<int>(os->tellp()) < 0)
-		*os << '\0';
+    {
-		os->seekp(0);
+        *os << '\0';
-	}
+        os->seekp(0);
+    }
 
-	// NB: We don't support mapped files with streams so add 'm'
+    // NB: We don't support mapped files with streams so add 'm'
-	return _tiffStreamOpen(name, "wm", os);
+    return _tiffStreamOpen(name, "wm", os);
 }
 
-TIFF*
+TIFF *TIFFStreamOpen(const char *name, istream *is)
-TIFFStreamOpen(const char* name, istream *is)
 {
-	// NB: We don't support mapped files with streams so add 'm'
+    // NB: We don't support mapped files with streams so add 'm'
-	return _tiffStreamOpen(name, "rm", is);
+    return _tiffStreamOpen(name, "rm", is);
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */
-

3rdparty/libtiff/tif_strip.c

@@ -32,153 +32,145 @@
 /*
  * Compute which strip a (row,sample) value is in.
  */
-uint32
+uint32_t TIFFComputeStrip(TIFF *tif, uint32_t row, uint16_t sample)
-TIFFComputeStrip(TIFF* tif, uint32 row, uint16 sample)
 {
-	static const char module[] = "TIFFComputeStrip";
+    static const char module[] = "TIFFComputeStrip";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint32 strip;
+    uint32_t strip;
 
-	strip = row / td->td_rowsperstrip;
+    strip = row / td->td_rowsperstrip;
-	if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
+    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
-		if (sample >= td->td_samplesperpixel) {
+    {
-			TIFFErrorExt(tif->tif_clientdata, module,
+        if (sample >= td->td_samplesperpixel)
-			    "%lu: Sample out of range, max %lu",
+        {
-			    (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
+            TIFFErrorExtR(tif, module, "%lu: Sample out of range, max %lu",
-			return (0);
+                          (unsigned long)sample,
-		}
+                          (unsigned long)td->td_samplesperpixel);
-		strip += (uint32)sample*td->td_stripsperimage;
+            return (0);
-	}
+        }
-	return (strip);
+        strip += (uint32_t)sample * td->td_stripsperimage;
+    }
+    return (strip);
 }
 
 /*
  * Compute how many strips are in an image.
  */
-uint32
+uint32_t TIFFNumberOfStrips(TIFF *tif)
-TIFFNumberOfStrips(TIFF* tif)
 {
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint32 nstrips;
+    uint32_t nstrips;
 
-	nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 :
+    nstrips = (td->td_rowsperstrip == (uint32_t)-1
-	     TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
+                   ? 1
-	if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
+                   : TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
-		nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel,
+    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
-		    "TIFFNumberOfStrips");
+        nstrips =
-	return (nstrips);
+            _TIFFMultiply32(tif, nstrips, (uint32_t)td->td_samplesperpixel,
+                            "TIFFNumberOfStrips");
+    return (nstrips);
 }
 
 /*
  * Compute the # bytes in a variable height, row-aligned strip.
  */
-uint64
+uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
-TIFFVStripSize64(TIFF* tif, uint32 nrows)
 {
-	static const char module[] = "TIFFVStripSize64";
+    static const char module[] = "TIFFVStripSize64";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	if (nrows==(uint32)(-1))
+    if (nrows == (uint32_t)(-1))
-		nrows=td->td_imagelength;
+        nrows = td->td_imagelength;
-	if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
+    if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
-	    (td->td_photometric == PHOTOMETRIC_YCBCR)&&
+        (td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
-	    (!isUpSampled(tif)))
+    {
-	{
+        /*
-		/*
+         * Packed YCbCr data contain one Cb+Cr for every
-		 * Packed YCbCr data contain one Cb+Cr for every
+         * HorizontalSampling*VerticalSampling Y values.
-		 * HorizontalSampling*VerticalSampling Y values.
+         * Must also roundup width and height when calculating
-		 * Must also roundup width and height when calculating
+         * since images that are not a multiple of the
-		 * since images that are not a multiple of the
+         * horizontal/vertical subsampling area include
-		 * horizontal/vertical subsampling area include
+         * YCbCr data for the extended image.
-		 * YCbCr data for the extended image.
+         */
-		 */
+        uint16_t ycbcrsubsampling[2];
-		uint16 ycbcrsubsampling[2];
+        uint16_t samplingblock_samples;
-		uint16 samplingblock_samples;
+        uint32_t samplingblocks_hor;
-		uint32 samplingblocks_hor;
+        uint32_t samplingblocks_ver;
-		uint32 samplingblocks_ver;
+        uint64_t samplingrow_samples;
-		uint64 samplingrow_samples;
+        uint64_t samplingrow_size;
-		uint64 samplingrow_size;
+        if (td->td_samplesperpixel != 3)
-		if(td->td_samplesperpixel!=3)
+        {
-		{
+            TIFFErrorExtR(tif, module, "Invalid td_samplesperpixel value");
-			TIFFErrorExt(tif->tif_clientdata,module,
+            return 0;
-			    "Invalid td_samplesperpixel value");
+        }
-			return 0;
+        TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
-		}
+                              ycbcrsubsampling + 0, ycbcrsubsampling + 1);
-		TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
+        if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
-		    ycbcrsubsampling+1);
+             ycbcrsubsampling[0] != 4) ||
-		if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
+            (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
-		    ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
+             ycbcrsubsampling[1] != 4))
-		{
+        {
-			TIFFErrorExt(tif->tif_clientdata,module,
+            TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
-				     "Invalid YCbCr subsampling (%dx%d)", 
+                          ycbcrsubsampling[0], ycbcrsubsampling[1]);
-				     ycbcrsubsampling[0], 
+            return 0;
-				     ycbcrsubsampling[1] );
+        }
-			return 0;
+        samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
-		}
+        samplingblocks_hor =
-		samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
+            TIFFhowmany_32(td->td_imagewidth, ycbcrsubsampling[0]);
-		samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
+        samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
-		samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
+        samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
-		samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
+                                              samplingblock_samples, module);
-		samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
+        samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
-		return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
+            tif, samplingrow_samples, td->td_bitspersample, module));
-	}
+        return (
-	else
+            _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
-		return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module));
+    }
+    else
+        return (_TIFFMultiply64(tif, nrows, TIFFScanlineSize64(tif), module));
 }
-tmsize_t
+tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows)
-TIFFVStripSize(TIFF* tif, uint32 nrows)
 {
-	static const char module[] = "TIFFVStripSize";
+    static const char module[] = "TIFFVStripSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFVStripSize64(tif,nrows);
+    m = TIFFVStripSize64(tif, nrows);
-        return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
  * Compute the # bytes in a raw strip.
  */
-uint64
+uint64_t TIFFRawStripSize64(TIFF *tif, uint32_t strip)
-TIFFRawStripSize64(TIFF* tif, uint32 strip)
 {
-	static const char module[] = "TIFFRawStripSize64";
+    static const char module[] = "TIFFRawStripSize64";
-	uint64 bytecount = TIFFGetStrileByteCount(tif, strip);
+    uint64_t bytecount = TIFFGetStrileByteCount(tif, strip);
 
-	if (bytecount == 0)
+    if (bytecount == 0)
-	{
+    {
-#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
+        TIFFErrorExtR(tif, module,
-		TIFFErrorExt(tif->tif_clientdata, module,
+                      "%" PRIu64 ": Invalid strip byte count, strip %lu",
-			     "%I64u: Invalid strip byte count, strip %lu",
+                      (uint64_t)bytecount, (unsigned long)strip);
-			     (unsigned __int64) bytecount,
+        bytecount = (uint64_t)-1;
-			     (unsigned long) strip);
+    }
-#else
-		TIFFErrorExt(tif->tif_clientdata, module,
-			     "%llu: Invalid strip byte count, strip %lu",
-			     (unsigned long long) bytecount,
-			     (unsigned long) strip);
-#endif
-		bytecount = (uint64) -1;
-	}
 
-	return bytecount;
+    return bytecount;
 }
-tmsize_t
+tmsize_t TIFFRawStripSize(TIFF *tif, uint32_t strip)
-TIFFRawStripSize(TIFF* tif, uint32 strip)
 {
-	static const char module[] = "TIFFRawStripSize";
+    static const char module[] = "TIFFRawStripSize";
-	uint64 m;
+    uint64_t m;
-	tmsize_t n;
+    tmsize_t n;
-	m=TIFFRawStripSize64(tif,strip);
+    m = TIFFRawStripSize64(tif, strip);
-	if (m==(uint64)(-1))
+    if (m == (uint64_t)(-1))
-		n=(tmsize_t)(-1);
+        n = (tmsize_t)(-1);
-	else
+    else
-	{
+    {
-		n=(tmsize_t)m;
+        n = (tmsize_t)m;
-		if ((uint64)n!=m)
+        if ((uint64_t)n != m)
-		{
+        {
-			TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
+            TIFFErrorExtR(tif, module, "Integer overflow");
-			n=0;
+            n = 0;
-		}
+        }
-	}
+    }
-	return(n);
+    return (n);
 }
 
 /*
@@ -189,22 +181,20 @@ TIFFRawStripSize(TIFF* tif, uint32 strip)
  * truncated to reflect the actual space required
  * to hold the strip.
  */
-uint64
+uint64_t TIFFStripSize64(TIFF *tif)
-TIFFStripSize64(TIFF* tif)
 {
-	TIFFDirectory* td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint32 rps = td->td_rowsperstrip;
+    uint32_t rps = td->td_rowsperstrip;
-	if (rps > td->td_imagelength)
+    if (rps > td->td_imagelength)
-		rps = td->td_imagelength;
+        rps = td->td_imagelength;
-	return (TIFFVStripSize64(tif, rps));
+    return (TIFFVStripSize64(tif, rps));
 }
-tmsize_t
+tmsize_t TIFFStripSize(TIFF *tif)
-TIFFStripSize(TIFF* tif)
 {
-	static const char module[] = "TIFFStripSize";
+    static const char module[] = "TIFFStripSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFStripSize64(tif);
+    m = TIFFStripSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
@@ -213,34 +203,33 @@ TIFFStripSize(TIFF* tif)
  * request is <1 then we choose a strip size according
  * to certain heuristics.
  */
-uint32
+uint32_t TIFFDefaultStripSize(TIFF *tif, uint32_t request)
-TIFFDefaultStripSize(TIFF* tif, uint32 request)
 {
-	return (*tif->tif_defstripsize)(tif, request);
+    return (*tif->tif_defstripsize)(tif, request);
 }
 
-uint32
+uint32_t _TIFFDefaultStripSize(TIFF *tif, uint32_t s)
-_TIFFDefaultStripSize(TIFF* tif, uint32 s)
 {
-	if ((int32) s < 1) {
+    if ((int32_t)s < 1)
-		/*
+    {
-		 * If RowsPerStrip is unspecified, try to break the
+        /*
-		 * image up into strips that are approximately
+         * If RowsPerStrip is unspecified, try to break the
-		 * STRIP_SIZE_DEFAULT bytes long.
+         * image up into strips that are approximately
-		 */
+         * STRIP_SIZE_DEFAULT bytes long.
-		uint64 scanlinesize;
+         */
-		uint64 rows;
+        uint64_t scanlinesize;
-		scanlinesize=TIFFScanlineSize64(tif);
+        uint64_t rows;
-		if (scanlinesize==0)
+        scanlinesize = TIFFScanlineSize64(tif);
-			scanlinesize=1;
+        if (scanlinesize == 0)
-		rows=(uint64)STRIP_SIZE_DEFAULT/scanlinesize;
+            scanlinesize = 1;
-		if (rows==0)
+        rows = (uint64_t)STRIP_SIZE_DEFAULT / scanlinesize;
-			rows=1;
+        if (rows == 0)
-		else if (rows>0xFFFFFFFF)
+            rows = 1;
-			rows=0xFFFFFFFF;
+        else if (rows > 0xFFFFFFFF)
-		s=(uint32)rows;
+            rows = 0xFFFFFFFF;
-	}
+        s = (uint32_t)rows;
-	return (s);
+    }
+    return (s);
 }
 
 /*
@@ -253,70 +242,79 @@ _TIFFDefaultStripSize(TIFF* tif, uint32 s)
  * subsampling lines divided by vertical subsampling. It should thus make
  * sense when multiplied by a multiple of vertical subsampling.
  */
-uint64
+uint64_t TIFFScanlineSize64(TIFF *tif)
-TIFFScanlineSize64(TIFF* tif)
 {
-	static const char module[] = "TIFFScanlineSize64";
+    static const char module[] = "TIFFScanlineSize64";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint64 scanline_size;
+    uint64_t scanline_size;
-	if (td->td_planarconfig==PLANARCONFIG_CONTIG)
+    if (td->td_planarconfig == PLANARCONFIG_CONTIG)
-	{
+    {
-		if ((td->td_photometric==PHOTOMETRIC_YCBCR)&&
+        if ((td->td_photometric == PHOTOMETRIC_YCBCR) &&
-		    (td->td_samplesperpixel==3)&&
+            (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
-		    (!isUpSampled(tif)))
-		{
-			uint16 ycbcrsubsampling[2];
-			uint16 samplingblock_samples;
-			uint32 samplingblocks_hor;
-			uint64 samplingrow_samples;
-			uint64 samplingrow_size;
-			if(td->td_samplesperpixel!=3)
-			{
-                            TIFFErrorExt(tif->tif_clientdata,module,
-                                         "Invalid td_samplesperpixel value");
-                            return 0;
-			}
-			TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,
-                                              ycbcrsubsampling+0,
-                                              ycbcrsubsampling+1);
-			if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) ||
-			    ((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4)))
-			{
-                            TIFFErrorExt(tif->tif_clientdata,module,
-                                         "Invalid YCbCr subsampling");
-                            return 0;
-			}
-			samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
-			samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
-			samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
-			samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8);
-			scanline_size = (samplingrow_size/ycbcrsubsampling[1]);
-		}
-		else
-		{
-			uint64 scanline_samples;
-			scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module);
-			scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8);
-		}
-	}
-	else
         {
-		scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8);
+            uint16_t ycbcrsubsampling[2];
-        }
+            uint16_t samplingblock_samples;
-        if (scanline_size == 0)
+            uint32_t samplingblocks_hor;
-        {
+            uint64_t samplingrow_samples;
-                TIFFErrorExt(tif->tif_clientdata,module,"Computed scanline size is zero");
+            uint64_t samplingrow_size;
+            if (td->td_samplesperpixel != 3)
+            {
+                TIFFErrorExtR(tif, module, "Invalid td_samplesperpixel value");
                 return 0;
+            }
+            TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
+                                  ycbcrsubsampling + 0, ycbcrsubsampling + 1);
+            if (((ycbcrsubsampling[0] != 1) && (ycbcrsubsampling[0] != 2) &&
+                 (ycbcrsubsampling[0] != 4)) ||
+                ((ycbcrsubsampling[1] != 1) && (ycbcrsubsampling[1] != 2) &&
+                 (ycbcrsubsampling[1] != 4)))
+            {
+                TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling");
+                return 0;
+            }
+            samplingblock_samples =
+                ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
+            samplingblocks_hor =
+                TIFFhowmany_32(td->td_imagewidth, ycbcrsubsampling[0]);
+            samplingrow_samples = _TIFFMultiply64(
+                tif, samplingblocks_hor, samplingblock_samples, module);
+            samplingrow_size =
+                TIFFhowmany_64(_TIFFMultiply64(tif, samplingrow_samples,
+                                               td->td_bitspersample, module),
+                               8);
+            scanline_size = (samplingrow_size / ycbcrsubsampling[1]);
         }
-	return(scanline_size);
+        else
+        {
+            uint64_t scanline_samples;
+            scanline_samples = _TIFFMultiply64(tif, td->td_imagewidth,
+                                               td->td_samplesperpixel, module);
+            scanline_size =
+                TIFFhowmany_64(_TIFFMultiply64(tif, scanline_samples,
+                                               td->td_bitspersample, module),
+                               8);
+        }
+    }
+    else
+    {
+        scanline_size =
+            TIFFhowmany_64(_TIFFMultiply64(tif, td->td_imagewidth,
+                                           td->td_bitspersample, module),
+                           8);
+    }
+    if (scanline_size == 0)
+    {
+        TIFFErrorExtR(tif, module, "Computed scanline size is zero");
+        return 0;
+    }
+    return (scanline_size);
 }
-tmsize_t
+tmsize_t TIFFScanlineSize(TIFF *tif)
-TIFFScanlineSize(TIFF* tif)
 {
-	static const char module[] = "TIFFScanlineSize";
+    static const char module[] = "TIFFScanlineSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFScanlineSize64(tif);
+    m = TIFFScanlineSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
@@ -325,35 +323,28 @@ TIFFScanlineSize(TIFF* tif)
  * I/O size returned by TIFFScanlineSize which may be less
  * if data is store as separate planes).
  */
-uint64
+uint64_t TIFFRasterScanlineSize64(TIFF *tif)
-TIFFRasterScanlineSize64(TIFF* tif)
 {
-	static const char module[] = "TIFFRasterScanlineSize64";
+    static const char module[] = "TIFFRasterScanlineSize64";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint64 scanline;
+    uint64_t scanline;
 
-	scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
+    scanline =
-	if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
+        _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
-		scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
+    if (td->td_planarconfig == PLANARCONFIG_CONTIG)
-		return (TIFFhowmany8_64(scanline));
+    {
-	} else
+        scanline =
-		return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
+            _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
-		    td->td_samplesperpixel, module));
+        return (TIFFhowmany8_64(scanline));
+    }
+    else
+        return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
+                                td->td_samplesperpixel, module));
 }
-tmsize_t
+tmsize_t TIFFRasterScanlineSize(TIFF *tif)
-TIFFRasterScanlineSize(TIFF* tif)
 {
-	static const char module[] = "TIFFRasterScanlineSize";
+    static const char module[] = "TIFFRasterScanlineSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFRasterScanlineSize64(tif);
+    m = TIFFRasterScanlineSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_swab.c

@@ -30,169 +30,218 @@
 #include "tiffiop.h"
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabShort)
-void
+void TIFFSwabShort(uint16_t *wp)
-TIFFSwabShort(uint16* wp)
 {
-	register unsigned char* cp = (unsigned char*) wp;
+    register unsigned char *cp = (unsigned char *)wp;
-	unsigned char t;
+    unsigned char t;
-	assert(sizeof(uint16)==2);
+    assert(sizeof(uint16_t) == 2);
-	t = cp[1]; cp[1] = cp[0]; cp[0] = t;
+    t = cp[1];
+    cp[1] = cp[0];
+    cp[0] = t;
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong)
-void
+void TIFFSwabLong(uint32_t *lp)
-TIFFSwabLong(uint32* lp)
 {
-	register unsigned char* cp = (unsigned char*) lp;
+    register unsigned char *cp = (unsigned char *)lp;
-	unsigned char t;
+    unsigned char t;
-	assert(sizeof(uint32)==4);
+    assert(sizeof(uint32_t) == 4);
-	t = cp[3]; cp[3] = cp[0]; cp[0] = t;
+    t = cp[3];
-	t = cp[2]; cp[2] = cp[1]; cp[1] = t;
+    cp[3] = cp[0];
+    cp[0] = t;
+    t = cp[2];
+    cp[2] = cp[1];
+    cp[1] = t;
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong8)
-void
+void TIFFSwabLong8(uint64_t *lp)
-TIFFSwabLong8(uint64* lp)
 {
-	register unsigned char* cp = (unsigned char*) lp;
+    register unsigned char *cp = (unsigned char *)lp;
-	unsigned char t;
+    unsigned char t;
-	assert(sizeof(uint64)==8);
+    assert(sizeof(uint64_t) == 8);
-	t = cp[7]; cp[7] = cp[0]; cp[0] = t;
+    t = cp[7];
-	t = cp[6]; cp[6] = cp[1]; cp[1] = t;
+    cp[7] = cp[0];
-	t = cp[5]; cp[5] = cp[2]; cp[2] = t;
+    cp[0] = t;
-	t = cp[4]; cp[4] = cp[3]; cp[3] = t;
+    t = cp[6];
+    cp[6] = cp[1];
+    cp[1] = t;
+    t = cp[5];
+    cp[5] = cp[2];
+    cp[2] = t;
+    t = cp[4];
+    cp[4] = cp[3];
+    cp[3] = t;
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfShort)
-void
+void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
-TIFFSwabArrayOfShort(register uint16* wp, tmsize_t n)
 {
-	register unsigned char* cp;
+    register unsigned char *cp;
-	register unsigned char t;
+    register unsigned char t;
-	assert(sizeof(uint16)==2);
+    assert(sizeof(uint16_t) == 2);
-	/* XXX unroll loop some */
+    /* XXX unroll loop some */
-	while (n-- > 0) {
+    while (n-- > 0)
-		cp = (unsigned char*) wp;
+    {
-		t = cp[1]; cp[1] = cp[0]; cp[0] = t;
+        cp = (unsigned char *)wp;
-		wp++;
+        t = cp[1];
-	}
+        cp[1] = cp[0];
+        cp[0] = t;
+        wp++;
+    }
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfTriples)
-void
+void TIFFSwabArrayOfTriples(register uint8_t *tp, tmsize_t n)
-TIFFSwabArrayOfTriples(register uint8* tp, tmsize_t n)
 {
-	unsigned char* cp;
+    unsigned char *cp;
-	unsigned char t;
+    unsigned char t;
 
-	/* XXX unroll loop some */
+    /* XXX unroll loop some */
-	while (n-- > 0) {
+    while (n-- > 0)
-		cp = (unsigned char*) tp;
+    {
-		t = cp[2]; cp[2] = cp[0]; cp[0] = t;
+        cp = (unsigned char *)tp;
-		tp += 3;
+        t = cp[2];
-	}
+        cp[2] = cp[0];
+        cp[0] = t;
+        tp += 3;
+    }
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong)
-void
+void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
-TIFFSwabArrayOfLong(register uint32* lp, tmsize_t n)
 {
-	register unsigned char *cp;
+    register unsigned char *cp;
-	register unsigned char t;
+    register unsigned char t;
-	assert(sizeof(uint32)==4);
+    assert(sizeof(uint32_t) == 4);
-	/* XXX unroll loop some */
+    /* XXX unroll loop some */
-	while (n-- > 0) {
+    while (n-- > 0)
-		cp = (unsigned char *)lp;
+    {
-		t = cp[3]; cp[3] = cp[0]; cp[0] = t;
+        cp = (unsigned char *)lp;
-		t = cp[2]; cp[2] = cp[1]; cp[1] = t;
+        t = cp[3];
-		lp++;
+        cp[3] = cp[0];
-	}
+        cp[0] = t;
+        t = cp[2];
+        cp[2] = cp[1];
+        cp[1] = t;
+        lp++;
+    }
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong8)
-void
+void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
-TIFFSwabArrayOfLong8(register uint64* lp, tmsize_t n)
 {
-	register unsigned char *cp;
+    register unsigned char *cp;
-	register unsigned char t;
+    register unsigned char t;
-	assert(sizeof(uint64)==8);
+    assert(sizeof(uint64_t) == 8);
-	/* XXX unroll loop some */
+    /* XXX unroll loop some */
-	while (n-- > 0) {
+    while (n-- > 0)
-		cp = (unsigned char *)lp;
+    {
-		t = cp[7]; cp[7] = cp[0]; cp[0] = t;
+        cp = (unsigned char *)lp;
-		t = cp[6]; cp[6] = cp[1]; cp[1] = t;
+        t = cp[7];
-		t = cp[5]; cp[5] = cp[2]; cp[2] = t;
+        cp[7] = cp[0];
-		t = cp[4]; cp[4] = cp[3]; cp[3] = t;
+        cp[0] = t;
-		lp++;
+        t = cp[6];
-	}
+        cp[6] = cp[1];
+        cp[1] = t;
+        t = cp[5];
+        cp[5] = cp[2];
+        cp[2] = t;
+        t = cp[4];
+        cp[4] = cp[3];
+        cp[3] = t;
+        lp++;
+    }
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabFloat)
-void
+void TIFFSwabFloat(float *fp)
-TIFFSwabFloat(float* fp)
 {
-	register unsigned char* cp = (unsigned char*) fp;
+    register unsigned char *cp = (unsigned char *)fp;
-	unsigned char t;
+    unsigned char t;
-	assert(sizeof(float)==4);
+    assert(sizeof(float) == 4);
-	t = cp[3]; cp[3] = cp[0]; cp[0] = t;
+    t = cp[3];
-	t = cp[2]; cp[2] = cp[1]; cp[1] = t;
+    cp[3] = cp[0];
+    cp[0] = t;
+    t = cp[2];
+    cp[2] = cp[1];
+    cp[1] = t;
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfFloat)
-void
+void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
-TIFFSwabArrayOfFloat(register float* fp, tmsize_t n)
 {
-	register unsigned char *cp;
+    register unsigned char *cp;
-	register unsigned char t;
+    register unsigned char t;
-	assert(sizeof(float)==4);
+    assert(sizeof(float) == 4);
-	/* XXX unroll loop some */
+    /* XXX unroll loop some */
-	while (n-- > 0) {
+    while (n-- > 0)
-		cp = (unsigned char *)fp;
+    {
-		t = cp[3]; cp[3] = cp[0]; cp[0] = t;
+        cp = (unsigned char *)fp;
-		t = cp[2]; cp[2] = cp[1]; cp[1] = t;
+        t = cp[3];
-		fp++;
+        cp[3] = cp[0];
-	}
+        cp[0] = t;
+        t = cp[2];
+        cp[2] = cp[1];
+        cp[1] = t;
+        fp++;
+    }
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabDouble)
-void
+void TIFFSwabDouble(double *dp)
-TIFFSwabDouble(double *dp)
 {
-	register unsigned char* cp = (unsigned char*) dp;
+    register unsigned char *cp = (unsigned char *)dp;
-	unsigned char t;
+    unsigned char t;
-	assert(sizeof(double)==8);
+    assert(sizeof(double) == 8);
-	t = cp[7]; cp[7] = cp[0]; cp[0] = t;
+    t = cp[7];
-	t = cp[6]; cp[6] = cp[1]; cp[1] = t;
+    cp[7] = cp[0];
-	t = cp[5]; cp[5] = cp[2]; cp[2] = t;
+    cp[0] = t;
-	t = cp[4]; cp[4] = cp[3]; cp[3] = t;
+    t = cp[6];
+    cp[6] = cp[1];
+    cp[1] = t;
+    t = cp[5];
+    cp[5] = cp[2];
+    cp[2] = t;
+    t = cp[4];
+    cp[4] = cp[3];
+    cp[3] = t;
 }
 #endif
 
 #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfDouble)
-void
+void TIFFSwabArrayOfDouble(double *dp, tmsize_t n)
-TIFFSwabArrayOfDouble(double* dp, tmsize_t n)
 {
-	register unsigned char *cp;
+    register unsigned char *cp;
-	register unsigned char t;
+    register unsigned char t;
-	assert(sizeof(double)==8);
+    assert(sizeof(double) == 8);
-	/* XXX unroll loop some */
+    /* XXX unroll loop some */
-	while (n-- > 0) {
+    while (n-- > 0)
-		cp = (unsigned char *)dp;
+    {
-		t = cp[7]; cp[7] = cp[0]; cp[0] = t;
+        cp = (unsigned char *)dp;
-		t = cp[6]; cp[6] = cp[1]; cp[1] = t;
+        t = cp[7];
-		t = cp[5]; cp[5] = cp[2]; cp[2] = t;
+        cp[7] = cp[0];
-		t = cp[4]; cp[4] = cp[3]; cp[3] = t;
+        cp[0] = t;
-		dp++;
+        t = cp[6];
-	}
+        cp[6] = cp[1];
+        cp[1] = t;
+        t = cp[5];
+        cp[5] = cp[2];
+        cp[2] = t;
+        t = cp[4];
+        cp[4] = cp[3];
+        cp[3] = t;
+        dp++;
+    }
 }
 #endif
 
@@ -206,105 +255,75 @@ TIFFSwabArrayOfDouble(double* dp, tmsize_t n)
  * do not reverse bit values.
  */
 static const unsigned char TIFFBitRevTable[256] = {
-    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0,
-    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+    0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4,
-    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+    0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc,
-    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+    0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca,
-    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+    0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6,
-    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+    0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1,
-    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+    0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9,
-    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+    0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd,
-    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+    0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3,
-    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+    0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7,
-    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+    0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf,
-    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+    0x3f, 0xbf, 0x7f, 0xff};
-    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
-};
 static const unsigned char TIFFNoBitRevTable[256] = {
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+    0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 
+    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
-    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 
+    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
-    0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 
+    0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
-    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 
+    0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
-    0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 
+    0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 
+    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
-    0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 
+    0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
-    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 
+    0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
-    0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 
+    0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
-    0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 
+    0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 
+    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
-    0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 
+    0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb,
-    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 
+    0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
-    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 
+    0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
-    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 
+    0xfc, 0xfd, 0xfe, 0xff,
-    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 
-    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 
-    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 
-    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 
-    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 
-    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 
-    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 
-    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 
-    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 
-    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 
 };
 
-const unsigned char*
+const unsigned char *TIFFGetBitRevTable(int reversed)
-TIFFGetBitRevTable(int reversed)
 {
-	return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
+    return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
 }
 
-void
+void TIFFReverseBits(uint8_t *cp, tmsize_t n)
-TIFFReverseBits(uint8* cp, tmsize_t n)  
 {
-	for (; n > 8; n -= 8) {
+    for (; n > 8; n -= 8)
-		cp[0] = TIFFBitRevTable[cp[0]];
+    {
-		cp[1] = TIFFBitRevTable[cp[1]];
+        cp[0] = TIFFBitRevTable[cp[0]];
-		cp[2] = TIFFBitRevTable[cp[2]];
+        cp[1] = TIFFBitRevTable[cp[1]];
-		cp[3] = TIFFBitRevTable[cp[3]];
+        cp[2] = TIFFBitRevTable[cp[2]];
-		cp[4] = TIFFBitRevTable[cp[4]];
+        cp[3] = TIFFBitRevTable[cp[3]];
-		cp[5] = TIFFBitRevTable[cp[5]];
+        cp[4] = TIFFBitRevTable[cp[4]];
-		cp[6] = TIFFBitRevTable[cp[6]];
+        cp[5] = TIFFBitRevTable[cp[5]];
-		cp[7] = TIFFBitRevTable[cp[7]];
+        cp[6] = TIFFBitRevTable[cp[6]];
-		cp += 8;
+        cp[7] = TIFFBitRevTable[cp[7]];
-	}
+        cp += 8;
-	while (n-- > 0) {
+    }
-		*cp = TIFFBitRevTable[*cp];
+    while (n-- > 0)
-		cp++;
+    {
-	}
+        *cp = TIFFBitRevTable[*cp];
+        cp++;
+    }
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_thunder.c

@@ -41,166 +41,158 @@
  * or 3-bit delta values are used, with the deltas packed
  * into a single byte.
  */
-#define	THUNDER_DATA		0x3f	/* mask for 6-bit data */
+#define THUNDER_DATA 0x3f /* mask for 6-bit data */
-#define	THUNDER_CODE		0xc0	/* mask for 2-bit code word */
+#define THUNDER_CODE 0xc0 /* mask for 2-bit code word */
 /* code values */
-#define	THUNDER_RUN		0x00	/* run of pixels w/ encoded count */
+#define THUNDER_RUN 0x00        /* run of pixels w/ encoded count */
-#define	THUNDER_2BITDELTAS	0x40	/* 3 pixels w/ encoded 2-bit deltas */
+#define THUNDER_2BITDELTAS 0x40 /* 3 pixels w/ encoded 2-bit deltas */
-#define	    DELTA2_SKIP		2	/* skip code for 2-bit deltas */
+#define DELTA2_SKIP 2           /* skip code for 2-bit deltas */
-#define	THUNDER_3BITDELTAS	0x80	/* 2 pixels w/ encoded 3-bit deltas */
+#define THUNDER_3BITDELTAS 0x80 /* 2 pixels w/ encoded 3-bit deltas */
-#define	    DELTA3_SKIP		4	/* skip code for 3-bit deltas */
+#define DELTA3_SKIP 4           /* skip code for 3-bit deltas */
-#define	THUNDER_RAW		0xc0	/* raw data encoded */
+#define THUNDER_RAW 0xc0        /* raw data encoded */
 
-static const int twobitdeltas[4] = { 0, 1, 0, -1 };
+static const int twobitdeltas[4] = {0, 1, 0, -1};
-static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 };
+static const int threebitdeltas[8] = {0, 1, 2, 3, 0, -3, -2, -1};
 
-#define	SETPIXEL(op, v) {                     \
+#define SETPIXEL(op, v)                                                        \
-	lastpixel = (v) & 0xf;                \
+    {                                                                          \
-        if ( npixels < maxpixels )         \
+        lastpixel = (v)&0xf;                                                   \
-        {                                     \
+        if (npixels < maxpixels)                                               \
-	  if (npixels++ & 1)                  \
+        {                                                                      \
-	    *op++ |= lastpixel;               \
+            if (npixels++ & 1)                                                 \
-	  else                                \
+                *op++ |= lastpixel;                                            \
-	    op[0] = (uint8) (lastpixel << 4); \
+            else                                                               \
-        }                                     \
+                op[0] = (uint8_t)(lastpixel << 4);                             \
+        }                                                                      \
+    }
+
+static int ThunderSetupDecode(TIFF *tif)
+{
+    static const char module[] = "ThunderSetupDecode";
+
+    if (tif->tif_dir.td_bitspersample != 4)
+    {
+        TIFFErrorExtR(tif, module,
+                      "Wrong bitspersample value (%d), Thunder decoder only "
+                      "supports 4bits per sample.",
+                      (int)tif->tif_dir.td_bitspersample);
+        return 0;
+    }
+
+    return (1);
 }
 
-static int
+static int ThunderDecode(TIFF *tif, uint8_t *op, tmsize_t maxpixels)
-ThunderSetupDecode(TIFF* tif)
 {
-	static const char module[] = "ThunderSetupDecode";
+    static const char module[] = "ThunderDecode";
+    register unsigned char *bp;
+    register tmsize_t cc;
+    unsigned int lastpixel;
+    tmsize_t npixels;
 
-        if( tif->tif_dir.td_bitspersample != 4 )
+    bp = (unsigned char *)tif->tif_rawcp;
+    cc = tif->tif_rawcc;
+    lastpixel = 0;
+    npixels = 0;
+    while (cc > 0 && npixels < maxpixels)
+    {
+        int n, delta;
+
+        n = *bp++;
+        cc--;
+        switch (n & THUNDER_CODE)
         {
-                TIFFErrorExt(tif->tif_clientdata, module,
+            case THUNDER_RUN: /* pixel run */
-                             "Wrong bitspersample value (%d), Thunder decoder only supports 4bits per sample.",
+                /*
-                             (int) tif->tif_dir.td_bitspersample );
+                 * Replicate the last pixel n times,
-                return 0;
+                 * where n is the lower-order 6 bits.
+                 */
+                if (npixels & 1)
+                {
+                    op[0] |= lastpixel;
+                    lastpixel = *op++;
+                    npixels++;
+                    n--;
+                }
+                else
+                    lastpixel |= lastpixel << 4;
+                npixels += n;
+                if (npixels < maxpixels)
+                {
+                    for (; n > 0; n -= 2)
+                        *op++ = (uint8_t)lastpixel;
+                }
+                if (n == -1)
+                    *--op &= 0xf0;
+                lastpixel &= 0xf;
+                break;
+            case THUNDER_2BITDELTAS: /* 2-bit deltas */
+                if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP)
+                    SETPIXEL(op,
+                             (unsigned)((int)lastpixel + twobitdeltas[delta]));
+                if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP)
+                    SETPIXEL(op,
+                             (unsigned)((int)lastpixel + twobitdeltas[delta]));
+                if ((delta = (n & 3)) != DELTA2_SKIP)
+                    SETPIXEL(op,
+                             (unsigned)((int)lastpixel + twobitdeltas[delta]));
+                break;
+            case THUNDER_3BITDELTAS: /* 3-bit deltas */
+                if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP)
+                    SETPIXEL(
+                        op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
+                if ((delta = (n & 7)) != DELTA3_SKIP)
+                    SETPIXEL(
+                        op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
+                break;
+            case THUNDER_RAW: /* raw data */
+                SETPIXEL(op, n);
+                break;
         }
+    }
+    tif->tif_rawcp = (uint8_t *)bp;
+    tif->tif_rawcc = cc;
+    if (npixels != maxpixels)
+    {
+        TIFFErrorExtR(tif, module,
+                      "%s data at scanline %lu (%" PRIu64 " != %" PRIu64 ")",
+                      npixels < maxpixels ? "Not enough" : "Too much",
+                      (unsigned long)tif->tif_row, (uint64_t)npixels,
+                      (uint64_t)maxpixels);
+        return (0);
+    }
 
-
+    return (1);
-	return (1);
 }
 
-static int
+static int ThunderDecodeRow(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
-ThunderDecode(TIFF* tif, uint8* op, tmsize_t maxpixels)
 {
-	static const char module[] = "ThunderDecode";
+    static const char module[] = "ThunderDecodeRow";
-	register unsigned char *bp;
+    uint8_t *row = buf;
-	register tmsize_t cc;
-	unsigned int lastpixel;
-	tmsize_t npixels;
 
-	bp = (unsigned char *)tif->tif_rawcp;
+    (void)s;
-	cc = tif->tif_rawcc;
+    if (occ % tif->tif_scanlinesize)
-	lastpixel = 0;
+    {
-	npixels = 0;
+        TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
-	while (cc > 0 && npixels < maxpixels) {
+        return (0);
-		int n, delta;
+    }
-
+    while (occ > 0)
-		n = *bp++;
+    {
-		cc--;
+        if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
-		switch (n & THUNDER_CODE) {
+            return (0);
-		case THUNDER_RUN:		/* pixel run */
+        occ -= tif->tif_scanlinesize;
-			/*
+        row += tif->tif_scanlinesize;
-			 * Replicate the last pixel n times,
+    }
-			 * where n is the lower-order 6 bits.
+    return (1);
-			 */
-			if (npixels & 1) {
-				op[0] |= lastpixel;
-				lastpixel = *op++; npixels++; n--;
-			} else
-				lastpixel |= lastpixel << 4;
-			npixels += n;
-			if (npixels < maxpixels) {
-				for (; n > 0; n -= 2)
-					*op++ = (uint8) lastpixel;
-			}
-			if (n == -1)
-				*--op &= 0xf0;
-			lastpixel &= 0xf;
-			break;
-		case THUNDER_2BITDELTAS:	/* 2-bit deltas */
-			if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP)
-				SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta]));
-			if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP)
-				SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta]));
-			if ((delta = (n & 3)) != DELTA2_SKIP)
-				SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta]));
-			break;
-		case THUNDER_3BITDELTAS:	/* 3-bit deltas */
-			if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP)
-				SETPIXEL(op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
-			if ((delta = (n & 7)) != DELTA3_SKIP)
-				SETPIXEL(op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
-			break;
-		case THUNDER_RAW:		/* raw data */
-			SETPIXEL(op, n);
-			break;
-		}
-	}
-	tif->tif_rawcp = (uint8*) bp;
-	tif->tif_rawcc = cc;
-	if (npixels != maxpixels) {
-#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
-		TIFFErrorExt(tif->tif_clientdata, module,
-			     "%s data at scanline %lu (%I64u != %I64u)",
-			     npixels < maxpixels ? "Not enough" : "Too much",
-			     (unsigned long) tif->tif_row,
-			     (unsigned __int64) npixels,
-			     (unsigned __int64) maxpixels);
-#else
-		TIFFErrorExt(tif->tif_clientdata, module,
-			     "%s data at scanline %lu (%llu != %llu)",
-			     npixels < maxpixels ? "Not enough" : "Too much",
-			     (unsigned long) tif->tif_row,
-			     (unsigned long long) npixels,
-			     (unsigned long long) maxpixels);
-#endif
-		return (0);
-	}
-
-        return (1);
 }
 
-static int
+int TIFFInitThunderScan(TIFF *tif, int scheme)
-ThunderDecodeRow(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
 {
-	static const char module[] = "ThunderDecodeRow";
+    (void)scheme;
-	uint8* row = buf;
 
-	(void) s;
+    tif->tif_setupdecode = ThunderSetupDecode;
-	if (occ % tif->tif_scanlinesize)
+    tif->tif_decoderow = ThunderDecodeRow;
-	{
+    tif->tif_decodestrip = ThunderDecodeRow;
-		TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
+    return (1);
-		return (0);
-	}
-	while (occ > 0) {
-		if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
-			return (0);
-		occ -= tif->tif_scanlinesize;
-		row += tif->tif_scanlinesize;
-	}
-	return (1);
-}
-
-int
-TIFFInitThunderScan(TIFF* tif, int scheme)
-{
-	(void) scheme;
-
-        tif->tif_setupdecode = ThunderSetupDecode;
-	tif->tif_decoderow = ThunderDecodeRow;
-	tif->tif_decodestrip = ThunderDecodeRow; 
-	return (1);
 }
 #endif /* THUNDER_SUPPORT */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_tile.c

@@ -32,234 +32,230 @@
 /*
  * Compute which tile an (x,y,z,s) value is in.
  */
-uint32
+uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
-TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
+                         uint16_t s)
 {
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint32 dx = td->td_tilewidth;
+    uint32_t dx = td->td_tilewidth;
-	uint32 dy = td->td_tilelength;
+    uint32_t dy = td->td_tilelength;
-	uint32 dz = td->td_tiledepth;
+    uint32_t dz = td->td_tiledepth;
-	uint32 tile = 1;
+    uint32_t tile = 1;
 
-	if (td->td_imagedepth == 1)
+    if (td->td_imagedepth == 1)
-		z = 0;
+        z = 0;
-	if (dx == (uint32) -1)
+    if (dx == (uint32_t)-1)
-		dx = td->td_imagewidth;
+        dx = td->td_imagewidth;
-	if (dy == (uint32) -1)
+    if (dy == (uint32_t)-1)
-		dy = td->td_imagelength;
+        dy = td->td_imagelength;
-	if (dz == (uint32) -1)
+    if (dz == (uint32_t)-1)
-		dz = td->td_imagedepth;
+        dz = td->td_imagedepth;
-	if (dx != 0 && dy != 0 && dz != 0) {
+    if (dx != 0 && dy != 0 && dz != 0)
-		uint32 xpt = TIFFhowmany_32(td->td_imagewidth, dx);
+    {
-		uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy);
+        uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
-		uint32 zpt = TIFFhowmany_32(td->td_imagedepth, dz);
+        uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
+        uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
 
-		if (td->td_planarconfig == PLANARCONFIG_SEPARATE) 
+        if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
-			tile = (xpt*ypt*zpt)*s +
+            tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
-			     (xpt*ypt)*(z/dz) +
+                   xpt * (y / dy) + x / dx;
-			     xpt*(y/dy) +
+        else
-			     x/dx;
+            tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
-		else
+    }
-			tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx;
+    return (tile);
-	}
-	return (tile);
 }
 
 /*
  * Check an (x,y,z,s) coordinate
  * against the image bounds.
  */
-int
+int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
-TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
 {
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
 
-	if (x >= td->td_imagewidth) {
+    if (x >= td->td_imagewidth)
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+    {
-			     "%lu: Col out of range, max %lu",
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu",
-			     (unsigned long) x,
+                      (unsigned long)x, (unsigned long)(td->td_imagewidth - 1));
-			     (unsigned long) (td->td_imagewidth - 1));
+        return (0);
-		return (0);
+    }
-	}
+    if (y >= td->td_imagelength)
-	if (y >= td->td_imagelength) {
+    {
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu",
-			     "%lu: Row out of range, max %lu",
+                      (unsigned long)y,
-			     (unsigned long) y,
+                      (unsigned long)(td->td_imagelength - 1));
-			     (unsigned long) (td->td_imagelength - 1));
+        return (0);
-		return (0);
+    }
-	}
+    if (z >= td->td_imagedepth)
-	if (z >= td->td_imagedepth) {
+    {
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
-			     "%lu: Depth out of range, max %lu",
+                      (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
-			     (unsigned long) z,
+        return (0);
-			     (unsigned long) (td->td_imagedepth - 1));
+    }
-		return (0);
+    if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
-	}
+        s >= td->td_samplesperpixel)
-	if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
+    {
-	    s >= td->td_samplesperpixel) {
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+                      (unsigned long)s,
-			     "%lu: Sample out of range, max %lu",
+                      (unsigned long)(td->td_samplesperpixel - 1));
-			     (unsigned long) s,
+        return (0);
-			     (unsigned long) (td->td_samplesperpixel - 1));
+    }
-		return (0);
+    return (1);
-	}
-	return (1);
 }
 
 /*
  * Compute how many tiles are in an image.
  */
-uint32
+uint32_t TIFFNumberOfTiles(TIFF *tif)
-TIFFNumberOfTiles(TIFF* tif)
 {
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint32 dx = td->td_tilewidth;
+    uint32_t dx = td->td_tilewidth;
-	uint32 dy = td->td_tilelength;
+    uint32_t dy = td->td_tilelength;
-	uint32 dz = td->td_tiledepth;
+    uint32_t dz = td->td_tiledepth;
-	uint32 ntiles;
+    uint32_t ntiles;
 
-	if (dx == (uint32) -1)
+    if (dx == (uint32_t)-1)
-		dx = td->td_imagewidth;
+        dx = td->td_imagewidth;
-	if (dy == (uint32) -1)
+    if (dy == (uint32_t)-1)
-		dy = td->td_imagelength;
+        dy = td->td_imagelength;
-	if (dz == (uint32) -1)
+    if (dz == (uint32_t)-1)
-		dz = td->td_imagedepth;
+        dz = td->td_imagedepth;
-	ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
+    ntiles =
-	    _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
+        (dx == 0 || dy == 0 || dz == 0)
-	    TIFFhowmany_32(td->td_imagelength, dy),
+            ? 0
-	    "TIFFNumberOfTiles"),
+            : _TIFFMultiply32(
-	    TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
+                  tif,
-	if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
+                  _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
-		ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
+                                  TIFFhowmany_32(td->td_imagelength, dy),
-		    "TIFFNumberOfTiles");
+                                  "TIFFNumberOfTiles"),
-	return (ntiles);
+                  TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
+    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
+        ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
+                                 "TIFFNumberOfTiles");
+    return (ntiles);
 }
 
 /*
  * Compute the # bytes in each row of a tile.
  */
-uint64
+uint64_t TIFFTileRowSize64(TIFF *tif)
-TIFFTileRowSize64(TIFF* tif)
 {
-        static const char module[] = "TIFFTileRowSize64";
+    static const char module[] = "TIFFTileRowSize64";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	uint64 rowsize;
+    uint64_t rowsize;
-	uint64 tilerowsize;
+    uint64_t tilerowsize;
 
-	if (td->td_tilelength == 0)
+    if (td->td_tilelength == 0)
+    {
+        TIFFErrorExtR(tif, module, "Tile length is zero");
+        return 0;
+    }
+    if (td->td_tilewidth == 0)
+    {
+        TIFFErrorExtR(tif, module, "Tile width is zero");
+        return (0);
+    }
+    rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
+                              "TIFFTileRowSize");
+    if (td->td_planarconfig == PLANARCONFIG_CONTIG)
+    {
+        if (td->td_samplesperpixel == 0)
         {
-                TIFFErrorExt(tif->tif_clientdata,module,"Tile length is zero");
+            TIFFErrorExtR(tif, module, "Samples per pixel is zero");
-                return 0;
+            return 0;
         }
-        if (td->td_tilewidth == 0)
+        rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
-        {
+                                  "TIFFTileRowSize");
-                TIFFErrorExt(tif->tif_clientdata,module,"Tile width is zero");
+    }
-		return (0);
+    tilerowsize = TIFFhowmany8_64(rowsize);
-        }
+    if (tilerowsize == 0)
-	rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
+    {
-	    "TIFFTileRowSize");
+        TIFFErrorExtR(tif, module, "Computed tile row size is zero");
-	if (td->td_planarconfig == PLANARCONFIG_CONTIG)
+        return 0;
-        {
+    }
-                if (td->td_samplesperpixel == 0)
+    return (tilerowsize);
-                {
-                        TIFFErrorExt(tif->tif_clientdata,module,"Samples per pixel is zero");
-                        return 0;
-                }
-		rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
-		    "TIFFTileRowSize");
-        }
-        tilerowsize=TIFFhowmany8_64(rowsize);
-        if (tilerowsize == 0)
-        {
-                TIFFErrorExt(tif->tif_clientdata,module,"Computed tile row size is zero");
-                return 0;
-        }
-	return (tilerowsize);
 }
-tmsize_t
+tmsize_t TIFFTileRowSize(TIFF *tif)
-TIFFTileRowSize(TIFF* tif)
 {
-	static const char module[] = "TIFFTileRowSize";
+    static const char module[] = "TIFFTileRowSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFTileRowSize64(tif);
+    m = TIFFTileRowSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
  * Compute the # bytes in a variable length, row-aligned tile.
  */
-uint64
+uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
-TIFFVTileSize64(TIFF* tif, uint32 nrows)
 {
-	static const char module[] = "TIFFVTileSize64";
+    static const char module[] = "TIFFVTileSize64";
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
-	if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
+    if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
-	    td->td_tiledepth == 0)
+        td->td_tiledepth == 0)
-		return (0);
+        return (0);
-	if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
+    if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
-	    (td->td_photometric==PHOTOMETRIC_YCBCR)&&
+        (td->td_photometric == PHOTOMETRIC_YCBCR) &&
-	    (td->td_samplesperpixel==3)&&
+        (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
-	    (!isUpSampled(tif)))
+    {
-	{
+        /*
-		/*
+         * Packed YCbCr data contain one Cb+Cr for every
-		 * Packed YCbCr data contain one Cb+Cr for every
+         * HorizontalSampling*VerticalSampling Y values.
-		 * HorizontalSampling*VerticalSampling Y values.
+         * Must also roundup width and height when calculating
-		 * Must also roundup width and height when calculating
+         * since images that are not a multiple of the
-		 * since images that are not a multiple of the
+         * horizontal/vertical subsampling area include
-		 * horizontal/vertical subsampling area include
+         * YCbCr data for the extended image.
-		 * YCbCr data for the extended image.
+         */
-		 */
+        uint16_t ycbcrsubsampling[2];
-		uint16 ycbcrsubsampling[2];
+        uint16_t samplingblock_samples;
-		uint16 samplingblock_samples;
+        uint32_t samplingblocks_hor;
-		uint32 samplingblocks_hor;
+        uint32_t samplingblocks_ver;
-		uint32 samplingblocks_ver;
+        uint64_t samplingrow_samples;
-		uint64 samplingrow_samples;
+        uint64_t samplingrow_size;
-		uint64 samplingrow_size;
+        TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
-		TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
+                              ycbcrsubsampling + 0, ycbcrsubsampling + 1);
-		    ycbcrsubsampling+1);
+        if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
-		if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
+             ycbcrsubsampling[0] != 4) ||
-		    ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
+            (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
-		{
+             ycbcrsubsampling[1] != 4))
-			TIFFErrorExt(tif->tif_clientdata,module,
+        {
-				     "Invalid YCbCr subsampling (%dx%d)", 
+            TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
-				     ycbcrsubsampling[0], 
+                          ycbcrsubsampling[0], ycbcrsubsampling[1]);
-				     ycbcrsubsampling[1] );
+            return 0;
-			return 0;
+        }
-		}
+        samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
-		samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
+        samplingblocks_hor =
-		samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
+            TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
-		samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
+        samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
-		samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
+        samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
-		samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
+                                              samplingblock_samples, module);
-		return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
+        samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
-	}
+            tif, samplingrow_samples, td->td_bitspersample, module));
-	else
+        return (
-		return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
+            _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
+    }
+    else
+        return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
 }
-tmsize_t
+tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows)
-TIFFVTileSize(TIFF* tif, uint32 nrows)
 {
-	static const char module[] = "TIFFVTileSize";
+    static const char module[] = "TIFFVTileSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFVTileSize64(tif,nrows);
+    m = TIFFVTileSize64(tif, nrows);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
  * Compute the # bytes in a row-aligned tile.
  */
-uint64
+uint64_t TIFFTileSize64(TIFF *tif)
-TIFFTileSize64(TIFF* tif)
 {
-	return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
+    return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
 }
-tmsize_t
+tmsize_t TIFFTileSize(TIFF *tif)
-TIFFTileSize(TIFF* tif)
 {
-	static const char module[] = "TIFFTileSize";
+    static const char module[] = "TIFFTileSize";
-	uint64 m;
+    uint64_t m;
-	m=TIFFTileSize64(tif);
+    m = TIFFTileSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
@@ -268,32 +264,21 @@ TIFFTileSize(TIFF* tif)
  * request is <1 then we choose a size according
  * to certain heuristics.
  */
-void
+void TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
-TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
 {
-	(*tif->tif_deftilesize)(tif, tw, th);
+    (*tif->tif_deftilesize)(tif, tw, th);
 }
 
-void
+void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
-_TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
 {
-	(void) tif;
+    (void)tif;
-	if (*(int32*) tw < 1)
+    if (*(int32_t *)tw < 1)
-		*tw = 256;
+        *tw = 256;
-	if (*(int32*) th < 1)
+    if (*(int32_t *)th < 1)
-		*th = 256;
+        *th = 256;
-	/* roundup to a multiple of 16 per the spec */
+    /* roundup to a multiple of 16 per the spec */
-	if (*tw & 0xf)
+    if (*tw & 0xf)
-		*tw = TIFFroundup_32(*tw, 16);
+        *tw = TIFFroundup_32(*tw, 16);
-	if (*th & 0xf)
+    if (*th & 0xf)
-		*th = TIFFroundup_32(*th, 16);
+        *th = TIFFroundup_32(*th, 16);
 }
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_unix.c

@@ -30,7 +30,7 @@
 #include "tif_config.h"
 
 #ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
 #include <errno.h>
@@ -40,215 +40,222 @@
 #include <sys/stat.h>
 
 #ifdef HAVE_UNISTD_H
-# include <unistd.h>
+#include <unistd.h>
 #endif
 
 #ifdef HAVE_FCNTL_H
-# include <fcntl.h>
+#include <fcntl.h>
 #endif
 
 #ifdef HAVE_IO_H
-# include <io.h>
+#include <io.h>
 #endif
 
 #include "tiffiop.h"
 
-
 #define TIFF_IO_MAX 2147483647U
 
-
 typedef union fd_as_handle_union
 {
-	int fd;
+    int fd;
-	thandle_t h;
+    thandle_t h;
 } fd_as_handle_union_t;
 
-static tmsize_t
+static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
-_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
 {
-	fd_as_handle_union_t fdh;
+    fd_as_handle_union_t fdh;
-        const size_t bytes_total = (size_t) size;
+    const size_t bytes_total = (size_t)size;
-        size_t bytes_read;
+    size_t bytes_read;
-        tmsize_t count = -1;
+    tmsize_t count = -1;
-	if ((tmsize_t) bytes_total != size)
+    if ((tmsize_t)bytes_total != size)
-	{
+    {
-		errno=EINVAL;
+        errno = EINVAL;
-		return (tmsize_t) -1;
+        return (tmsize_t)-1;
-	}
+    }
-	fdh.h = fd;
+    fdh.h = fd;
-        for (bytes_read=0; bytes_read < bytes_total; bytes_read+=count)
+    for (bytes_read = 0; bytes_read < bytes_total; bytes_read += count)
-        {
+    {
-                char *buf_offset = (char *) buf+bytes_read;
+        char *buf_offset = (char *)buf + bytes_read;
-                size_t io_size = bytes_total-bytes_read;
+        size_t io_size = bytes_total - bytes_read;
-                if (io_size > TIFF_IO_MAX)
+        if (io_size > TIFF_IO_MAX)
-                        io_size = TIFF_IO_MAX;
+            io_size = TIFF_IO_MAX;
-                count=read(fdh.fd, buf_offset, (TIFFIOSize_t) io_size);
+        count = read(fdh.fd, buf_offset, (TIFFIOSize_t)io_size);
-                if (count <= 0)
+        if (count <= 0)
-                        break;
+            break;
-        }
+    }
-        if (count < 0)
+    if (count < 0)
-                return (tmsize_t)-1;
+        return (tmsize_t)-1;
-        return (tmsize_t) bytes_read;
+    return (tmsize_t)bytes_read;
 }
 
-static tmsize_t
+static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
-_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
 {
-	fd_as_handle_union_t fdh;
+    fd_as_handle_union_t fdh;
-	const size_t bytes_total = (size_t) size;
+    const size_t bytes_total = (size_t)size;
-        size_t bytes_written;
+    size_t bytes_written;
-        tmsize_t count = -1;
+    tmsize_t count = -1;
-	if ((tmsize_t) bytes_total != size)
+    if ((tmsize_t)bytes_total != size)
-	{
+    {
-		errno=EINVAL;
+        errno = EINVAL;
-		return (tmsize_t) -1;
+        return (tmsize_t)-1;
-	}
+    }
-	fdh.h = fd;
+    fdh.h = fd;
-        for (bytes_written=0; bytes_written < bytes_total; bytes_written+=count)
+    for (bytes_written = 0; bytes_written < bytes_total; bytes_written += count)
-        {
+    {
-                const char *buf_offset = (char *) buf+bytes_written;
+        const char *buf_offset = (char *)buf + bytes_written;
-                size_t io_size = bytes_total-bytes_written;
+        size_t io_size = bytes_total - bytes_written;
-                if (io_size > TIFF_IO_MAX)
+        if (io_size > TIFF_IO_MAX)
-                        io_size = TIFF_IO_MAX;
+            io_size = TIFF_IO_MAX;
-                count=write(fdh.fd, buf_offset, (TIFFIOSize_t) io_size);
+        count = write(fdh.fd, buf_offset, (TIFFIOSize_t)io_size);
-                if (count <= 0)
+        if (count <= 0)
-                        break;
+            break;
-        }
+    }
-        if (count < 0)
+    if (count < 0)
-                return (tmsize_t)-1;
+        return (tmsize_t)-1;
-        return (tmsize_t) bytes_written;
+    return (tmsize_t)bytes_written;
-	/* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */
+    /* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */
 }
 
-static uint64
+static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
-_tiffSeekProc(thandle_t fd, uint64 off, int whence)
 {
-	fd_as_handle_union_t fdh;
+    fd_as_handle_union_t fdh;
-	_TIFF_off_t off_io = (_TIFF_off_t) off;
+    _TIFF_off_t off_io = (_TIFF_off_t)off;
-	if ((uint64) off_io != off)
+    if ((uint64_t)off_io != off)
-	{
+    {
-		errno=EINVAL;
+        errno = EINVAL;
-		return (uint64) -1; /* this is really gross */
+        return (uint64_t)-1; /* this is really gross */
-	}
+    }
-	fdh.h = fd;
+    fdh.h = fd;
-	return((uint64)_TIFF_lseek_f(fdh.fd,off_io,whence));
+    return ((uint64_t)_TIFF_lseek_f(fdh.fd, off_io, whence));
 }
 
-static int
+static int _tiffCloseProc(thandle_t fd)
-_tiffCloseProc(thandle_t fd)
 {
-	fd_as_handle_union_t fdh;
+    fd_as_handle_union_t fdh;
-	fdh.h = fd;
+    fdh.h = fd;
-	return(close(fdh.fd));
+    return (close(fdh.fd));
 }
 
-static uint64
+static uint64_t _tiffSizeProc(thandle_t fd)
-_tiffSizeProc(thandle_t fd)
 {
-	_TIFF_stat_s sb;
+    _TIFF_stat_s sb;
-	fd_as_handle_union_t fdh;
+    fd_as_handle_union_t fdh;
-	fdh.h = fd;
+    fdh.h = fd;
-	if (_TIFF_fstat_f(fdh.fd,&sb)<0)
+    if (_TIFF_fstat_f(fdh.fd, &sb) < 0)
-		return(0);
+        return (0);
-	else
+    else
-		return((uint64)sb.st_size);
+        return ((uint64_t)sb.st_size);
 }
 
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 
-static int
+static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
-_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
 {
-	uint64 size64 = _tiffSizeProc(fd);
+    uint64_t size64 = _tiffSizeProc(fd);
-	tmsize_t sizem = (tmsize_t)size64;
+    tmsize_t sizem = (tmsize_t)size64;
-	if (size64 && (uint64)sizem==size64) {
+    if (size64 && (uint64_t)sizem == size64)
-		fd_as_handle_union_t fdh;
+    {
-		fdh.h = fd;
+        fd_as_handle_union_t fdh;
-		*pbase = (void*)
+        fdh.h = fd;
-		    mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
+        *pbase =
-		if (*pbase != (void*) -1) {
+            (void *)mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
-			*psize = (tmsize_t)sizem;
+        if (*pbase != (void *)-1)
-			return (1);
+        {
-		}
+            *psize = (tmsize_t)sizem;
-	}
+            return (1);
-	return (0);
+        }
+    }
+    return (0);
 }
 
-static void
+static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
-_tiffUnmapProc(thandle_t fd, void* base, toff_t size)
 {
-	(void) fd;
+    (void)fd;
-	(void) munmap(base, (off_t) size);
+    (void)munmap(base, (off_t)size);
 }
-#else /* !HAVE_MMAP */
+#else  /* !HAVE_MMAP */
-static int
+static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
-_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
 {
-	(void) fd; (void) pbase; (void) psize;
+    (void)fd;
-	return (0);
+    (void)pbase;
+    (void)psize;
+    return (0);
 }
 
-static void
+static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
-_tiffUnmapProc(thandle_t fd, void* base, toff_t size)
 {
-	(void) fd; (void) base; (void) size;
+    (void)fd;
+    (void)base;
+    (void)size;
 }
 #endif /* !HAVE_MMAP */
 
 /*
  * Open a TIFF file descriptor for read/writing.
  */
-TIFF*
+TIFF *TIFFFdOpen(int fd, const char *name, const char *mode)
-TIFFFdOpen(int fd, const char* name, const char* mode)
 {
-	TIFF* tif;
+    return TIFFFdOpenExt(fd, name, mode, NULL);
+}
 
-	fd_as_handle_union_t fdh;
+TIFF *TIFFFdOpenExt(int fd, const char *name, const char *mode,
-	fdh.fd = fd;
+                    TIFFOpenOptions *opts)
-	tif = TIFFClientOpen(name, mode,
+{
-	    fdh.h,
+    TIFF *tif;
-	    _tiffReadProc, _tiffWriteProc,
+
-	    _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
+    fd_as_handle_union_t fdh;
-	    _tiffMapProc, _tiffUnmapProc);
+    fdh.fd = fd;
-	if (tif)
+    tif = TIFFClientOpenExt(name, mode, fdh.h, _tiffReadProc, _tiffWriteProc,
-		tif->tif_fd = fd;
+                            _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
-	return (tif);
+                            _tiffMapProc, _tiffUnmapProc, opts);
+    if (tif)
+        tif->tif_fd = fd;
+    return (tif);
 }
 
 /*
  * Open a TIFF file for read/writing.
  */
-TIFF*
+TIFF *TIFFOpen(const char *name, const char *mode)
-TIFFOpen(const char* name, const char* mode)
 {
-	static const char module[] = "TIFFOpen";
+    return TIFFOpenExt(name, mode, NULL);
-	int m, fd;
+}
-	TIFF* tif;
 
-	m = _TIFFgetMode(mode, module);
+TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
-	if (m == -1)
+{
-		return ((TIFF*)0);
+    static const char module[] = "TIFFOpen";
+    int m, fd;
+    TIFF *tif;
+
+    m = _TIFFgetMode(opts, NULL, mode, module);
+    if (m == -1)
+        return ((TIFF *)0);
 
 /* for cygwin and mingw */
 #ifdef O_BINARY
-	m |= O_BINARY;
+    m |= O_BINARY;
 #endif
 
-	fd = open(name, m, 0666);
+    fd = open(name, m, 0666);
-	if (fd < 0) {
+    if (fd < 0)
-		if (errno > 0 && strerror(errno) != NULL ) {
+    {
-			TIFFErrorExt(0, module, "%s: %s", name, strerror(errno) );
+        if (errno > 0 && strerror(errno) != NULL)
-		} else {
+        {
-			TIFFErrorExt(0, module, "%s: Cannot open", name);
+            _TIFFErrorEarly(opts, NULL, module, "%s: %s", name,
-		}
+                            strerror(errno));
-		return ((TIFF *)0);
+        }
-	}
+        else
+        {
+            _TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
+        }
+        return ((TIFF *)0);
+    }
 
-	tif = TIFFFdOpen((int)fd, name, mode);
+    tif = TIFFFdOpenExt((int)fd, name, mode, opts);
-	if(!tif)
+    if (!tif)
-		close(fd);
+        close(fd);
-	return tif;
+    return tif;
 }
 
 #ifdef __WIN32__
@@ -256,129 +263,108 @@ TIFFOpen(const char* name, const char* mode)
 /*
  * Open a TIFF file with a Unicode filename, for read/writing.
  */
-TIFF*
+TIFF *TIFFOpenW(const wchar_t *name, const char *mode)
-TIFFOpenW(const wchar_t* name, const char* mode)
 {
-	static const char module[] = "TIFFOpenW";
+    return TIFFOpenWExt(name, mode, NULL);
-	int m, fd;
+}
-	int mbsize;
+TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
-	char *mbname;
+{
-	TIFF* tif;
+    static const char module[] = "TIFFOpenW";
+    int m, fd;
+    int mbsize;
+    char *mbname;
+    TIFF *tif;
 
-	m = _TIFFgetMode(mode, module);
+    m = _TIFFgetMode(opts, NULL, mode, module);
-	if (m == -1)
+    if (m == -1)
-		return ((TIFF*)0);
+        return ((TIFF *)0);
 
 /* for cygwin and mingw */
 #ifdef O_BINARY
-	m |= O_BINARY;
+    m |= O_BINARY;
 #endif
 
-	fd = _wopen(name, m, 0666);
+    fd = _wopen(name, m, 0666);
-	if (fd < 0) {
+    if (fd < 0)
-		TIFFErrorExt(0, module, "%ls: Cannot open", name);
+    {
-		return ((TIFF *)0);
+        _TIFFErrorEarly(opts, NULL, module, "%ls: Cannot open", name);
-	}
+        return ((TIFF *)0);
+    }
 
-	mbname = NULL;
+    mbname = NULL;
-	mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
+    mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
-	if (mbsize > 0) {
+    if (mbsize > 0)
-		mbname = _TIFFmalloc(mbsize);
+    {
-		if (!mbname) {
+        mbname = _TIFFmalloc(mbsize);
-			TIFFErrorExt(0, module,
+        if (!mbname)
-			"Can't allocate space for filename conversion buffer");
+        {
-			return ((TIFF*)0);
+            _TIFFErrorEarly(
-		}
+                opts, NULL, module,
+                "Can't allocate space for filename conversion buffer");
+            return ((TIFF *)0);
+        }
 
-		WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
+        WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL);
-				    NULL, NULL);
+    }
-	}
 
-	tif = TIFFFdOpen((int)fd, (mbname != NULL) ? mbname : "<unknown>",
+    tif = TIFFFdOpenExt((int)fd, (mbname != NULL) ? mbname : "<unknown>", mode,
-			 mode);
+                        opts);
 
-	_TIFFfree(mbname);
+    _TIFFfree(mbname);
 
-	if(!tif)
+    if (!tif)
-		close(fd);
+        close(fd);
-	return tif;
+    return tif;
 }
 #endif
 
-void*
+void *_TIFFmalloc(tmsize_t s)
-_TIFFmalloc(tmsize_t s)
 {
-        if (s == 0)
+    if (s == 0)
-                return ((void *) NULL);
+        return ((void *)NULL);
 
-	return (malloc((size_t) s));
+    return (malloc((size_t)s));
 }
 
-void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
+void *_TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
 {
-    if( nmemb == 0 || siz == 0 )
+    if (nmemb == 0 || siz == 0)
-        return ((void *) NULL);
+        return ((void *)NULL);
 
-    return calloc((size_t) nmemb, (size_t)siz);
+    return calloc((size_t)nmemb, (size_t)siz);
 }
 
-void
+void _TIFFfree(void *p) { free(p); }
-_TIFFfree(void* p)
+
+void *_TIFFrealloc(void *p, tmsize_t s) { return (realloc(p, (size_t)s)); }
+
+void _TIFFmemset(void *p, int v, tmsize_t c) { memset(p, v, (size_t)c); }
+
+void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
 {
-	free(p);
+    memcpy(d, s, (size_t)c);
 }
 
-void*
+int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
-_TIFFrealloc(void* p, tmsize_t s)
 {
-	return (realloc(p, (size_t) s));
+    return (memcmp(p1, p2, (size_t)c));
 }
 
-void
+static void unixWarningHandler(const char *module, const char *fmt, va_list ap)
-_TIFFmemset(void* p, int v, tmsize_t c)
 {
-	memset(p, v, (size_t) c);
+    if (module != NULL)
-}
+        fprintf(stderr, "%s: ", module);
-
+    fprintf(stderr, "Warning, ");
-void
+    vfprintf(stderr, fmt, ap);
-_TIFFmemcpy(void* d, const void* s, tmsize_t c)
+    fprintf(stderr, ".\n");
-{
-	memcpy(d, s, (size_t) c);
-}
-
-int
-_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
-{
-	return (memcmp(p1, p2, (size_t) c));
-}
-
-static void
-unixWarningHandler(const char* module, const char* fmt, va_list ap)
-{
-	if (module != NULL)
-		fprintf(stderr, "%s: ", module);
-	fprintf(stderr, "Warning, ");
-	vfprintf(stderr, fmt, ap);
-	fprintf(stderr, ".\n");
 }
 TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
 
-static void
+static void unixErrorHandler(const char *module, const char *fmt, va_list ap)
-unixErrorHandler(const char* module, const char* fmt, va_list ap)
 {
-	if (module != NULL)
+    if (module != NULL)
-		fprintf(stderr, "%s: ", module);
+        fprintf(stderr, "%s: ", module);
-	vfprintf(stderr, fmt, ap);
+    vfprintf(stderr, fmt, ap);
-	fprintf(stderr, ".\n");
+    fprintf(stderr, ".\n");
 }
 TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_version.c

@@ -25,15 +25,4 @@
 
 static const char TIFFVersion[] = TIFFLIB_VERSION_STR;
 
-const char*
+const char *TIFFGetVersion(void) { return (TIFFVersion); }
-TIFFGetVersion(void)
-{
-	return (TIFFVersion);
-}
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_warning.c

@@ -29,59 +29,77 @@
 
 TIFFErrorHandlerExt _TIFFwarningHandlerExt = NULL;
 
-TIFFErrorHandler
+TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler handler)
-TIFFSetWarningHandler(TIFFErrorHandler handler)
 {
-	TIFFErrorHandler prev = _TIFFwarningHandler;
+    TIFFErrorHandler prev = _TIFFwarningHandler;
-	_TIFFwarningHandler = handler;
+    _TIFFwarningHandler = handler;
-	return (prev);
+    return (prev);
 }
 
-TIFFErrorHandlerExt
+TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt handler)
-TIFFSetWarningHandlerExt(TIFFErrorHandlerExt handler)
 {
-	TIFFErrorHandlerExt prev = _TIFFwarningHandlerExt;
+    TIFFErrorHandlerExt prev = _TIFFwarningHandlerExt;
-	_TIFFwarningHandlerExt = handler;
+    _TIFFwarningHandlerExt = handler;
-	return (prev);
+    return (prev);
 }
 
-void
+void TIFFWarning(const char *module, const char *fmt, ...)
-TIFFWarning(const char* module, const char* fmt, ...)
 {
-	va_list ap;
+    va_list ap;
-	if (_TIFFwarningHandler) {
+    if (_TIFFwarningHandler)
-		va_start(ap, fmt);
+    {
-		(*_TIFFwarningHandler)(module, fmt, ap);
+        va_start(ap, fmt);
-		va_end(ap);
+        (*_TIFFwarningHandler)(module, fmt, ap);
-	}
+        va_end(ap);
-	if (_TIFFwarningHandlerExt) {
+    }
-		va_start(ap, fmt);
+    if (_TIFFwarningHandlerExt)
-		(*_TIFFwarningHandlerExt)(0, module, fmt, ap);
+    {
-		va_end(ap);
+        va_start(ap, fmt);
-	}
+        (*_TIFFwarningHandlerExt)(0, module, fmt, ap);
+        va_end(ap);
+    }
 }
 
-void
+void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt, ...)
-TIFFWarningExt(thandle_t fd, const char* module, const char* fmt, ...)
 {
-	va_list ap;
+    va_list ap;
-	if (_TIFFwarningHandler) {
+    if (_TIFFwarningHandler)
-		va_start(ap, fmt);	
+    {
-		(*_TIFFwarningHandler)(module, fmt, ap);
+        va_start(ap, fmt);
-		va_end(ap);
+        (*_TIFFwarningHandler)(module, fmt, ap);
-	}
+        va_end(ap);
-	if (_TIFFwarningHandlerExt) {
+    }
-		va_start(ap, fmt);
+    if (_TIFFwarningHandlerExt)
-		(*_TIFFwarningHandlerExt)(fd, module, fmt, ap);
+    {
-		va_end(ap);
+        va_start(ap, fmt);
-	}
+        (*_TIFFwarningHandlerExt)(fd, module, fmt, ap);
+        va_end(ap);
+    }
 }
 
-
+void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt, ...)
-/*
+{
- * Local Variables:
+    va_list ap;
- * mode: c
+    if (tif && tif->tif_warnhandler)
- * c-basic-offset: 8
+    {
- * fill-column: 78
+        va_start(ap, fmt);
- * End:
+        int stop = (*tif->tif_warnhandler)(tif, tif->tif_warnhandler_user_data,
- */
+                                           module, fmt, ap);
+        va_end(ap);
+        if (stop)
+            return;
+    }
+    if (_TIFFwarningHandler)
+    {
+        va_start(ap, fmt);
+        (*_TIFFwarningHandler)(module, fmt, ap);
+        va_end(ap);
+    }
+    if (_TIFFwarningHandlerExt)
+    {
+        va_start(ap, fmt);
+        (*_TIFFwarningHandlerExt)(tif ? tif->tif_clientdata : 0, module, fmt,
+                                  ap);
+        va_end(ap);
+    }
+}

3rdparty/libtiff/tif_win32.c

@@ -28,6 +28,7 @@
  */
 
 #include "tiffiop.h"
+#include <stdlib.h>
 
 #include <windows.h>
 
@@ -54,121 +55,111 @@ static inline thandle_t thandle_from_int(int ifd)
     return (thandle_t)(intptr_t)ifd;
 }
 
-static inline int thandle_to_int(thandle_t fd)
+static inline int thandle_to_int(thandle_t fd) { return (int)(intptr_t)fd; }
+
+static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
 {
-    return (int)(intptr_t)fd;
+    /* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes
+     * 32bit sizes, so we loop through the data in suitable 32bit sized
+     * chunks */
+    uint8_t *ma;
+    uint64_t mb;
+    DWORD n;
+    DWORD o;
+    tmsize_t p;
+    ma = (uint8_t *)buf;
+    mb = size;
+    p = 0;
+    while (mb > 0)
+    {
+        n = 0x80000000UL;
+        if ((uint64_t)n > mb)
+            n = (DWORD)mb;
+        if (!ReadFile(fd, (LPVOID)ma, n, &o, NULL))
+            return (0);
+        ma += o;
+        mb -= o;
+        p += o;
+        if (o != n)
+            break;
+    }
+    return (p);
 }
 
-static tmsize_t
+static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
-_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
 {
-	/* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes
+    /* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes
-	 * 32bit sizes, so we loop through the data in suitable 32bit sized
+     * 32bit sizes, so we loop through the data in suitable 32bit sized
-	 * chunks */
+     * chunks */
-	uint8* ma;
+    uint8_t *ma;
-	uint64 mb;
+    uint64_t mb;
-	DWORD n;
+    DWORD n;
-	DWORD o;
+    DWORD o;
-	tmsize_t p;
+    tmsize_t p;
-	ma=(uint8*)buf;
+    ma = (uint8_t *)buf;
-	mb=size;
+    mb = size;
-	p=0;
+    p = 0;
-	while (mb>0)
+    while (mb > 0)
-	{
+    {
-		n=0x80000000UL;
+        n = 0x80000000UL;
-		if ((uint64)n>mb)
+        if ((uint64_t)n > mb)
-			n=(DWORD)mb;
+            n = (DWORD)mb;
-		if (!ReadFile(fd,(LPVOID)ma,n,&o,NULL))
+        if (!WriteFile(fd, (LPVOID)ma, n, &o, NULL))
-			return(0);
+            return (0);
-		ma+=o;
+        ma += o;
-		mb-=o;
+        mb -= o;
-		p+=o;
+        p += o;
-		if (o!=n)
+        if (o != n)
-			break;
+            break;
-	}
+    }
-	return(p);
+    return (p);
 }
 
-static tmsize_t
+static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
-_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
 {
-	/* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes
+    LARGE_INTEGER offli;
-	 * 32bit sizes, so we loop through the data in suitable 32bit sized
+    DWORD dwMoveMethod;
-	 * chunks */
+    offli.QuadPart = off;
-	uint8* ma;
+    switch (whence)
-	uint64 mb;
+    {
-	DWORD n;
+        case SEEK_SET:
-	DWORD o;
+            dwMoveMethod = FILE_BEGIN;
-	tmsize_t p;
+            break;
-	ma=(uint8*)buf;
+        case SEEK_CUR:
-	mb=size;
+            dwMoveMethod = FILE_CURRENT;
-	p=0;
+            break;
-	while (mb>0)
+        case SEEK_END:
-	{
+            dwMoveMethod = FILE_END;
-		n=0x80000000UL;
+            break;
-		if ((uint64)n>mb)
+        default:
-			n=(DWORD)mb;
+            dwMoveMethod = FILE_BEGIN;
-		if (!WriteFile(fd,(LPVOID)ma,n,&o,NULL))
+            break;
-			return(0);
+    }
-		ma+=o;
+    offli.LowPart =
-		mb-=o;
+        SetFilePointer(fd, offli.LowPart, &offli.HighPart, dwMoveMethod);
-		p+=o;
+    if ((offli.LowPart == INVALID_SET_FILE_POINTER) &&
-		if (o!=n)
+        (GetLastError() != NO_ERROR))
-			break;
+        offli.QuadPart = 0;
-	}
+    return (offli.QuadPart);
-	return(p);
 }
 
-static uint64
+static int _tiffCloseProc(thandle_t fd) { return (CloseHandle(fd) ? 0 : -1); }
-_tiffSeekProc(thandle_t fd, uint64 off, int whence)
+
+static uint64_t _tiffSizeProc(thandle_t fd)
 {
-	LARGE_INTEGER offli;
+    LARGE_INTEGER m;
-	DWORD dwMoveMethod;
+    if (GetFileSizeEx(fd, &m))
-	offli.QuadPart = off;
+        return (m.QuadPart);
-	switch(whence)
+    else
-	{
+        return (0);
-		case SEEK_SET:
-			dwMoveMethod = FILE_BEGIN;
-			break;
-		case SEEK_CUR:
-			dwMoveMethod = FILE_CURRENT;
-			break;
-		case SEEK_END:
-			dwMoveMethod = FILE_END;
-			break;
-		default:
-			dwMoveMethod = FILE_BEGIN;
-			break;
-	}
-	offli.LowPart=SetFilePointer(fd,offli.LowPart,&offli.HighPart,dwMoveMethod);
-	if ((offli.LowPart==INVALID_SET_FILE_POINTER)&&(GetLastError()!=NO_ERROR))
-		offli.QuadPart=0;
-	return(offli.QuadPart);
 }
 
-static int
+static int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
-_tiffCloseProc(thandle_t fd)
 {
-	return (CloseHandle(fd) ? 0 : -1);
+    (void)fd;
-}
+    (void)pbase;
-
+    (void)psize;
-static uint64
+    return (0);
-_tiffSizeProc(thandle_t fd)
-{
-	LARGE_INTEGER m;
-	if (GetFileSizeEx(fd,&m))
-		return(m.QuadPart);
-	else
-		return(0);
-}
-
-static int
-_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
-{
-	(void) fd;
-	(void) pbase;
-	(void) psize;
-	return (0);
 }
 
 /*
@@ -182,45 +173,42 @@ _tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
  * This removes a nasty OS dependency and cures a problem
  * with Visual C++ 5.0
  */
-static int
+static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
-_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
 {
-	uint64 size;
+    uint64_t size;
-	tmsize_t sizem;
+    tmsize_t sizem;
-	HANDLE hMapFile;
+    HANDLE hMapFile;
 
-	size = _tiffSizeProc(fd);
+    size = _tiffSizeProc(fd);
-	sizem = (tmsize_t)size;
+    sizem = (tmsize_t)size;
-	if (!size || (uint64)sizem!=size)
+    if (!size || (uint64_t)sizem != size)
-		return (0);
+        return (0);
 
-	/* By passing in 0 for the maximum file size, it specifies that we
+    /* By passing in 0 for the maximum file size, it specifies that we
-	   create a file mapping object for the full file size. */
+       create a file mapping object for the full file size. */
-	hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL);
+    hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL);
-	if (hMapFile == NULL)
+    if (hMapFile == NULL)
-		return (0);
+        return (0);
-	*pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
+    *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
-	CloseHandle(hMapFile);
+    CloseHandle(hMapFile);
-	if (*pbase == NULL)
+    if (*pbase == NULL)
-		return (0);
+        return (0);
-	*psize = size;
+    *psize = size;
-	return(1);
+    return (1);
 }
 
-static void
+static void _tiffDummyUnmapProc(thandle_t fd, void *base, toff_t size)
-_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
 {
-	(void) fd;
+    (void)fd;
-	(void) base;
+    (void)base;
-	(void) size;
+    (void)size;
 }
 
-static void
+static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
-_tiffUnmapProc(thandle_t fd, void* base, toff_t size)
 {
-	(void) fd;
+    (void)fd;
-	(void) size;
+    (void)size;
-	UnmapViewOfFile(base);
+    UnmapViewOfFile(base);
 }
 
 /*
@@ -228,29 +216,36 @@ _tiffUnmapProc(thandle_t fd, void* base, toff_t size)
  * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
  * string, which forces the file to be opened unmapped.
  */
-TIFF*
+TIFF *TIFFFdOpen(int ifd, const char *name, const char *mode)
-TIFFFdOpen(int ifd, const char* name, const char* mode)
 {
-	TIFF* tif;
+    return TIFFFdOpenExt(ifd, name, mode, NULL);
-	int fSuppressMap;
+}
-	int m;
+
-	fSuppressMap=0;
+TIFF *TIFFFdOpenExt(int ifd, const char *name, const char *mode,
-	for (m=0; mode[m]!=0; m++)
+                    TIFFOpenOptions *opts)
-	{
+{
-		if (mode[m]=='u')
+    TIFF *tif;
-		{
+    int fSuppressMap;
-			fSuppressMap=1;
+    int m;
-			break;
+
-		}
+    fSuppressMap = 0;
-	}
+    for (m = 0; mode[m] != 0; m++)
-	tif = TIFFClientOpen(name, mode, thandle_from_int(ifd),
+    {
-			_tiffReadProc, _tiffWriteProc,
+        if (mode[m] == 'u')
-			_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
+        {
-			fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
+            fSuppressMap = 1;
-			fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc);
+            break;
-	if (tif)
+        }
-		tif->tif_fd = ifd;
+    }
-	return (tif);
+
+    tif = TIFFClientOpenExt(
+        name, mode, thandle_from_int(ifd), _tiffReadProc, _tiffWriteProc,
+        _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
+        fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
+        fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc, opts);
+    if (tif)
+        tif->tif_fd = ifd;
+    return (tif);
 }
 
 #ifndef _WIN32_WCE
@@ -258,184 +253,190 @@ TIFFFdOpen(int ifd, const char* name, const char* mode)
 /*
  * Open a TIFF file for read/writing.
  */
-TIFF*
+TIFF *TIFFOpen(const char *name, const char *mode)
-TIFFOpen(const char* name, const char* mode)
 {
-	static const char module[] = "TIFFOpen";
+    return TIFFOpenExt(name, mode, NULL);
-	thandle_t fd;
+}
-	int m;
-	DWORD dwMode;
-	TIFF* tif;
 
-	m = _TIFFgetMode(mode, module);
+TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
+{
+    static const char module[] = "TIFFOpen";
+    thandle_t fd;
+    int m;
+    DWORD dwMode;
+    TIFF *tif;
 
-	switch(m) {
+    m = _TIFFgetMode(opts, NULL, mode, module);
-		case O_RDONLY:			dwMode = OPEN_EXISTING; break;
-		case O_RDWR:			dwMode = OPEN_ALWAYS;   break;
-		case O_RDWR|O_CREAT:		dwMode = OPEN_ALWAYS;   break;
-		case O_RDWR|O_TRUNC:		dwMode = CREATE_ALWAYS; break;
-		case O_RDWR|O_CREAT|O_TRUNC:	dwMode = CREATE_ALWAYS; break;
-		default:			return ((TIFF*)0);
-	}
 
-	fd = (thandle_t)CreateFileA(name,
+    switch (m)
-		(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE),
+    {
-		FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
+        case O_RDONLY:
-		(m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
+            dwMode = OPEN_EXISTING;
-		NULL);
+            break;
-	if (fd == INVALID_HANDLE_VALUE) {
+        case O_RDWR:
-		TIFFErrorExt(0, module, "%s: Cannot open", name);
+            dwMode = OPEN_EXISTING;
-		return ((TIFF *)0);
+            break;
-	}
+        case O_RDWR | O_CREAT:
+            dwMode = OPEN_ALWAYS;
+            break;
+        case O_RDWR | O_TRUNC:
+            dwMode = CREATE_ALWAYS;
+            break;
+        case O_RDWR | O_CREAT | O_TRUNC:
+            dwMode = CREATE_ALWAYS;
+            break;
+        default:
+            return ((TIFF *)0);
+    }
 
-	tif = TIFFFdOpen(thandle_to_int(fd), name, mode);
+    fd = (thandle_t)CreateFileA(
-	if(!tif)
+        name, (m == O_RDONLY) ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE),
-		CloseHandle(fd);
+        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
-	return tif;
+        (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL,
+        NULL);
+    if (fd == INVALID_HANDLE_VALUE)
+    {
+        _TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
+        return ((TIFF *)0);
+    }
+
+    tif = TIFFFdOpenExt(thandle_to_int(fd), name, mode, opts);
+    if (!tif)
+        CloseHandle(fd);
+    return tif;
 }
 
 /*
  * Open a TIFF file with a Unicode filename, for read/writing.
  */
-TIFF*
+TIFF *TIFFOpenW(const wchar_t *name, const char *mode)
-TIFFOpenW(const wchar_t* name, const char* mode)
 {
-	static const char module[] = "TIFFOpenW";
+    return TIFFOpenWExt(name, mode, NULL);
-	thandle_t fd;
+}
-	int m;
-	DWORD dwMode;
-	int mbsize;
-	char *mbname;
-	TIFF *tif;
 
-	m = _TIFFgetMode(mode, module);
+TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
+{
+    static const char module[] = "TIFFOpenW";
+    thandle_t fd;
+    int m;
+    DWORD dwMode;
+    int mbsize;
+    char *mbname;
+    TIFF *tif;
 
-	switch(m) {
+    m = _TIFFgetMode(opts, NULL, mode, module);
-		case O_RDONLY:			dwMode = OPEN_EXISTING; break;
-		case O_RDWR:			dwMode = OPEN_ALWAYS;   break;
-		case O_RDWR|O_CREAT:		dwMode = OPEN_ALWAYS;   break;
-		case O_RDWR|O_TRUNC:		dwMode = CREATE_ALWAYS; break;
-		case O_RDWR|O_CREAT|O_TRUNC:	dwMode = CREATE_ALWAYS; break;
-		default:			return ((TIFF*)0);
-	}
 
-	fd = (thandle_t)CreateFileW(name,
+    switch (m)
-		(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE),
+    {
-		FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
+        case O_RDONLY:
-		(m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
+            dwMode = OPEN_EXISTING;
-		NULL);
+            break;
-	if (fd == INVALID_HANDLE_VALUE) {
+        case O_RDWR:
-		TIFFErrorExt(0, module, "%S: Cannot open", name);
+            dwMode = OPEN_EXISTING;
-		return ((TIFF *)0);
+            break;
-	}
+        case O_RDWR | O_CREAT:
+            dwMode = OPEN_ALWAYS;
+            break;
+        case O_RDWR | O_TRUNC:
+            dwMode = CREATE_ALWAYS;
+            break;
+        case O_RDWR | O_CREAT | O_TRUNC:
+            dwMode = CREATE_ALWAYS;
+            break;
+        default:
+            return ((TIFF *)0);
+    }
 
-	mbname = NULL;
+    fd = (thandle_t)CreateFileW(
-	mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
+        name, (m == O_RDONLY) ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE),
-	if (mbsize > 0) {
+        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
-		mbname = (char *)_TIFFmalloc(mbsize);
+        (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL,
-		if (!mbname) {
+        NULL);
-			TIFFErrorExt(0, module,
+    if (fd == INVALID_HANDLE_VALUE)
-			"Can't allocate space for filename conversion buffer");
+    {
-			return ((TIFF*)0);
+        _TIFFErrorEarly(opts, NULL, module, "%S: Cannot open", name);
-		}
+        return ((TIFF *)0);
+    }
 
-		WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
+    mbname = NULL;
-				    NULL, NULL);
+    mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
-	}
+    if (mbsize > 0)
+    {
+        mbname = (char *)_TIFFmalloc(mbsize);
+        if (!mbname)
+        {
+            _TIFFErrorEarly(
+                opts, NULL, module,
+                "Can't allocate space for filename conversion buffer");
+            return ((TIFF *)0);
+        }
 
-	tif = TIFFFdOpen(thandle_to_int(fd),
+        WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL);
-			 (mbname != NULL) ? mbname : "<unknown>", mode);
+    }
-	if(!tif)
-		CloseHandle(fd);
 
-	_TIFFfree(mbname);
+    tif = TIFFFdOpenExt(thandle_to_int(fd),
+                        (mbname != NULL) ? mbname : "<unknown>", mode, opts);
+    if (!tif)
+        CloseHandle(fd);
 
-	return tif;
+    _TIFFfree(mbname);
+
+    return tif;
 }
 
 #endif /* ndef _WIN32_WCE */
 
-void*
+void *_TIFFmalloc(tmsize_t s)
-_TIFFmalloc(tmsize_t s)
 {
-        if (s == 0)
+    if (s == 0)
-                return ((void *) NULL);
+        return ((void *)NULL);
 
-	return (malloc((size_t) s));
+    return (malloc((size_t)s));
 }
 
-void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
+void *_TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
 {
-    if( nmemb == 0 || siz == 0 )
+    if (nmemb == 0 || siz == 0)
-        return ((void *) NULL);
+        return ((void *)NULL);
 
-    return calloc((size_t) nmemb, (size_t)siz);
+    return calloc((size_t)nmemb, (size_t)siz);
 }
 
-void
+void _TIFFfree(void *p) { free(p); }
-_TIFFfree(void* p)
+
+void *_TIFFrealloc(void *p, tmsize_t s) { return (realloc(p, (size_t)s)); }
+
+void _TIFFmemset(void *p, int v, tmsize_t c) { memset(p, v, (size_t)c); }
+
+void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
 {
-	free(p);
+    memcpy(d, s, (size_t)c);
 }
 
-void*
+int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
-_TIFFrealloc(void* p, tmsize_t s)
 {
-	return (realloc(p, (size_t) s));
+    return (memcmp(p1, p2, (size_t)c));
-}
-
-void
-_TIFFmemset(void* p, int v, tmsize_t c)
-{
-	memset(p, v, (size_t) c);
-}
-
-void
-_TIFFmemcpy(void* d, const void* s, tmsize_t c)
-{
-	memcpy(d, s, (size_t) c);
-}
-
-int
-_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
-{
-	return (memcmp(p1, p2, (size_t) c));
 }
 
 #ifndef _WIN32_WCE
 
-#if (_MSC_VER < 1500)
+static void Win32WarningHandler(const char *module, const char *fmt, va_list ap)
-#  define vsnprintf _vsnprintf
-#endif
-
-static void
-Win32WarningHandler(const char* module, const char* fmt, va_list ap)
 {
-	if (module != NULL)
+    if (module != NULL)
-		fprintf(stderr, "%s: ", module);
+        fprintf(stderr, "%s: ", module);
-	fprintf(stderr, "Warning, ");
+    fprintf(stderr, "Warning, ");
-	vfprintf(stderr, fmt, ap);
+    vfprintf(stderr, fmt, ap);
-	fprintf(stderr, ".\n");
+    fprintf(stderr, ".\n");
 }
 TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
 
-static void
+static void Win32ErrorHandler(const char *module, const char *fmt, va_list ap)
-Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
 {
-	if (module != NULL)
+    if (module != NULL)
-		fprintf(stderr, "%s: ", module);
+        fprintf(stderr, "%s: ", module);
-	vfprintf(stderr, fmt, ap);
+    vfprintf(stderr, fmt, ap);
-	fprintf(stderr, ".\n");
+    fprintf(stderr, ".\n");
 }
 TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
 
 #endif /* ndef _WIN32_WCE */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tif_zstd.c

@@ -1,35 +1,35 @@
 /*
-* Copyright (c) 2017, Planet Labs
+ * Copyright (c) 2017, Planet Labs
-* Author: <even.rouault at spatialys.com>
+ * Author: <even.rouault at spatialys.com>
-*
+ *
-* Permission to use, copy, modify, distribute, and sell this software and
+ * Permission to use, copy, modify, distribute, and sell this software and
-* its documentation for any purpose is hereby granted without fee, provided
+ * its documentation for any purpose is hereby granted without fee, provided
-* that (i) the above copyright notices and this permission notice appear in
+ * that (i) the above copyright notices and this permission notice appear in
-* all copies of the software and related documentation, and (ii) the names of
+ * all copies of the software and related documentation, and (ii) the names of
-* Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
-* publicity relating to the software without the specific, prior written
+ * publicity relating to the software without the specific, prior written
-* permission of Sam Leffler and Silicon Graphics.
+ * permission of Sam Leffler and Silicon Graphics.
-*
+ *
-* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
-* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
-*
+ *
-* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
-* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
-* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
-* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
-* OF THIS SOFTWARE.
+ * OF THIS SOFTWARE.
-*/
+ */
 
 #include "tiffiop.h"
 #ifdef ZSTD_SUPPORT
 /*
-* TIFF Library.
+ * TIFF Library.
-*
+ *
-* ZSTD Compression Support
+ * ZSTD Compression Support
-*
+ *
-*/
+ */
 
 #include "tif_predict.h"
 #include "zstd.h"
@@ -37,406 +37,400 @@
 #include <stdio.h>
 
 /*
-* State block for each open TIFF file using ZSTD compression/decompression.
+ * State block for each open TIFF file using ZSTD compression/decompression.
-*/
+ */
-typedef struct {
+typedef struct
-        TIFFPredictorState predict;
+{
-        ZSTD_DStream*   dstream;
+    TIFFPredictorState predict;
-        ZSTD_CStream*   cstream;
+    ZSTD_DStream *dstream;
-        int             compression_level;      /* compression level */
+    ZSTD_CStream *cstream;
-        ZSTD_outBuffer  out_buffer;
+    int compression_level; /* compression level */
-        int             state;                  /* state flags */
+    ZSTD_outBuffer out_buffer;
+    int state; /* state flags */
 #define LSTATE_INIT_DECODE 0x01
 #define LSTATE_INIT_ENCODE 0x02
 
-        TIFFVGetMethod  vgetparent;            /* super-class method */
+    TIFFVGetMethod vgetparent; /* super-class method */
-        TIFFVSetMethod  vsetparent;            /* super-class method */
+    TIFFVSetMethod vsetparent; /* super-class method */
 } ZSTDState;
 
-#define LState(tif)             ((ZSTDState*) (tif)->tif_data)
+#define LState(tif) ((ZSTDState *)(tif)->tif_data)
-#define DecoderState(tif)       LState(tif)
+#define DecoderState(tif) LState(tif)
-#define EncoderState(tif)       LState(tif)
+#define EncoderState(tif) LState(tif)
 
-static int ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
+static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
-static int ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
+static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
 
-static int
+static int ZSTDFixupTags(TIFF *tif)
-ZSTDFixupTags(TIFF* tif)
 {
-        (void) tif;
+    (void)tif;
-        return 1;
+    return 1;
 }
 
-static int
+static int ZSTDSetupDecode(TIFF *tif)
-ZSTDSetupDecode(TIFF* tif)
 {
-        ZSTDState* sp = DecoderState(tif);
+    ZSTDState *sp = DecoderState(tif);
 
-        assert(sp != NULL);
+    assert(sp != NULL);
 
-        /* if we were last encoding, terminate this mode */
+    /* if we were last encoding, terminate this mode */
-        if (sp->state & LSTATE_INIT_ENCODE) {
+    if (sp->state & LSTATE_INIT_ENCODE)
-            ZSTD_freeCStream(sp->cstream);
+    {
-            sp->cstream = NULL;
+        ZSTD_freeCStream(sp->cstream);
-            sp->state = 0;
+        sp->cstream = NULL;
-        }
+        sp->state = 0;
+    }
 
-        sp->state |= LSTATE_INIT_DECODE;
+    sp->state |= LSTATE_INIT_DECODE;
-        return 1;
+    return 1;
 }
 
 /*
-* Setup state for decoding a strip.
+ * Setup state for decoding a strip.
-*/
+ */
-static int
+static int ZSTDPreDecode(TIFF *tif, uint16_t s)
-ZSTDPreDecode(TIFF* tif, uint16 s)
 {
-        static const char module[] = "ZSTDPreDecode";
+    static const char module[] = "ZSTDPreDecode";
-        ZSTDState* sp = DecoderState(tif);
+    ZSTDState *sp = DecoderState(tif);
-        size_t zstd_ret;
+    size_t zstd_ret;
 
-        (void) s;
+    (void)s;
-        assert(sp != NULL);
+    assert(sp != NULL);
 
-        if( (sp->state & LSTATE_INIT_DECODE) == 0 )
+    if ((sp->state & LSTATE_INIT_DECODE) == 0)
-            tif->tif_setupdecode(tif);
+        tif->tif_setupdecode(tif);
-
-        if( sp->dstream )
-        {
-            ZSTD_freeDStream(sp->dstream);
-            sp->dstream = NULL;
-        }
 
+    if (sp->dstream == NULL)
+    {
         sp->dstream = ZSTD_createDStream();
-        if( sp->dstream == NULL ) {
+        if (sp->dstream == NULL)
-            TIFFErrorExt(tif->tif_clientdata, module,
+        {
-                         "Cannot allocate decompression stream");
+            TIFFErrorExtR(tif, module, "Cannot allocate decompression stream");
             return 0;
         }
-        zstd_ret = ZSTD_initDStream(sp->dstream);
+    }
-        if( ZSTD_isError(zstd_ret) ) {
+
-            TIFFErrorExt(tif->tif_clientdata, module,
+    zstd_ret = ZSTD_initDStream(sp->dstream);
-                         "Error in ZSTD_initDStream(): %s",
+    if (ZSTD_isError(zstd_ret))
-                         ZSTD_getErrorName(zstd_ret));
+    {
+        TIFFErrorExtR(tif, module, "Error in ZSTD_initDStream(): %s",
+                      ZSTD_getErrorName(zstd_ret));
+        return 0;
+    }
+
+    return 1;
+}
+
+static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
+{
+    static const char module[] = "ZSTDDecode";
+    ZSTDState *sp = DecoderState(tif);
+    ZSTD_inBuffer in_buffer;
+    ZSTD_outBuffer out_buffer;
+    size_t zstd_ret;
+
+    (void)s;
+    assert(sp != NULL);
+    assert(sp->state == LSTATE_INIT_DECODE);
+
+    in_buffer.src = tif->tif_rawcp;
+    in_buffer.size = (size_t)tif->tif_rawcc;
+    in_buffer.pos = 0;
+
+    out_buffer.dst = op;
+    out_buffer.size = (size_t)occ;
+    out_buffer.pos = 0;
+
+    do
+    {
+        zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer, &in_buffer);
+        if (ZSTD_isError(zstd_ret))
+        {
+            TIFFErrorExtR(tif, module, "Error in ZSTD_decompressStream(): %s",
+                          ZSTD_getErrorName(zstd_ret));
             return 0;
         }
+    } while (zstd_ret != 0 && in_buffer.pos < in_buffer.size &&
+             out_buffer.pos < out_buffer.size);
 
-        return 1;
+    if (out_buffer.pos < (size_t)occ)
+    {
+        TIFFErrorExtR(tif, module,
+                      "Not enough data at scanline %lu (short %lu bytes)",
+                      (unsigned long)tif->tif_row,
+                      (unsigned long)((size_t)occ - out_buffer.pos));
+        return 0;
+    }
+
+    tif->tif_rawcp += in_buffer.pos;
+    tif->tif_rawcc -= in_buffer.pos;
+
+    return 1;
 }
 
-static int
+static int ZSTDSetupEncode(TIFF *tif)
-ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 {
-        static const char module[] = "ZSTDDecode";
+    ZSTDState *sp = EncoderState(tif);
-        ZSTDState* sp = DecoderState(tif);
-        ZSTD_inBuffer   in_buffer;
-        ZSTD_outBuffer  out_buffer;
-        size_t          zstd_ret;
 
-        (void) s;
+    assert(sp != NULL);
-        assert(sp != NULL);
+    if (sp->state & LSTATE_INIT_DECODE)
-        assert(sp->state == LSTATE_INIT_DECODE);
+    {
+        ZSTD_freeDStream(sp->dstream);
+        sp->dstream = NULL;
+        sp->state = 0;
+    }
 
-        in_buffer.src = tif->tif_rawcp;
+    sp->state |= LSTATE_INIT_ENCODE;
-        in_buffer.size = (size_t) tif->tif_rawcc;
+    return 1;
-        in_buffer.pos = 0;
-
-        out_buffer.dst = op;
-        out_buffer.size = (size_t) occ;
-        out_buffer.pos = 0;
-
-        do {
-                zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer,
-                                                 &in_buffer);
-                if( ZSTD_isError(zstd_ret) ) {
-                    TIFFErrorExt(tif->tif_clientdata, module,
-                                "Error in ZSTD_decompressStream(): %s",
-                                ZSTD_getErrorName(zstd_ret));
-                    return 0;
-                }
-        } while( zstd_ret != 0 &&
-                 in_buffer.pos < in_buffer.size &&
-                 out_buffer.pos < out_buffer.size );
-
-        if (out_buffer.pos < (size_t)occ) {
-                TIFFErrorExt(tif->tif_clientdata, module,
-                    "Not enough data at scanline %lu (short %lu bytes)",
-                    (unsigned long) tif->tif_row,
-                    (unsigned long) (size_t)occ - out_buffer.pos);
-                return 0;
-        }
-
-        tif->tif_rawcp += in_buffer.pos;
-        tif->tif_rawcc -= in_buffer.pos;
-
-        return 1;
-}
-
-static int
-ZSTDSetupEncode(TIFF* tif)
-{
-        ZSTDState* sp = EncoderState(tif);
-
-        assert(sp != NULL);
-        if (sp->state & LSTATE_INIT_DECODE) {
-                ZSTD_freeDStream(sp->dstream);
-                sp->dstream = NULL;
-                sp->state = 0;
-        }
-
-        sp->state |= LSTATE_INIT_ENCODE;
-        return 1;
 }
 
 /*
-* Reset encoding state at the start of a strip.
+ * Reset encoding state at the start of a strip.
-*/
+ */
-static int
+static int ZSTDPreEncode(TIFF *tif, uint16_t s)
-ZSTDPreEncode(TIFF* tif, uint16 s)
 {
-        static const char module[] = "ZSTDPreEncode";
+    static const char module[] = "ZSTDPreEncode";
-        ZSTDState *sp = EncoderState(tif);
+    ZSTDState *sp = EncoderState(tif);
-        size_t zstd_ret;
+    size_t zstd_ret;
 
-        (void) s;
+    (void)s;
-        assert(sp != NULL);
+    assert(sp != NULL);
-        if( sp->state != LSTATE_INIT_ENCODE )
+    if (sp->state != LSTATE_INIT_ENCODE)
-            tif->tif_setupencode(tif);
+        tif->tif_setupencode(tif);
 
-        if (sp->cstream) {
+    if (sp->cstream == NULL)
-            ZSTD_freeCStream(sp->cstream);
+    {
-            sp->cstream = NULL;
-        }
         sp->cstream = ZSTD_createCStream();
-        if( sp->cstream == NULL ) {
+        if (sp->cstream == NULL)
-            TIFFErrorExt(tif->tif_clientdata, module,
+        {
-                         "Cannot allocate compression stream");
+            TIFFErrorExtR(tif, module, "Cannot allocate compression stream");
             return 0;
         }
+    }
 
-        zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level);
+    zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level);
-        if( ZSTD_isError(zstd_ret) ) {
+    if (ZSTD_isError(zstd_ret))
-            TIFFErrorExt(tif->tif_clientdata, module,
+    {
-                         "Error in ZSTD_initCStream(): %s",
+        TIFFErrorExtR(tif, module, "Error in ZSTD_initCStream(): %s",
-                         ZSTD_getErrorName(zstd_ret));
+                      ZSTD_getErrorName(zstd_ret));
-            return 0;
+        return 0;
-        }
+    }
 
-        sp->out_buffer.dst = tif->tif_rawdata;
+    sp->out_buffer.dst = tif->tif_rawdata;
-        sp->out_buffer.size = (size_t)tif->tif_rawdatasize;
+    sp->out_buffer.size = (size_t)tif->tif_rawdatasize;
-        sp->out_buffer.pos = 0;
+    sp->out_buffer.pos = 0;
 
-        return 1;
+    return 1;
 }
 
 /*
-* Encode a chunk of pixels.
+ * Encode a chunk of pixels.
-*/
+ */
-static int
+static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
-ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 {
-        static const char module[] = "ZSTDEncode";
+    static const char module[] = "ZSTDEncode";
-        ZSTDState *sp = EncoderState(tif);
+    ZSTDState *sp = EncoderState(tif);
-        ZSTD_inBuffer   in_buffer;
+    ZSTD_inBuffer in_buffer;
-        size_t          zstd_ret;
+    size_t zstd_ret;
 
-        assert(sp != NULL);
+    assert(sp != NULL);
-        assert(sp->state == LSTATE_INIT_ENCODE);
+    assert(sp->state == LSTATE_INIT_ENCODE);
 
-        (void) s;
+    (void)s;
 
-        in_buffer.src = bp;
+    in_buffer.src = bp;
-        in_buffer.size = (size_t)cc;
+    in_buffer.size = (size_t)cc;
-        in_buffer.pos = 0;
+    in_buffer.pos = 0;
 
-        do {
+    do
-                zstd_ret = ZSTD_compressStream(sp->cstream, &sp->out_buffer,
+    {
-                                               &in_buffer);
+        zstd_ret =
-                if( ZSTD_isError(zstd_ret) ) {
+            ZSTD_compressStream(sp->cstream, &sp->out_buffer, &in_buffer);
-                    TIFFErrorExt(tif->tif_clientdata, module,
+        if (ZSTD_isError(zstd_ret))
-                                "Error in ZSTD_compressStream(): %s",
+        {
-                                ZSTD_getErrorName(zstd_ret));
+            TIFFErrorExtR(tif, module, "Error in ZSTD_compressStream(): %s",
-                    return 0;
+                          ZSTD_getErrorName(zstd_ret));
-                }
+            return 0;
-                if( sp->out_buffer.pos == sp->out_buffer.size ) {
+        }
-                        tif->tif_rawcc = tif->tif_rawdatasize;
+        if (sp->out_buffer.pos == sp->out_buffer.size)
-                        if (!TIFFFlushData1(tif))
+        {
-                                return 0;
+            tif->tif_rawcc = tif->tif_rawdatasize;
-                        sp->out_buffer.dst = tif->tif_rawcp;
+            if (!TIFFFlushData1(tif))
-                        sp->out_buffer.pos = 0;
+                return 0;
-                }
+            sp->out_buffer.dst = tif->tif_rawcp;
-        } while( in_buffer.pos < in_buffer.size );
+            sp->out_buffer.pos = 0;
+        }
+    } while (in_buffer.pos < in_buffer.size);
 
-        return 1;
+    return 1;
 }
 
 /*
-* Finish off an encoded strip by flushing it.
+ * Finish off an encoded strip by flushing it.
-*/
+ */
-static int
+static int ZSTDPostEncode(TIFF *tif)
-ZSTDPostEncode(TIFF* tif)
 {
-        static const char module[] = "ZSTDPostEncode";
+    static const char module[] = "ZSTDPostEncode";
-        ZSTDState *sp = EncoderState(tif);
+    ZSTDState *sp = EncoderState(tif);
-        size_t          zstd_ret;
+    size_t zstd_ret;
 
-        do {
+    do
-                zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
+    {
-                if( ZSTD_isError(zstd_ret) ) {
+        zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
-                    TIFFErrorExt(tif->tif_clientdata, module,
+        if (ZSTD_isError(zstd_ret))
-                                "Error in ZSTD_endStream(): %s",
+        {
-                                ZSTD_getErrorName(zstd_ret));
+            TIFFErrorExtR(tif, module, "Error in ZSTD_endStream(): %s",
-                    return 0;
+                          ZSTD_getErrorName(zstd_ret));
-                }
+            return 0;
-                if( sp->out_buffer.pos > 0 ) {
+        }
-                        tif->tif_rawcc = sp->out_buffer.pos;
+        if (sp->out_buffer.pos > 0)
-                        if (!TIFFFlushData1(tif))
+        {
-                                return 0;
+            tif->tif_rawcc = sp->out_buffer.pos;
-                        sp->out_buffer.dst = tif->tif_rawcp;
+            if (!TIFFFlushData1(tif))
-                        sp->out_buffer.pos = 0;
+                return 0;
-                }
+            sp->out_buffer.dst = tif->tif_rawcp;
-        } while (zstd_ret != 0);
+            sp->out_buffer.pos = 0;
-        return 1;
+        }
+    } while (zstd_ret != 0);
+    return 1;
 }
 
-static void
+static void ZSTDCleanup(TIFF *tif)
-ZSTDCleanup(TIFF* tif)
 {
-        ZSTDState* sp = LState(tif);
+    ZSTDState *sp = LState(tif);
 
-        assert(sp != 0);
+    assert(sp != 0);
 
-        (void)TIFFPredictorCleanup(tif);
+    (void)TIFFPredictorCleanup(tif);
 
-        tif->tif_tagmethods.vgetfield = sp->vgetparent;
+    tif->tif_tagmethods.vgetfield = sp->vgetparent;
-        tif->tif_tagmethods.vsetfield = sp->vsetparent;
+    tif->tif_tagmethods.vsetfield = sp->vsetparent;
 
-        if (sp->dstream) {
+    if (sp->dstream)
-            ZSTD_freeDStream(sp->dstream);
+    {
-            sp->dstream = NULL;
+        ZSTD_freeDStream(sp->dstream);
-        }
+        sp->dstream = NULL;
-        if (sp->cstream) {
+    }
-            ZSTD_freeCStream(sp->cstream);
+    if (sp->cstream)
-            sp->cstream = NULL;
+    {
-        }
+        ZSTD_freeCStream(sp->cstream);
-        _TIFFfree(sp);
+        sp->cstream = NULL;
-        tif->tif_data = NULL;
+    }
+    _TIFFfreeExt(tif, sp);
+    tif->tif_data = NULL;
 
-        _TIFFSetDefaultCompressionState(tif);
+    _TIFFSetDefaultCompressionState(tif);
 }
 
-static int
+static int ZSTDVSetField(TIFF *tif, uint32_t tag, va_list ap)
-ZSTDVSetField(TIFF* tif, uint32 tag, va_list ap)
 {
-	static const char module[] = "ZSTDVSetField";
+    static const char module[] = "ZSTDVSetField";
-        ZSTDState* sp = LState(tif);
+    ZSTDState *sp = LState(tif);
 
-        switch (tag) {
+    switch (tag)
+    {
         case TIFFTAG_ZSTD_LEVEL:
-                sp->compression_level = (int) va_arg(ap, int);
+            sp->compression_level = (int)va_arg(ap, int);
-                if( sp->compression_level <= 0 ||
+            if (sp->compression_level <= 0 ||
-                    sp->compression_level > ZSTD_maxCLevel() )
+                sp->compression_level > ZSTD_maxCLevel())
-                {
+            {
-                    TIFFWarningExt(tif->tif_clientdata, module,
+                TIFFWarningExtR(tif, module,
-                                   "ZSTD_LEVEL should be between 1 and %d",
+                                "ZSTD_LEVEL should be between 1 and %d",
-                                   ZSTD_maxCLevel());
+                                ZSTD_maxCLevel());
-                }
+            }
-                return 1;
+            return 1;
         default:
-                return (*sp->vsetparent)(tif, tag, ap);
+            return (*sp->vsetparent)(tif, tag, ap);
-        }
+    }
-        /*NOTREACHED*/
+    /*NOTREACHED*/
 }
 
-static int
+static int ZSTDVGetField(TIFF *tif, uint32_t tag, va_list ap)
-ZSTDVGetField(TIFF* tif, uint32 tag, va_list ap)
 {
-        ZSTDState* sp = LState(tif);
+    ZSTDState *sp = LState(tif);
 
-        switch (tag) {
+    switch (tag)
+    {
         case TIFFTAG_ZSTD_LEVEL:
-                *va_arg(ap, int*) = sp->compression_level;
+            *va_arg(ap, int *) = sp->compression_level;
-                break;
+            break;
         default:
-                return (*sp->vgetparent)(tif, tag, ap);
+            return (*sp->vgetparent)(tif, tag, ap);
-        }
+    }
-        return 1;
+    return 1;
 }
 
 static const TIFFField ZSTDFields[] = {
-        { TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
+    {TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
-          TIFF_SETGET_UNDEFINED,
+     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "ZSTD compression_level",
-          FIELD_PSEUDO, TRUE, FALSE, "ZSTD compression_level", NULL },
+     NULL},
 };
 
-int
+int TIFFInitZSTD(TIFF *tif, int scheme)
-TIFFInitZSTD(TIFF* tif, int scheme)
 {
-        static const char module[] = "TIFFInitZSTD";
+    static const char module[] = "TIFFInitZSTD";
-        ZSTDState* sp;
+    ZSTDState *sp;
 
-        assert( scheme == COMPRESSION_ZSTD );
+    (void)scheme;
+    assert(scheme == COMPRESSION_ZSTD);
 
-        /*
+    /*
-        * Merge codec-specific tag information.
+     * Merge codec-specific tag information.
-        */
+     */
-        if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields))) {
+    if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields)))
-                TIFFErrorExt(tif->tif_clientdata, module,
+    {
-                            "Merging ZSTD codec-specific tags failed");
+        TIFFErrorExtR(tif, module, "Merging ZSTD codec-specific tags failed");
-                return 0;
-        }
-
-        /*
-        * Allocate state block so tag methods have storage to record values.
-        */
-        tif->tif_data = (uint8*) _TIFFmalloc(sizeof(ZSTDState));
-        if (tif->tif_data == NULL)
-                goto bad;
-        sp = LState(tif);
-
-        /*
-        * Override parent get/set field methods.
-        */
-        sp->vgetparent = tif->tif_tagmethods.vgetfield;
-        tif->tif_tagmethods.vgetfield = ZSTDVGetField;	/* hook for codec tags */
-        sp->vsetparent = tif->tif_tagmethods.vsetfield;
-        tif->tif_tagmethods.vsetfield = ZSTDVSetField;	/* hook for codec tags */
-
-        /* Default values for codec-specific fields */
-        sp->compression_level = 9;		/* default comp. level */
-        sp->state = 0;
-        sp->dstream = 0;
-        sp->cstream = 0;
-        sp->out_buffer.dst = NULL;
-        sp->out_buffer.size = 0;
-        sp->out_buffer.pos = 0;
-
-        /*
-        * Install codec methods.
-        */
-        tif->tif_fixuptags = ZSTDFixupTags;
-        tif->tif_setupdecode = ZSTDSetupDecode;
-        tif->tif_predecode = ZSTDPreDecode;
-        tif->tif_decoderow = ZSTDDecode;
-        tif->tif_decodestrip = ZSTDDecode;
-        tif->tif_decodetile = ZSTDDecode;
-        tif->tif_setupencode = ZSTDSetupEncode;
-        tif->tif_preencode = ZSTDPreEncode;
-        tif->tif_postencode = ZSTDPostEncode;
-        tif->tif_encoderow = ZSTDEncode;
-        tif->tif_encodestrip = ZSTDEncode;
-        tif->tif_encodetile = ZSTDEncode;
-        tif->tif_cleanup = ZSTDCleanup;
-        /*
-        * Setup predictor setup.
-        */
-        (void) TIFFPredictorInit(tif);
-        return 1;
-bad:
-        TIFFErrorExt(tif->tif_clientdata, module,
-                    "No space for ZSTD state block");
         return 0;
+    }
+
+    /*
+     * Allocate state block so tag methods have storage to record values.
+     */
+    tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(ZSTDState));
+    if (tif->tif_data == NULL)
+        goto bad;
+    sp = LState(tif);
+
+    /*
+     * Override parent get/set field methods.
+     */
+    sp->vgetparent = tif->tif_tagmethods.vgetfield;
+    tif->tif_tagmethods.vgetfield = ZSTDVGetField; /* hook for codec tags */
+    sp->vsetparent = tif->tif_tagmethods.vsetfield;
+    tif->tif_tagmethods.vsetfield = ZSTDVSetField; /* hook for codec tags */
+
+    /* Default values for codec-specific fields */
+    sp->compression_level = 9; /* default comp. level */
+    sp->state = 0;
+    sp->dstream = 0;
+    sp->cstream = 0;
+    sp->out_buffer.dst = NULL;
+    sp->out_buffer.size = 0;
+    sp->out_buffer.pos = 0;
+
+    /*
+     * Install codec methods.
+     */
+    tif->tif_fixuptags = ZSTDFixupTags;
+    tif->tif_setupdecode = ZSTDSetupDecode;
+    tif->tif_predecode = ZSTDPreDecode;
+    tif->tif_decoderow = ZSTDDecode;
+    tif->tif_decodestrip = ZSTDDecode;
+    tif->tif_decodetile = ZSTDDecode;
+    tif->tif_setupencode = ZSTDSetupEncode;
+    tif->tif_preencode = ZSTDPreEncode;
+    tif->tif_postencode = ZSTDPostEncode;
+    tif->tif_encoderow = ZSTDEncode;
+    tif->tif_encodestrip = ZSTDEncode;
+    tif->tif_encodetile = ZSTDEncode;
+    tif->tif_cleanup = ZSTDCleanup;
+    /*
+     * Setup predictor setup.
+     */
+    (void)TIFFPredictorInit(tif);
+    return 1;
+bad:
+    TIFFErrorExtR(tif, module, "No space for ZSTD state block");
+    return 0;
 }
 #endif /* ZSTD_SUPPORT */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */

3rdparty/libtiff/tiffconf.h.cmake.in

@@ -4,9 +4,21 @@
   from this file in your programs.
 */
 
+/* clang-format off */
+/* clang-format disabled because CMake scripts are very sensitive to the
+ * formatting of this file. configure_file variables of type "@VAR@" are
+ * modified by clang-format and won't be substituted.
+ */
+
 #ifndef _TIFFCONF_
 #define _TIFFCONF_
 
+
+#include <stddef.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
 /* Signed 16-bit type */
 #define TIFF_INT16_T @TIFF_INT16_T@
 
@@ -31,23 +43,26 @@
 /* Unsigned 8-bit type */
 #define TIFF_UINT8_T @TIFF_UINT8_T@
 
-/* Unsigned size type */
-#define TIFF_SIZE_T @TIFF_SIZE_T@
-
 /* Signed size type */
 #define TIFF_SSIZE_T @TIFF_SSIZE_T@
 
-/* Pointer difference type */
-#define TIFF_PTRDIFF_T @TIFF_PTRDIFF_T@
-
 /* Compatibility stuff. */
 
-/* Define as 0 or 1 according to the floating point format suported by the
+/* Define as 0 or 1 according to the floating point format supported by the
    machine */
 #cmakedefine HAVE_IEEEFP 1
 
-/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
+/* The concept of HOST_FILLORDER is broken. Since libtiff 4.5.1
-#define HOST_FILLORDER @HOST_FILLORDER@
+ * this macro will always be hardcoded to FILLORDER_LSB2MSB on all
+ * architectures, to reflect past long behavior of doing so on x86 architecture.
+ * Note however that the default FillOrder used by libtiff is FILLORDER_MSB2LSB,
+ * as mandated per the TIFF specification.
+ * The influence of HOST_FILLORDER is only when passing the 'H' mode in
+ * TIFFOpen().
+ * You should NOT rely on this macro to decide the CPU endianness!
+ * This macro will be removed in libtiff 4.6
+ */
+#define HOST_FILLORDER FILLORDER_LSB2MSB
 
 /* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
    (Intel) */
@@ -62,6 +77,9 @@
 /* Support JBIG compression (requires JBIG-KIT library) */
 #cmakedefine JBIG_SUPPORT
 
+/* Support LERC compression */
+#cmakedefine LERC_SUPPORT 1
+
 /* Support LogLuv high dynamic range encoding */
 #cmakedefine LOGLUV_SUPPORT 1
 
@@ -91,8 +109,8 @@
 #cmakedefine LIBDEFLATE_SUPPORT 1
 
 /* Support strip chopping (whether or not to convert single-strip uncompressed
-   images to mutiple strips of ~8Kb to reduce memory usage) */
+   images to multiple strips of ~8Kb to reduce memory usage) */
-#cmakedefine STRIPCHOP_DEFAULT 1
+#cmakedefine STRIPCHOP_DEFAULT TIFF_STRIPCHOP
 
 /* Enable SubIFD tag (330) support */
 #cmakedefine SUBIFD_SUPPORT 1
@@ -122,3 +140,5 @@
 #define IPTC_SUPPORT
 
 #endif /* _TIFFCONF_ */
+
+/* clang-format on */

3rdparty/libtiff/tiffio.h

@@ -23,7 +23,7 @@
  */
 
 #ifndef _TIFFIO_
-#define	_TIFFIO_
+#define _TIFFIO_
 
 /*
  * TIFF I/O Library Definitions.
@@ -60,20 +60,22 @@ typedef struct tiff TIFF;
  */
 /*
  * this is the machine addressing size type, only it's signed, so make it
- * int32 on 32bit machines, int64 on 64bit machines
+ * int32_t on 32bit machines, int64_t on 64bit machines
  */
 typedef TIFF_SSIZE_T tmsize_t;
-typedef uint64 toff_t;          /* file offset */
+#define TIFF_TMSIZE_T_MAX (tmsize_t)(SIZE_MAX >> 1)
+
+typedef uint64_t toff_t; /* file offset */
 /* the following are deprecated and should be replaced by their defining
    counterparts */
-typedef uint32 ttag_t;          /* directory tag */
+typedef uint32_t ttag_t;    /* directory tag */
-typedef uint16 tdir_t;          /* directory index */
+typedef uint32_t tdir_t;    /* directory index */
-typedef uint16 tsample_t;       /* sample number */
+typedef uint16_t tsample_t; /* sample number */
-typedef uint32 tstrile_t;       /* strip or tile number */
+typedef uint32_t tstrile_t; /* strip or tile number */
-typedef tstrile_t tstrip_t;     /* strip number */
+typedef tstrile_t tstrip_t; /* strip number */
-typedef tstrile_t ttile_t;      /* tile number */
+typedef tstrile_t ttile_t;  /* tile number */
-typedef tmsize_t tsize_t;       /* i/o size in bytes */
+typedef tmsize_t tsize_t;   /* i/o size in bytes */
-typedef void* tdata_t;          /* image data ref */
+typedef void *tdata_t;      /* image data ref */
 
 #if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32))
 #define __WIN32__
@@ -87,21 +89,22 @@ typedef void* tdata_t;          /* image data ref */
  */
 
 #if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows)
-#  if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && !defined(USE_WIN32_FILEIO)
+#if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) &&                      \
-#    define AVOID_WIN32_FILEIO
+    !defined(USE_WIN32_FILEIO)
-#  endif
+#define AVOID_WIN32_FILEIO
+#endif
 #endif
 
 #if defined(USE_WIN32_FILEIO)
-# define VC_EXTRALEAN
+#define VC_EXTRALEAN
-# include <windows.h>
+#include <windows.h>
-# ifdef __WIN32__
+#ifdef __WIN32__
-DECLARE_HANDLE(thandle_t);     /* Win32 file handle */
+DECLARE_HANDLE(thandle_t); /* Win32 file handle */
-# else
-typedef HFILE thandle_t;       /* client data handle */
-# endif /* __WIN32__ */
 #else
-typedef void* thandle_t;       /* client data handle */
+typedef HFILE thandle_t; /* client data handle */
+#endif /* __WIN32__ */
+#else
+typedef void *thandle_t; /* client data handle */
 #endif /* USE_WIN32_FILEIO */
 
 /*
@@ -110,13 +113,13 @@ typedef void* thandle_t;       /* client data handle */
  * very large.   Bit-or these flags to enable printing
  * multiple items.
  */
-#define TIFFPRINT_NONE	       0x0    /* no extra info */
+#define TIFFPRINT_NONE 0x0           /* no extra info */
-#define TIFFPRINT_STRIPS       0x1    /* strips/tiles info */
+#define TIFFPRINT_STRIPS 0x1         /* strips/tiles info */
-#define TIFFPRINT_CURVES       0x2    /* color/gray response curves */
+#define TIFFPRINT_CURVES 0x2         /* color/gray response curves */
-#define TIFFPRINT_COLORMAP     0x4    /* colormap */
+#define TIFFPRINT_COLORMAP 0x4       /* colormap */
-#define TIFFPRINT_JPEGQTABLES  0x100  /* JPEG Q matrices */
+#define TIFFPRINT_JPEGQTABLES 0x100  /* JPEG Q matrices */
-#define TIFFPRINT_JPEGACTABLES 0x200  /* JPEG AC tables */
+#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */
-#define TIFFPRINT_JPEGDCTABLES 0x200  /* JPEG DC tables */
+#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */
 
 /*
  * Colour conversion stuff
@@ -133,42 +136,45 @@ typedef void* thandle_t;       /* client data handle */
 
 /* Structure for holding information about a display device. */
 
-typedef unsigned char TIFFRGBValue;               /* 8-bit samples */
+typedef unsigned char TIFFRGBValue; /* 8-bit samples */
 
-typedef struct {
+typedef struct
-	float d_mat[3][3];                        /* XYZ -> luminance matrix */
+{
-	float d_YCR;                              /* Light o/p for reference white */
+    float d_mat[3][3]; /* XYZ -> luminance matrix */
-	float d_YCG;
+    float d_YCR;       /* Light o/p for reference white */
-	float d_YCB;
+    float d_YCG;
-	uint32 d_Vrwr;                            /* Pixel values for ref. white */
+    float d_YCB;
-	uint32 d_Vrwg;
+    uint32_t d_Vrwr; /* Pixel values for ref. white */
-	uint32 d_Vrwb;
+    uint32_t d_Vrwg;
-	float d_Y0R;                              /* Residual light for black pixel */
+    uint32_t d_Vrwb;
-	float d_Y0G;
+    float d_Y0R; /* Residual light for black pixel */
-	float d_Y0B;
+    float d_Y0G;
-	float d_gammaR;                           /* Gamma values for the three guns */
+    float d_Y0B;
-	float d_gammaG;
+    float d_gammaR; /* Gamma values for the three guns */
-	float d_gammaB;
+    float d_gammaG;
+    float d_gammaB;
 } TIFFDisplay;
 
-typedef struct {                                  /* YCbCr->RGB support */
+typedef struct
-	TIFFRGBValue* clamptab;                   /* range clamping table */
+{                           /* YCbCr->RGB support */
-	int* Cr_r_tab;
+    TIFFRGBValue *clamptab; /* range clamping table */
-	int* Cb_b_tab;
+    int *Cr_r_tab;
-	int32* Cr_g_tab;
+    int *Cb_b_tab;
-	int32* Cb_g_tab;
+    int32_t *Cr_g_tab;
-	int32* Y_tab;
+    int32_t *Cb_g_tab;
+    int32_t *Y_tab;
 } TIFFYCbCrToRGB;
 
-typedef struct {                                  /* CIE Lab 1976->RGB support */
+typedef struct
-	int range;                                /* Size of conversion table */
+{              /* CIE Lab 1976->RGB support */
+    int range; /* Size of conversion table */
 #define CIELABTORGB_TABLE_RANGE 1500
-	float rstep, gstep, bstep;
+    float rstep, gstep, bstep;
-	float X0, Y0, Z0;                         /* Reference white point */
+    float X0, Y0, Z0; /* Reference white point */
-	TIFFDisplay display;
+    TIFFDisplay display;
-	float Yr2r[CIELABTORGB_TABLE_RANGE + 1];  /* Conversion of Yr to r */
+    float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */
-	float Yg2g[CIELABTORGB_TABLE_RANGE + 1];  /* Conversion of Yg to g */
+    float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */
-	float Yb2b[CIELABTORGB_TABLE_RANGE + 1];  /* Conversion of Yb to b */
+    float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */
 } TIFFCIELabToRGB;
 
 /*
@@ -185,56 +191,59 @@ typedef struct _TIFFRGBAImage TIFFRGBAImage;
  * different format or, for example, unpack the data
  * and draw the unpacked raster on the display.
  */
-typedef void (*tileContigRoutine)
+typedef void (*tileContigRoutine)(TIFFRGBAImage *, uint32_t *, uint32_t,
-    (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
+                                  uint32_t, uint32_t, uint32_t, int32_t,
-	unsigned char*);
+                                  int32_t, unsigned char *);
-typedef void (*tileSeparateRoutine)
+typedef void (*tileSeparateRoutine)(TIFFRGBAImage *, uint32_t *, uint32_t,
-    (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
+                                    uint32_t, uint32_t, uint32_t, int32_t,
-	unsigned char*, unsigned char*, unsigned char*, unsigned char*);
+                                    int32_t, unsigned char *, unsigned char *,
+                                    unsigned char *, unsigned char *);
 /*
  * RGBA-reader state.
  */
-struct _TIFFRGBAImage {
+struct _TIFFRGBAImage
-	TIFF* tif;                              /* image handle */
+{
-	int stoponerr;                          /* stop on read error */
+    TIFF *tif;                /* image handle */
-	int isContig;                           /* data is packed/separate */
+    int stoponerr;            /* stop on read error */
-	int alpha;                              /* type of alpha data present */
+    int isContig;             /* data is packed/separate */
-	uint32 width;                           /* image width */
+    int alpha;                /* type of alpha data present */
-	uint32 height;                          /* image height */
+    uint32_t width;           /* image width */
-	uint16 bitspersample;                   /* image bits/sample */
+    uint32_t height;          /* image height */
-	uint16 samplesperpixel;                 /* image samples/pixel */
+    uint16_t bitspersample;   /* image bits/sample */
-	uint16 orientation;                     /* image orientation */
+    uint16_t samplesperpixel; /* image samples/pixel */
-	uint16 req_orientation;                 /* requested orientation */
+    uint16_t orientation;     /* image orientation */
-	uint16 photometric;                     /* image photometric interp */
+    uint16_t req_orientation; /* requested orientation */
-	uint16* redcmap;                        /* colormap palette */
+    uint16_t photometric;     /* image photometric interp */
-	uint16* greencmap;
+    uint16_t *redcmap;        /* colormap palette */
-	uint16* bluecmap;
+    uint16_t *greencmap;
-	/* get image data routine */
+    uint16_t *bluecmap;
-	int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32);
+    /* get image data routine */
-	/* put decoded strip/tile */
+    int (*get)(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
-	union {
+    /* put decoded strip/tile */
-	    void (*any)(TIFFRGBAImage*);
+    union
-	    tileContigRoutine contig;
+    {
-	    tileSeparateRoutine separate;
+        void (*any)(TIFFRGBAImage *);
-	} put;
+        tileContigRoutine contig;
-	TIFFRGBValue* Map;                      /* sample mapping array */
+        tileSeparateRoutine separate;
-	uint32** BWmap;                         /* black&white map */
+    } put;
-	uint32** PALmap;                        /* palette image map */
+    TIFFRGBValue *Map;       /* sample mapping array */
-	TIFFYCbCrToRGB* ycbcr;                  /* YCbCr conversion state */
+    uint32_t **BWmap;        /* black&white map */
-	TIFFCIELabToRGB* cielab;                /* CIE L*a*b conversion state */
+    uint32_t **PALmap;       /* palette image map */
+    TIFFYCbCrToRGB *ycbcr;   /* YCbCr conversion state */
+    TIFFCIELabToRGB *cielab; /* CIE L*a*b conversion state */
 
-	uint8* UaToAa;                          /* Unassociated alpha to associated alpha conversion LUT */
+    uint8_t *UaToAa; /* Unassociated alpha to associated alpha conversion LUT */
-	uint8* Bitdepth16To8;                   /* LUT for conversion from 16bit to 8bit values */
+    uint8_t *Bitdepth16To8; /* LUT for conversion from 16bit to 8bit values */
 
-	int row_offset;
+    int row_offset;
-	int col_offset;
+    int col_offset;
 };
 
 /*
  * Macros for extracting components from the
  * packed ABGR form returned by TIFFReadRGBAImage.
  */
-#define TIFFGetR(abgr) ((abgr) & 0xff)
+#define TIFFGetR(abgr) ((abgr)&0xff)
 #define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
 #define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
 #define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
@@ -246,327 +255,399 @@ struct _TIFFRGBAImage {
  * More codecs may be registered through calls to the library
  * and/or the builtin implementations may be overridden.
  */
-typedef int (*TIFFInitMethod)(TIFF*, int);
+typedef int (*TIFFInitMethod)(TIFF *, int);
-typedef struct {
+typedef struct
-	char* name;
+{
-	uint16 scheme;
+    char *name;
-	TIFFInitMethod init;
+    uint16_t scheme;
+    TIFFInitMethod init;
 } TIFFCodec;
 
-#include <stdio.h>
+typedef struct
+{
+    uint32_t uNum;
+    uint32_t uDenom;
+} TIFFRational_t;
+
 #include <stdarg.h>
+#include <stdio.h>
 
 /* share internal LogLuv conversion routines? */
 #ifndef LOGLUV_PUBLIC
 #define LOGLUV_PUBLIC 1
 #endif
 
-#if defined(__GNUC__) || defined(__attribute__)
+#if defined(__GNUC__) || defined(__clang__) || defined(__attribute__)
-#  define TIFF_ATTRIBUTE(x)    __attribute__(x)
+#define TIFF_ATTRIBUTE(x) __attribute__(x)
 #else
-#  define TIFF_ATTRIBUTE(x) /*nothing*/
+#define TIFF_ATTRIBUTE(x) /*nothing*/
 #endif
 
 #if defined(c_plusplus) || defined(__cplusplus)
-extern "C" {
+extern "C"
+{
 #endif
-typedef void (*TIFFErrorHandler)(const char*, const char*, va_list);
+    typedef void (*TIFFErrorHandler)(const char *, const char *, va_list);
-typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list);
+    typedef void (*TIFFErrorHandlerExt)(thandle_t, const char *, const char *,
-typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void*, tmsize_t);
+                                        va_list);
-typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
+    typedef int (*TIFFErrorHandlerExtR)(TIFF *, void *user_data, const char *,
-typedef int (*TIFFCloseProc)(thandle_t);
+                                        const char *, va_list);
-typedef toff_t (*TIFFSizeProc)(thandle_t);
+    typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void *, tmsize_t);
-typedef int (*TIFFMapFileProc)(thandle_t, void** base, toff_t* size);
+    typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
-typedef void (*TIFFUnmapFileProc)(thandle_t, void* base, toff_t size);
+    typedef int (*TIFFCloseProc)(thandle_t);
-typedef void (*TIFFExtendProc)(TIFF*);
+    typedef toff_t (*TIFFSizeProc)(thandle_t);
+    typedef int (*TIFFMapFileProc)(thandle_t, void **base, toff_t *size);
+    typedef void (*TIFFUnmapFileProc)(thandle_t, void *base, toff_t size);
+    typedef void (*TIFFExtendProc)(TIFF *);
 
-extern const char* TIFFGetVersion(void);
+    extern const char *TIFFGetVersion(void);
 
-extern const TIFFCodec* TIFFFindCODEC(uint16);
+    extern const TIFFCodec *TIFFFindCODEC(uint16_t);
-extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod);
+    extern TIFFCodec *TIFFRegisterCODEC(uint16_t, const char *, TIFFInitMethod);
-extern void TIFFUnRegisterCODEC(TIFFCodec*);
+    extern void TIFFUnRegisterCODEC(TIFFCodec *);
-extern int TIFFIsCODECConfigured(uint16);
+    extern int TIFFIsCODECConfigured(uint16_t);
-extern TIFFCodec* TIFFGetConfiguredCODECs(void);
+    extern TIFFCodec *TIFFGetConfiguredCODECs(void);
 
-/*
+    /*
- * Auxiliary functions.
+     * Auxiliary functions.
- */
+     */
 
-extern void* _TIFFmalloc(tmsize_t s);
+    extern void *_TIFFmalloc(tmsize_t s);
-extern void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz);
+    extern void *_TIFFcalloc(tmsize_t nmemb, tmsize_t siz);
-extern void* _TIFFrealloc(void* p, tmsize_t s);
+    extern void *_TIFFrealloc(void *p, tmsize_t s);
-extern void _TIFFmemset(void* p, int v, tmsize_t c);
+    extern void _TIFFmemset(void *p, int v, tmsize_t c);
-extern void _TIFFmemcpy(void* d, const void* s, tmsize_t c);
+    extern void _TIFFmemcpy(void *d, const void *s, tmsize_t c);
-extern int _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c);
+    extern int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c);
-extern void _TIFFfree(void* p);
+    extern void _TIFFfree(void *p);
 
-/*
+    /*
-** Stuff, related to tag handling and creating custom tags.
+    ** Stuff, related to tag handling and creating custom tags.
-*/
+    */
-extern int TIFFGetTagListCount( TIFF * );
+    extern int TIFFGetTagListCount(TIFF *);
-extern uint32 TIFFGetTagListEntry( TIFF *, int tag_index );
+    extern uint32_t TIFFGetTagListEntry(TIFF *, int tag_index);
 
-#define TIFF_ANY       TIFF_NOTYPE     /* for field descriptor searching */
+#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
-#define TIFF_VARIABLE  -1              /* marker for variable length tags */
+#define TIFF_VARIABLE -1     /* marker for variable length tags */
-#define TIFF_SPP       -2              /* marker for SamplesPerPixel tags */
+#define TIFF_SPP -2          /* marker for SamplesPerPixel tags */
-#define TIFF_VARIABLE2 -3              /* marker for uint32 var-length tags */
+#define TIFF_VARIABLE2 -3    /* marker for uint32_t var-length tags */
 
-#define FIELD_CUSTOM    65
+#define FIELD_CUSTOM 65
 
-typedef struct _TIFFField TIFFField;
+    typedef struct _TIFFField TIFFField;
-typedef struct _TIFFFieldArray TIFFFieldArray;
+    typedef struct _TIFFFieldArray TIFFFieldArray;
 
-extern const TIFFField* TIFFFindField(TIFF *, uint32, TIFFDataType);
+    extern const TIFFField *TIFFFindField(TIFF *, uint32_t, TIFFDataType);
-extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32);
+    extern const TIFFField *TIFFFieldWithTag(TIFF *, uint32_t);
-extern const TIFFField* TIFFFieldWithName(TIFF*, const char *);
+    extern const TIFFField *TIFFFieldWithName(TIFF *, const char *);
 
-extern uint32 TIFFFieldTag(const TIFFField*);
+    extern uint32_t TIFFFieldTag(const TIFFField *);
-extern const char* TIFFFieldName(const TIFFField*);
+    extern const char *TIFFFieldName(const TIFFField *);
-extern TIFFDataType TIFFFieldDataType(const TIFFField*);
+    extern TIFFDataType TIFFFieldDataType(const TIFFField *);
-extern int TIFFFieldPassCount(const TIFFField*);
+    extern int TIFFFieldPassCount(const TIFFField *);
-extern int TIFFFieldReadCount(const TIFFField*);
+    extern int TIFFFieldReadCount(const TIFFField *);
-extern int TIFFFieldWriteCount(const TIFFField*);
+    extern int TIFFFieldWriteCount(const TIFFField *);
+    extern int
+    TIFFFieldSetGetSize(const TIFFField *); /* returns internal storage size of
+                                               TIFFSetGetFieldType in bytes. */
+    extern int TIFFFieldSetGetCountSize(
+        const TIFFField *); /* returns size of count parameter 0=none,
+                               2=uint16_t, 4=uint32_t */
+    extern int TIFFFieldIsAnonymous(const TIFFField *);
 
-typedef int (*TIFFVSetMethod)(TIFF*, uint32, va_list);
+    typedef int (*TIFFVSetMethod)(TIFF *, uint32_t, va_list);
-typedef int (*TIFFVGetMethod)(TIFF*, uint32, va_list);
+    typedef int (*TIFFVGetMethod)(TIFF *, uint32_t, va_list);
-typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
+    typedef void (*TIFFPrintMethod)(TIFF *, FILE *, long);
 
-typedef struct {
+    typedef struct
-    TIFFVSetMethod vsetfield; /* tag set routine */
+    {
-    TIFFVGetMethod vgetfield; /* tag get routine */
+        TIFFVSetMethod vsetfield; /* tag set routine */
-    TIFFPrintMethod printdir; /* directory print routine */
+        TIFFVGetMethod vgetfield; /* tag get routine */
-} TIFFTagMethods;
+        TIFFPrintMethod printdir; /* directory print routine */
+    } TIFFTagMethods;
 
-extern  TIFFTagMethods *TIFFAccessTagMethods(TIFF *);
+    extern TIFFTagMethods *TIFFAccessTagMethods(TIFF *);
-extern  void *TIFFGetClientInfo(TIFF *, const char *);
+    extern void *TIFFGetClientInfo(TIFF *, const char *);
-extern  void TIFFSetClientInfo(TIFF *, void *, const char *);
+    extern void TIFFSetClientInfo(TIFF *, void *, const char *);
 
-extern void TIFFCleanup(TIFF* tif);
+    extern void TIFFCleanup(TIFF *tif);
-extern void TIFFClose(TIFF* tif);
+    extern void TIFFClose(TIFF *tif);
-extern int TIFFFlush(TIFF* tif);
+    extern int TIFFFlush(TIFF *tif);
-extern int TIFFFlushData(TIFF* tif);
+    extern int TIFFFlushData(TIFF *tif);
-extern int TIFFGetField(TIFF* tif, uint32 tag, ...);
+    extern int TIFFGetField(TIFF *tif, uint32_t tag, ...);
-extern int TIFFVGetField(TIFF* tif, uint32 tag, va_list ap);
+    extern int TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap);
-extern int TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...);
+    extern int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...);
-extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap);
+    extern int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap);
-extern int TIFFReadDirectory(TIFF* tif);
+    extern int TIFFReadDirectory(TIFF *tif);
-extern int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, const TIFFFieldArray* infoarray);
+    extern int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
-extern int TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff);
+                                       const TIFFFieldArray *infoarray);
-extern int TIFFReadGPSDirectory(TIFF* tif, toff_t diroff);
+    extern int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff);
-extern uint64 TIFFScanlineSize64(TIFF* tif);
+    extern int TIFFReadGPSDirectory(TIFF *tif, toff_t diroff);
-extern tmsize_t TIFFScanlineSize(TIFF* tif);
+    extern uint64_t TIFFScanlineSize64(TIFF *tif);
-extern uint64 TIFFRasterScanlineSize64(TIFF* tif);
+    extern tmsize_t TIFFScanlineSize(TIFF *tif);
-extern tmsize_t TIFFRasterScanlineSize(TIFF* tif);
+    extern uint64_t TIFFRasterScanlineSize64(TIFF *tif);
-extern uint64 TIFFStripSize64(TIFF* tif);
+    extern tmsize_t TIFFRasterScanlineSize(TIFF *tif);
-extern tmsize_t TIFFStripSize(TIFF* tif);
+    extern uint64_t TIFFStripSize64(TIFF *tif);
-extern uint64 TIFFRawStripSize64(TIFF* tif, uint32 strip);
+    extern tmsize_t TIFFStripSize(TIFF *tif);
-extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32 strip);
+    extern uint64_t TIFFRawStripSize64(TIFF *tif, uint32_t strip);
-extern uint64 TIFFVStripSize64(TIFF* tif, uint32 nrows);
+    extern tmsize_t TIFFRawStripSize(TIFF *tif, uint32_t strip);
-extern tmsize_t TIFFVStripSize(TIFF* tif, uint32 nrows);
+    extern uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows);
-extern uint64 TIFFTileRowSize64(TIFF* tif);
+    extern tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows);
-extern tmsize_t TIFFTileRowSize(TIFF* tif);
+    extern uint64_t TIFFTileRowSize64(TIFF *tif);
-extern uint64 TIFFTileSize64(TIFF* tif);
+    extern tmsize_t TIFFTileRowSize(TIFF *tif);
-extern tmsize_t TIFFTileSize(TIFF* tif);
+    extern uint64_t TIFFTileSize64(TIFF *tif);
-extern uint64 TIFFVTileSize64(TIFF* tif, uint32 nrows);
+    extern tmsize_t TIFFTileSize(TIFF *tif);
-extern tmsize_t TIFFVTileSize(TIFF* tif, uint32 nrows);
+    extern uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows);
-extern uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request);
+    extern tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows);
-extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
+    extern uint32_t TIFFDefaultStripSize(TIFF *tif, uint32_t request);
-extern int TIFFFileno(TIFF*);
+    extern void TIFFDefaultTileSize(TIFF *, uint32_t *, uint32_t *);
-extern int TIFFSetFileno(TIFF*, int);
+    extern int TIFFFileno(TIFF *);
-extern thandle_t TIFFClientdata(TIFF*);
+    extern int TIFFSetFileno(TIFF *, int);
-extern thandle_t TIFFSetClientdata(TIFF*, thandle_t);
+    extern thandle_t TIFFClientdata(TIFF *);
-extern int TIFFGetMode(TIFF*);
+    extern thandle_t TIFFSetClientdata(TIFF *, thandle_t);
-extern int TIFFSetMode(TIFF*, int);
+    extern int TIFFGetMode(TIFF *);
-extern int TIFFIsTiled(TIFF*);
+    extern int TIFFSetMode(TIFF *, int);
-extern int TIFFIsByteSwapped(TIFF*);
+    extern int TIFFIsTiled(TIFF *);
-extern int TIFFIsUpSampled(TIFF*);
+    extern int TIFFIsByteSwapped(TIFF *);
-extern int TIFFIsMSB2LSB(TIFF*);
+    extern int TIFFIsUpSampled(TIFF *);
-extern int TIFFIsBigEndian(TIFF*);
+    extern int TIFFIsMSB2LSB(TIFF *);
-extern TIFFReadWriteProc TIFFGetReadProc(TIFF*);
+    extern int TIFFIsBigEndian(TIFF *);
-extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*);
+    extern int TIFFIsBigTIFF(TIFF *);
-extern TIFFSeekProc TIFFGetSeekProc(TIFF*);                                                          
+    extern TIFFReadWriteProc TIFFGetReadProc(TIFF *);
-extern TIFFCloseProc TIFFGetCloseProc(TIFF*);
+    extern TIFFReadWriteProc TIFFGetWriteProc(TIFF *);
-extern TIFFSizeProc TIFFGetSizeProc(TIFF*);
+    extern TIFFSeekProc TIFFGetSeekProc(TIFF *);
-extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*);
+    extern TIFFCloseProc TIFFGetCloseProc(TIFF *);
-extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*);
+    extern TIFFSizeProc TIFFGetSizeProc(TIFF *);
-extern uint32 TIFFCurrentRow(TIFF*);
+    extern TIFFMapFileProc TIFFGetMapFileProc(TIFF *);
-extern uint16 TIFFCurrentDirectory(TIFF*);
+    extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *);
-extern uint16 TIFFNumberOfDirectories(TIFF*);
+    extern uint32_t TIFFCurrentRow(TIFF *);
-extern uint64 TIFFCurrentDirOffset(TIFF*);
+    extern tdir_t TIFFCurrentDirectory(TIFF *);
-extern uint32 TIFFCurrentStrip(TIFF*);
+    extern tdir_t TIFFNumberOfDirectories(TIFF *);
-extern uint32 TIFFCurrentTile(TIFF* tif);
+    extern uint64_t TIFFCurrentDirOffset(TIFF *);
-extern int TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size);
+    extern uint32_t TIFFCurrentStrip(TIFF *);
-extern int TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size);  
+    extern uint32_t TIFFCurrentTile(TIFF *tif);
-extern int TIFFSetupStrips(TIFF *);
+    extern int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size);
-extern int TIFFWriteCheck(TIFF*, int, const char *);
+    extern int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size);
-extern void TIFFFreeDirectory(TIFF*);
+    extern int TIFFSetupStrips(TIFF *);
-extern int TIFFCreateDirectory(TIFF*);
+    extern int TIFFWriteCheck(TIFF *, int, const char *);
-extern int TIFFCreateCustomDirectory(TIFF*,const TIFFFieldArray*);
+    extern void TIFFFreeDirectory(TIFF *);
-extern int TIFFCreateEXIFDirectory(TIFF*);
+    extern int TIFFCreateDirectory(TIFF *);
-extern int TIFFCreateGPSDirectory(TIFF*);
+    extern int TIFFCreateCustomDirectory(TIFF *, const TIFFFieldArray *);
-extern int TIFFLastDirectory(TIFF*);
+    extern int TIFFCreateEXIFDirectory(TIFF *);
-extern int TIFFSetDirectory(TIFF*, uint16);
+    extern int TIFFCreateGPSDirectory(TIFF *);
-extern int TIFFSetSubDirectory(TIFF*, uint64);
+    extern int TIFFLastDirectory(TIFF *);
-extern int TIFFUnlinkDirectory(TIFF*, uint16);
+    extern int TIFFSetDirectory(TIFF *, tdir_t);
-extern int TIFFSetField(TIFF*, uint32, ...);
+    extern int TIFFSetSubDirectory(TIFF *, uint64_t);
-extern int TIFFVSetField(TIFF*, uint32, va_list);
+    extern int TIFFUnlinkDirectory(TIFF *, tdir_t);
-extern int TIFFUnsetField(TIFF*, uint32);
+    extern int TIFFSetField(TIFF *, uint32_t, ...);
-extern int TIFFWriteDirectory(TIFF *);
+    extern int TIFFVSetField(TIFF *, uint32_t, va_list);
-extern int TIFFWriteCustomDirectory(TIFF *, uint64 *);
+    extern int TIFFUnsetField(TIFF *, uint32_t);
-extern int TIFFCheckpointDirectory(TIFF *);
+    extern int TIFFWriteDirectory(TIFF *);
-extern int TIFFRewriteDirectory(TIFF *);
+    extern int TIFFWriteCustomDirectory(TIFF *, uint64_t *);
-extern int TIFFDeferStrileArrayWriting(TIFF *);
+    extern int TIFFCheckpointDirectory(TIFF *);
-extern int TIFFForceStrileArrayWriting(TIFF* );
+    extern int TIFFRewriteDirectory(TIFF *);
+    extern int TIFFDeferStrileArrayWriting(TIFF *);
+    extern int TIFFForceStrileArrayWriting(TIFF *);
 
 #if defined(c_plusplus) || defined(__cplusplus)
-extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0);
+    extern void TIFFPrintDirectory(TIFF *, FILE *, long = 0);
-extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0);
+    extern int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row,
-extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0);
+                                uint16_t sample = 0);
-extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0);
+    extern int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row,
-extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*,
+                                 uint16_t sample = 0);
-    int = ORIENTATION_BOTLEFT, int = 0);
+    extern int TIFFReadRGBAImage(TIFF *, uint32_t, uint32_t, uint32_t *,
+                                 int = 0);
+    extern int TIFFReadRGBAImageOriented(TIFF *, uint32_t, uint32_t, uint32_t *,
+                                         int = ORIENTATION_BOTLEFT, int = 0);
 #else
-extern void TIFFPrintDirectory(TIFF*, FILE*, long);
+extern void TIFFPrintDirectory(TIFF *, FILE *, long);
-extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample);
+extern int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row,
-extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample);
+                            uint16_t sample);
-extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int);
+extern int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row,
-extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int);
+                             uint16_t sample);
+extern int TIFFReadRGBAImage(TIFF *, uint32_t, uint32_t, uint32_t *, int);
+extern int TIFFReadRGBAImageOriented(TIFF *, uint32_t, uint32_t, uint32_t *,
+                                     int, int);
 #endif
 
-extern int TIFFReadRGBAStrip(TIFF*, uint32, uint32 * );
+    extern int TIFFReadRGBAStrip(TIFF *, uint32_t, uint32_t *);
-extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * );
+    extern int TIFFReadRGBATile(TIFF *, uint32_t, uint32_t, uint32_t *);
-extern int TIFFReadRGBAStripExt(TIFF*, uint32, uint32 *, int stop_on_error );
+    extern int TIFFReadRGBAStripExt(TIFF *, uint32_t, uint32_t *,
-extern int TIFFReadRGBATileExt(TIFF*, uint32, uint32, uint32 *, int stop_on_error );
+                                    int stop_on_error);
-extern int TIFFRGBAImageOK(TIFF*, char [1024]);
+    extern int TIFFReadRGBATileExt(TIFF *, uint32_t, uint32_t, uint32_t *,
-extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]);
+                                   int stop_on_error);
-extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32);
+    extern int TIFFRGBAImageOK(TIFF *, char[1024]);
-extern void TIFFRGBAImageEnd(TIFFRGBAImage*);
+    extern int TIFFRGBAImageBegin(TIFFRGBAImage *, TIFF *, int, char[1024]);
-extern TIFF* TIFFOpen(const char*, const char*);
+    extern int TIFFRGBAImageGet(TIFFRGBAImage *, uint32_t *, uint32_t,
-# ifdef __WIN32__
+                                uint32_t);
-extern TIFF* TIFFOpenW(const wchar_t*, const char*);
+    extern void TIFFRGBAImageEnd(TIFFRGBAImage *);
-# endif /* __WIN32__ */
-extern TIFF* TIFFFdOpen(int, const char*, const char*);
-extern TIFF* TIFFClientOpen(const char*, const char*,
-	    thandle_t,
-	    TIFFReadWriteProc, TIFFReadWriteProc,
-	    TIFFSeekProc, TIFFCloseProc,
-	    TIFFSizeProc,
-	    TIFFMapFileProc, TIFFUnmapFileProc);
-extern const char* TIFFFileName(TIFF*);
-extern const char* TIFFSetFileName(TIFF*, const char *);
-extern void TIFFError(const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,2,3)));
-extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,3,4)));
-extern void TIFFWarning(const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,2,3)));
-extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,3,4)));
-extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
-extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
-extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
-extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
-extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
-extern uint32 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s);
-extern int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s);
-extern uint32 TIFFNumberOfTiles(TIFF*);
-extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s);  
-extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s);
-extern uint32 TIFFComputeStrip(TIFF*, uint32, uint16);
-extern uint32 TIFFNumberOfStrips(TIFF*);
-extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size);
-extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size);  
-extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size);  
-extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size);  
-extern int      TIFFReadFromUserBuffer(TIFF* tif, uint32 strile,
-                                       void* inbuf, tmsize_t insize,
-                                       void* outbuf, tmsize_t outsize);
-extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc);
-extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc);  
-extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc);  
-extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc);  
-extern int TIFFDataWidth(TIFFDataType);    /* table of tag datatype widths */
-extern void TIFFSetWriteOffset(TIFF* tif, toff_t off);
-extern void TIFFSwabShort(uint16*);
-extern void TIFFSwabLong(uint32*);
-extern void TIFFSwabLong8(uint64*);
-extern void TIFFSwabFloat(float*);
-extern void TIFFSwabDouble(double*);
-extern void TIFFSwabArrayOfShort(uint16* wp, tmsize_t n);
-extern void TIFFSwabArrayOfTriples(uint8* tp, tmsize_t n);
-extern void TIFFSwabArrayOfLong(uint32* lp, tmsize_t n);
-extern void TIFFSwabArrayOfLong8(uint64* lp, tmsize_t n);
-extern void TIFFSwabArrayOfFloat(float* fp, tmsize_t n);
-extern void TIFFSwabArrayOfDouble(double* dp, tmsize_t n);
-extern void TIFFReverseBits(uint8* cp, tmsize_t n);
-extern const unsigned char* TIFFGetBitRevTable(int);
 
-extern uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile);
+    extern const char *TIFFFileName(TIFF *);
-extern uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile);
+    extern const char *TIFFSetFileName(TIFF *, const char *);
-extern uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr);
+    extern void TIFFError(const char *, const char *, ...)
-extern uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 strile, int *pbErr);
+        TIFF_ATTRIBUTE((__format__(__printf__, 2, 3)));
+    extern void TIFFErrorExt(thandle_t, const char *, const char *, ...)
+        TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
+    extern void TIFFWarning(const char *, const char *, ...)
+        TIFF_ATTRIBUTE((__format__(__printf__, 2, 3)));
+    extern void TIFFWarningExt(thandle_t, const char *, const char *, ...)
+        TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
+    extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
+    extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
+    extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
+    extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
+
+    extern void TIFFWarningExtR(TIFF *, const char *, const char *, ...)
+        TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
+    extern void TIFFErrorExtR(TIFF *, const char *, const char *, ...)
+        TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
+
+    typedef struct TIFFOpenOptions TIFFOpenOptions;
+    extern TIFFOpenOptions *TIFFOpenOptionsAlloc(void);
+    extern void TIFFOpenOptionsFree(TIFFOpenOptions *);
+    extern void
+    TIFFOpenOptionsSetMaxSingleMemAlloc(TIFFOpenOptions *opts,
+                                        tmsize_t max_single_mem_alloc);
+    extern void
+    TIFFOpenOptionsSetErrorHandlerExtR(TIFFOpenOptions *opts,
+                                       TIFFErrorHandlerExtR handler,
+                                       void *errorhandler_user_data);
+    extern void
+    TIFFOpenOptionsSetWarningHandlerExtR(TIFFOpenOptions *opts,
+                                         TIFFErrorHandlerExtR handler,
+                                         void *warnhandler_user_data);
+
+    extern TIFF *TIFFOpen(const char *, const char *);
+    extern TIFF *TIFFOpenExt(const char *, const char *, TIFFOpenOptions *opts);
+#ifdef __WIN32__
+    extern TIFF *TIFFOpenW(const wchar_t *, const char *);
+    extern TIFF *TIFFOpenWExt(const wchar_t *, const char *,
+                              TIFFOpenOptions *opts);
+#endif /* __WIN32__ */
+    extern TIFF *TIFFFdOpen(int, const char *, const char *);
+    extern TIFF *TIFFFdOpenExt(int, const char *, const char *,
+                               TIFFOpenOptions *opts);
+    extern TIFF *TIFFClientOpen(const char *, const char *, thandle_t,
+                                TIFFReadWriteProc, TIFFReadWriteProc,
+                                TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
+                                TIFFMapFileProc, TIFFUnmapFileProc);
+    extern TIFF *TIFFClientOpenExt(const char *, const char *, thandle_t,
+                                   TIFFReadWriteProc, TIFFReadWriteProc,
+                                   TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
+                                   TIFFMapFileProc, TIFFUnmapFileProc,
+                                   TIFFOpenOptions *opts);
+    extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
+    extern uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y,
+                                    uint32_t z, uint16_t s);
+    extern int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
+                             uint16_t s);
+    extern uint32_t TIFFNumberOfTiles(TIFF *);
+    extern tmsize_t TIFFReadTile(TIFF *tif, void *buf, uint32_t x, uint32_t y,
+                                 uint32_t z, uint16_t s);
+    extern tmsize_t TIFFWriteTile(TIFF *tif, void *buf, uint32_t x, uint32_t y,
+                                  uint32_t z, uint16_t s);
+    extern uint32_t TIFFComputeStrip(TIFF *, uint32_t, uint16_t);
+    extern uint32_t TIFFNumberOfStrips(TIFF *);
+    extern tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32_t strip, void *buf,
+                                         tmsize_t size);
+    extern tmsize_t TIFFReadRawStrip(TIFF *tif, uint32_t strip, void *buf,
+                                     tmsize_t size);
+    extern tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32_t tile, void *buf,
+                                        tmsize_t size);
+    extern tmsize_t TIFFReadRawTile(TIFF *tif, uint32_t tile, void *buf,
+                                    tmsize_t size);
+    extern int TIFFReadFromUserBuffer(TIFF *tif, uint32_t strile, void *inbuf,
+                                      tmsize_t insize, void *outbuf,
+                                      tmsize_t outsize);
+    extern tmsize_t TIFFWriteEncodedStrip(TIFF *tif, uint32_t strip, void *data,
+                                          tmsize_t cc);
+    extern tmsize_t TIFFWriteRawStrip(TIFF *tif, uint32_t strip, void *data,
+                                      tmsize_t cc);
+    extern tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data,
+                                         tmsize_t cc);
+    extern tmsize_t TIFFWriteRawTile(TIFF *tif, uint32_t tile, void *data,
+                                     tmsize_t cc);
+    extern int TIFFDataWidth(
+        TIFFDataType); /* table of tag datatype widths within TIFF file. */
+    extern void TIFFSetWriteOffset(TIFF *tif, toff_t off);
+    extern void TIFFSwabShort(uint16_t *);
+    extern void TIFFSwabLong(uint32_t *);
+    extern void TIFFSwabLong8(uint64_t *);
+    extern void TIFFSwabFloat(float *);
+    extern void TIFFSwabDouble(double *);
+    extern void TIFFSwabArrayOfShort(uint16_t *wp, tmsize_t n);
+    extern void TIFFSwabArrayOfTriples(uint8_t *tp, tmsize_t n);
+    extern void TIFFSwabArrayOfLong(uint32_t *lp, tmsize_t n);
+    extern void TIFFSwabArrayOfLong8(uint64_t *lp, tmsize_t n);
+    extern void TIFFSwabArrayOfFloat(float *fp, tmsize_t n);
+    extern void TIFFSwabArrayOfDouble(double *dp, tmsize_t n);
+    extern void TIFFReverseBits(uint8_t *cp, tmsize_t n);
+    extern const unsigned char *TIFFGetBitRevTable(int);
+
+    extern uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile);
+    extern uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile);
+    extern uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile,
+                                               int *pbErr);
+    extern uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile,
+                                                  int *pbErr);
 
 #ifdef LOGLUV_PUBLIC
-#define U_NEU		0.210526316
+#define U_NEU 0.210526316
-#define V_NEU		0.473684211
+#define V_NEU 0.473684211
-#define UVSCALE		410.
+#define UVSCALE 410.
-extern double LogL16toY(int);
+    extern double LogL16toY(int);
-extern double LogL10toY(int);
+    extern double LogL10toY(int);
-extern void XYZtoRGB24(float*, uint8*);
+    extern void XYZtoRGB24(float *, uint8_t *);
-extern int uv_decode(double*, double*, int);
+    extern int uv_decode(double *, double *, int);
-extern void LogLuv24toXYZ(uint32, float*);
+    extern void LogLuv24toXYZ(uint32_t, float *);
-extern void LogLuv32toXYZ(uint32, float*);
+    extern void LogLuv32toXYZ(uint32_t, float *);
 #if defined(c_plusplus) || defined(__cplusplus)
-extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
+    extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
-extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
+    extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
-extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
+    extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
-extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER);
+    extern uint32_t LogLuv24fromXYZ(float *, int = SGILOGENCODE_NODITHER);
-extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER);
+    extern uint32_t LogLuv32fromXYZ(float *, int = SGILOGENCODE_NODITHER);
 #else
-extern int LogL16fromY(double, int);
+    extern int LogL16fromY(double, int);
-extern int LogL10fromY(double, int);
+    extern int LogL10fromY(double, int);
-extern int uv_encode(double, double, int);
+    extern int uv_encode(double, double, int);
-extern uint32 LogLuv24fromXYZ(float*, int);
+    extern uint32_t LogLuv24fromXYZ(float *, int);
-extern uint32 LogLuv32fromXYZ(float*, int);
+    extern uint32_t LogLuv32fromXYZ(float *, int);
 #endif
 #endif /* LOGLUV_PUBLIC */
 
-extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, const TIFFDisplay *, float*);
+    extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB *, const TIFFDisplay *,
-extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32,
+                                   float *);
-    float *, float *, float *);
+    extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32_t, int32_t, int32_t,
-extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float,
+                                float *, float *, float *);
-    uint32 *, uint32 *, uint32 *);
+    extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, uint32_t *,
+                             uint32_t *, uint32_t *);
 
-extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*);
+    extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *, float *, float *);
-extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32,
+    extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32_t, int32_t, int32_t,
-    uint32 *, uint32 *, uint32 *);
+                               uint32_t *, uint32_t *, uint32_t *);
 
-/****************************************************************************
+    /****************************************************************************
- *               O B S O L E T E D    I N T E R F A C E S
+     *               O B S O L E T E D    I N T E R F A C E S
- *
+     *
- * Don't use this stuff in your applications, it may be removed in the future
+     * Don't use this stuff in your applications, it may be removed in the
- * libtiff versions.
+     *future libtiff versions.
- ****************************************************************************/
+     ****************************************************************************/
-typedef	struct {
+    typedef struct
-	ttag_t	field_tag;		/* field's tag */
+    {
-	short	field_readcount;	/* read count/TIFF_VARIABLE/TIFF_SPP */
+        ttag_t field_tag;               /* field's tag */
-	short	field_writecount;	/* write count/TIFF_VARIABLE */
+        short field_readcount;          /* read count/TIFF_VARIABLE/TIFF_SPP */
-	TIFFDataType field_type;	/* type of associated data */
+        short field_writecount;         /* write count/TIFF_VARIABLE */
-        unsigned short field_bit;	/* bit in fieldsset bit vector */
+        TIFFDataType field_type;        /* type of associated data */
-	unsigned char field_oktochange;	/* if true, can change while writing */
+        unsigned short field_bit;       /* bit in fieldsset bit vector */
-	unsigned char field_passcount;	/* if true, pass dir count on set */
+        unsigned char field_oktochange; /* if true, can change while writing */
-	char	*field_name;		/* ASCII name */
+        unsigned char field_passcount;  /* if true, pass dir count on set */
-} TIFFFieldInfo;
+        char *field_name;               /* ASCII name */
+    } TIFFFieldInfo;
 
-extern int TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], uint32);
+    extern int TIFFMergeFieldInfo(TIFF *, const TIFFFieldInfo[], uint32_t);
 
 #if defined(c_plusplus) || defined(__cplusplus)
 }
 #endif
 
 #endif /* _TIFFIO_ */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tiffio.hxx

@@ -23,26 +23,17 @@
  */
 
 #ifndef _TIFFIO_HXX_
-#define	_TIFFIO_HXX_
+#define _TIFFIO_HXX_
 
 /*
  * TIFF I/O library definitions which provide C++ streams API.
  */
 
-#include <iostream>
 #include "tiff.h"
 #include "tiffio.h"
+#include <iostream>
 
-extern TIFF* TIFFStreamOpen(const char*, std::ostream *);
+extern TIFF *TIFFStreamOpen(const char *, std::ostream *);
-extern TIFF* TIFFStreamOpen(const char*, std::istream *);
+extern TIFF *TIFFStreamOpen(const char *, std::istream *);
 
 #endif /* _TIFFIO_HXX_ */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c++
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tiffiop.h

@@ -23,7 +23,7 @@
  */
 
 #ifndef _TIFFIOP_
-#define	_TIFFIOP_
+#define _TIFFIOP_
 /*
  * ``Library-private'' definitions.
  */
@@ -31,66 +31,48 @@
 #include "tif_config.h"
 
 #ifdef HAVE_FCNTL_H
-# include <fcntl.h>
+#include <fcntl.h>
 #endif
 
 #ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
-#ifdef HAVE_STRING_H
+#include <string.h>
-# include <string.h>
-#endif
 
 #ifdef HAVE_ASSERT_H
-# include <assert.h>
+#include <assert.h>
 #else
-# define assert(x) 
+#define assert(x)
-#endif
-
-#ifdef HAVE_SEARCH_H
-# include <search.h>
-#else
-extern void *lfind(const void *, const void *, size_t *, size_t,
-		   int (*)(const void *, const void *));
-#endif
-
-#if !defined(HAVE_SNPRINTF) && !defined(HAVE__SNPRINTF)
-#undef snprintf
-#define snprintf _TIFF_snprintf_f
-extern int snprintf(char* str, size_t size, const char* format, ...);
 #endif
 
+#include "tif_hash_set.h"
 #include "tiffio.h"
 
 #include "tif_dir.h"
 
+#include <limits.h>
+
 #ifndef STRIP_SIZE_DEFAULT
-# define STRIP_SIZE_DEFAULT 8192
+#define STRIP_SIZE_DEFAULT 8192
 #endif
 
-#define    streq(a,b)      (strcmp(a,b) == 0)
+#ifndef TIFF_MAX_DIR_COUNT
-#define    strneq(a,b,n)   (strncmp(a,b,n) == 0)
+#define TIFF_MAX_DIR_COUNT 1048576
+#endif
+
+#define TIFF_NON_EXISTENT_DIR_NUMBER UINT_MAX
+
+#define streq(a, b) (strcmp(a, b) == 0)
+#define strneq(a, b, n) (strncmp(a, b, n) == 0)
 
 #ifndef TRUE
-#define	TRUE	1
+#define TRUE 1
-#define	FALSE	0
+#define FALSE 0
 #endif
 
-#define TIFF_SIZE_T_MAX ((size_t) ~ ((size_t)0))
+typedef struct client_info
-#define TIFF_TMSIZE_T_MAX (tmsize_t)(TIFF_SIZE_T_MAX >> 1)
+{
-
-/*
- * Largest 32-bit unsigned integer value.
- */
-#define TIFF_UINT32_MAX 0xFFFFFFFFU
-
-/*
- * Largest 64-bit unsigned integer value.
- */
-#define TIFF_UINT64_MAX (((uint64)(TIFF_UINT32_MAX)) << 32 | TIFF_UINT32_MAX)
-
-typedef struct client_info {
     struct client_info *next;
     void *data;
     char *name;
@@ -100,187 +82,231 @@ typedef struct client_info {
  * Typedefs for ``method pointers'' used internally.
  * these are deprecated and provided only for backwards compatibility.
  */
-typedef unsigned char tidataval_t;    /* internal image data value type */
+typedef unsigned char tidataval_t; /* internal image data value type */
-typedef tidataval_t* tidata_t;        /* reference to internal image data */
+typedef tidataval_t *tidata_t;     /* reference to internal image data */
 
-typedef void (*TIFFVoidMethod)(TIFF*);
+typedef void (*TIFFVoidMethod)(TIFF *);
-typedef int (*TIFFBoolMethod)(TIFF*);
+typedef int (*TIFFBoolMethod)(TIFF *);
-typedef int (*TIFFPreMethod)(TIFF*, uint16);
+typedef int (*TIFFPreMethod)(TIFF *, uint16_t);
-typedef int (*TIFFCodeMethod)(TIFF* tif, uint8* buf, tmsize_t size, uint16 sample);
+typedef int (*TIFFCodeMethod)(TIFF *tif, uint8_t *buf, tmsize_t size,
-typedef int (*TIFFSeekMethod)(TIFF*, uint32);
+                              uint16_t sample);
-typedef void (*TIFFPostMethod)(TIFF* tif, uint8* buf, tmsize_t size);
+typedef int (*TIFFSeekMethod)(TIFF *, uint32_t);
-typedef uint32 (*TIFFStripMethod)(TIFF*, uint32);
+typedef void (*TIFFPostMethod)(TIFF *tif, uint8_t *buf, tmsize_t size);
-typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*);
+typedef uint32_t (*TIFFStripMethod)(TIFF *, uint32_t);
+typedef void (*TIFFTileMethod)(TIFF *, uint32_t *, uint32_t *);
 
-struct tiff {
+struct TIFFOffsetAndDirNumber
-	char*                tif_name;         /* name of open file */
+{
-	int                  tif_fd;           /* open file descriptor */
+    uint64_t offset;
-	int                  tif_mode;         /* open mode (O_*) */
+    tdir_t dirNumber;
-	uint32               tif_flags;
+};
-	#define TIFF_FILLORDER   0x00003U /* natural bit fill order for machine */
+typedef struct TIFFOffsetAndDirNumber TIFFOffsetAndDirNumber;
-	#define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */
+
-	#define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */
+struct tiff
-	#define TIFF_BUFFERSETUP 0x00010U /* data buffers setup */
+{
-	#define TIFF_CODERSETUP  0x00020U /* encoder/decoder setup done */
+    char *tif_name; /* name of open file */
-	#define TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */
+    int tif_fd;     /* open file descriptor */
-	#define TIFF_SWAB        0x00080U /* byte swap file information */
+    int tif_mode;   /* open mode (O_*) */
-	#define TIFF_NOBITREV    0x00100U /* inhibit bit reversal logic */
+    uint32_t tif_flags;
-	#define TIFF_MYBUFFER    0x00200U /* my raw data buffer; free on close */
+#define TIFF_FILLORDER 0x00003U   /* natural bit fill order for machine */
-	#define TIFF_ISTILED     0x00400U /* file is tile, not strip- based */
+#define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */
-	#define TIFF_MAPPED      0x00800U /* file is mapped into memory */
+#define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */
-	#define TIFF_POSTENCODE  0x01000U /* need call to postencode routine */
+#define TIFF_BUFFERSETUP 0x00010U /* data buffers setup */
-	#define TIFF_INSUBIFD    0x02000U /* currently writing a subifd */
+#define TIFF_CODERSETUP 0x00020U  /* encoder/decoder setup done */
-	#define TIFF_UPSAMPLED   0x04000U /* library is doing data up-sampling */
+#define TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */
-	#define TIFF_STRIPCHOP   0x08000U /* enable strip chopping support */
+#define TIFF_SWAB 0x00080U        /* byte swap file information */
-	#define TIFF_HEADERONLY  0x10000U /* read header only, do not process the first directory */
+#define TIFF_NOBITREV 0x00100U    /* inhibit bit reversal logic */
-	#define TIFF_NOREADRAW   0x20000U /* skip reading of raw uncompressed image data */
+#define TIFF_MYBUFFER 0x00200U    /* my raw data buffer; free on close */
-	#define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */
+#define TIFF_ISTILED 0x00400U     /* file is tile, not strip- based */
-	#define TIFF_BIGTIFF     0x80000U /* read/write bigtiff */
+#define TIFF_MAPPED 0x00800U      /* file is mapped into memory */
-        #define TIFF_BUF4WRITE  0x100000U /* rawcc bytes are for writing */
+#define TIFF_POSTENCODE 0x01000U  /* need call to postencode routine */
-        #define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/
+#define TIFF_INSUBIFD 0x02000U    /* currently writing a subifd */
-        #define TIFF_PERSAMPLE  0x400000U /* get/set per sample tags as arrays */
+#define TIFF_UPSAMPLED 0x04000U   /* library is doing data up-sampling */
-        #define TIFF_BUFFERMMAP 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
+#define TIFF_STRIPCHOP 0x08000U   /* enable strip chopping support */
-        #define TIFF_DEFERSTRILELOAD 0x1000000U /* defer strip/tile offset/bytecount array loading. */
+#define TIFF_HEADERONLY                                                        \
-        #define TIFF_LAZYSTRILELOAD  0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. Only used if TIFF_DEFERSTRILELOAD is set and in read-only mode */
+    0x10000U /* read header only, do not process the first directory */
-        #define TIFF_CHOPPEDUPARRAYS 0x4000000U /* set when allocChoppedUpStripArrays() has modified strip array */
+#define TIFF_NOREADRAW                                                         \
-	uint64               tif_diroff;       /* file offset of current directory */
+    0x20000U /* skip reading of raw uncompressed image data */
-	uint64               tif_nextdiroff;   /* file offset of following directory */
+#define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */
-	uint64*              tif_dirlist;      /* list of offsets to already seen directories to prevent IFD looping */
+#define TIFF_BIGTIFF 0x80000U     /* read/write bigtiff */
-	uint16               tif_dirlistsize;  /* number of entries in offset list */
+#define TIFF_BUF4WRITE 0x100000U  /* rawcc bytes are for writing */
-	uint16               tif_dirnumber;    /* number of already seen directories */
+#define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/
-	TIFFDirectory        tif_dir;          /* internal rep of current directory */
+#define TIFF_PERSAMPLE 0x400000U  /* get/set per sample tags as arrays */
-	TIFFDirectory        tif_customdir;    /* custom IFDs are separated from the main ones */
+#define TIFF_BUFFERMMAP                                                        \
-	union {
+    0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
-		TIFFHeaderCommon common;
+#define TIFF_DEFERSTRILELOAD                                                   \
-		TIFFHeaderClassic classic;
+    0x1000000U /* defer strip/tile offset/bytecount array loading. */
-		TIFFHeaderBig big;
+#define TIFF_LAZYSTRILELOAD                                                    \
-	} tif_header;
+    0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. \
-	uint16               tif_header_size;  /* file's header block and its length */
+                  Only used if TIFF_DEFERSTRILELOAD is set and in read-only    \
-	uint32               tif_row;          /* current scanline */
+                  mode */
-	uint16               tif_curdir;       /* current directory (index) */
+#define TIFF_CHOPPEDUPARRAYS                                                   \
-	uint32               tif_curstrip;     /* current strip for read/write */
+    0x4000000U /* set when allocChoppedUpStripArrays() has modified strip      \
-	uint64               tif_curoff;       /* current offset for read/write */
+                  array */
-	uint64               tif_dataoff;      /* current offset for writing dir */
+    uint64_t tif_diroff;     /* file offset of current directory */
-	/* SubIFD support */
+    uint64_t tif_nextdiroff; /* file offset of following directory */
-	uint16               tif_nsubifd;      /* remaining subifds to write */
+    uint64_t tif_lastdiroff; /* file offset of last directory written so far */
-	uint64               tif_subifdoff;    /* offset for patching SubIFD link */
+    TIFFHashSet *tif_map_dir_offset_to_number;
-	/* tiling support */
+    TIFFHashSet *tif_map_dir_number_to_offset;
-	uint32               tif_col;          /* current column (offset by row too) */
+    int tif_setdirectory_force_absolute; /* switch between relative and absolute
-	uint32               tif_curtile;      /* current tile for read/write */
+                                            stepping in TIFFSetDirectory() */
-	tmsize_t             tif_tilesize;     /* # of bytes in a tile */
+    TIFFDirectory tif_dir;               /* internal rep of current directory */
-	/* compression scheme hooks */
+    TIFFDirectory
-	int                  tif_decodestatus;
+        tif_customdir; /* custom IFDs are separated from the main ones */
-	TIFFBoolMethod       tif_fixuptags;    /* called in TIFFReadDirectory */
+    union
-	TIFFBoolMethod       tif_setupdecode;  /* called once before predecode */
+    {
-	TIFFPreMethod        tif_predecode;    /* pre- row/strip/tile decoding */
+        TIFFHeaderCommon common;
-	TIFFBoolMethod       tif_setupencode;  /* called once before preencode */
+        TIFFHeaderClassic classic;
-	int                  tif_encodestatus;
+        TIFFHeaderBig big;
-	TIFFPreMethod        tif_preencode;    /* pre- row/strip/tile encoding */
+    } tif_header;
-	TIFFBoolMethod       tif_postencode;   /* post- row/strip/tile encoding */
+    uint16_t tif_header_size;  /* file's header block and its length */
-	TIFFCodeMethod       tif_decoderow;    /* scanline decoding routine */
+    uint32_t tif_row;          /* current scanline */
-	TIFFCodeMethod       tif_encoderow;    /* scanline encoding routine */
+    tdir_t tif_curdir;         /* current directory (index) */
-	TIFFCodeMethod       tif_decodestrip;  /* strip decoding routine */
+    uint32_t tif_curstrip;     /* current strip for read/write */
-	TIFFCodeMethod       tif_encodestrip;  /* strip encoding routine */
+    uint64_t tif_curoff;       /* current offset for read/write */
-	TIFFCodeMethod       tif_decodetile;   /* tile decoding routine */
+    uint64_t tif_lastvalidoff; /* last valid offset allowed for rewrite in
-	TIFFCodeMethod       tif_encodetile;   /* tile encoding routine */
+                                  place. Used only by TIFFAppendToStrip() */
-	TIFFVoidMethod       tif_close;        /* cleanup-on-close routine */
+    uint64_t tif_dataoff;      /* current offset for writing dir */
-	TIFFSeekMethod       tif_seek;         /* position within a strip routine */
+    /* SubIFD support */
-	TIFFVoidMethod       tif_cleanup;      /* cleanup state routine */
+    uint16_t tif_nsubifd;   /* remaining subifds to write */
-	TIFFStripMethod      tif_defstripsize; /* calculate/constrain strip size */
+    uint64_t tif_subifdoff; /* offset for patching SubIFD link */
-	TIFFTileMethod       tif_deftilesize;  /* calculate/constrain tile size */
+    /* tiling support */
-	uint8*               tif_data;         /* compression scheme private data */
+    uint32_t tif_col;      /* current column (offset by row too) */
-	/* input/output buffering */
+    uint32_t tif_curtile;  /* current tile for read/write */
-	tmsize_t             tif_scanlinesize; /* # of bytes in a scanline */
+    tmsize_t tif_tilesize; /* # of bytes in a tile */
-	tmsize_t             tif_scanlineskew; /* scanline skew for reading strips */
+    /* compression scheme hooks */
-	uint8*               tif_rawdata;      /* raw data buffer */
+    int tif_decodestatus;
-	tmsize_t             tif_rawdatasize;  /* # of bytes in raw data buffer */
+    TIFFBoolMethod tif_fixuptags;   /* called in TIFFReadDirectory */
-        tmsize_t             tif_rawdataoff;   /* rawdata offset within strip */
+    TIFFBoolMethod tif_setupdecode; /* called once before predecode */
-        tmsize_t             tif_rawdataloaded;/* amount of data in rawdata */
+    TIFFPreMethod tif_predecode;    /* pre- row/strip/tile decoding */
-	uint8*               tif_rawcp;        /* current spot in raw buffer */
+    TIFFBoolMethod tif_setupencode; /* called once before preencode */
-	tmsize_t             tif_rawcc;        /* bytes unread from raw buffer */
+    int tif_encodestatus;
-	/* memory-mapped file support */
+    TIFFPreMethod tif_preencode;      /* pre- row/strip/tile encoding */
-	uint8*               tif_base;         /* base of mapped file */
+    TIFFBoolMethod tif_postencode;    /* post- row/strip/tile encoding */
-	tmsize_t             tif_size;         /* size of mapped file region (bytes, thus tmsize_t) */
+    TIFFCodeMethod tif_decoderow;     /* scanline decoding routine */
-	TIFFMapFileProc      tif_mapproc;      /* map file method */
+    TIFFCodeMethod tif_encoderow;     /* scanline encoding routine */
-	TIFFUnmapFileProc    tif_unmapproc;    /* unmap file method */
+    TIFFCodeMethod tif_decodestrip;   /* strip decoding routine */
-	/* input/output callback methods */
+    TIFFCodeMethod tif_encodestrip;   /* strip encoding routine */
-	thandle_t            tif_clientdata;   /* callback parameter */
+    TIFFCodeMethod tif_decodetile;    /* tile decoding routine */
-	TIFFReadWriteProc    tif_readproc;     /* read method */
+    TIFFCodeMethod tif_encodetile;    /* tile encoding routine */
-	TIFFReadWriteProc    tif_writeproc;    /* write method */
+    TIFFVoidMethod tif_close;         /* cleanup-on-close routine */
-	TIFFSeekProc         tif_seekproc;     /* lseek method */
+    TIFFSeekMethod tif_seek;          /* position within a strip routine */
-	TIFFCloseProc        tif_closeproc;    /* close method */
+    TIFFVoidMethod tif_cleanup;       /* cleanup state routine */
-	TIFFSizeProc         tif_sizeproc;     /* filesize method */
+    TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */
-	/* post-decoding support */
+    TIFFTileMethod tif_deftilesize;   /* calculate/constrain tile size */
-	TIFFPostMethod       tif_postdecode;   /* post decoding routine */
+    uint8_t *tif_data;                /* compression scheme private data */
-	/* tag support */
+    /* input/output buffering */
-	TIFFField**          tif_fields;       /* sorted table of registered tags */
+    tmsize_t tif_scanlinesize;  /* # of bytes in a scanline */
-	size_t               tif_nfields;      /* # entries in registered tag table */
+    tmsize_t tif_scanlineskew;  /* scanline skew for reading strips */
-	const TIFFField*     tif_foundfield;   /* cached pointer to already found tag */
+    uint8_t *tif_rawdata;       /* raw data buffer */
-	TIFFTagMethods       tif_tagmethods;   /* tag get/set/print routines */
+    tmsize_t tif_rawdatasize;   /* # of bytes in raw data buffer */
-	TIFFClientInfoLink*  tif_clientinfo;   /* extra client information. */
+    tmsize_t tif_rawdataoff;    /* rawdata offset within strip */
-	/* Backward compatibility stuff. We need these two fields for
+    tmsize_t tif_rawdataloaded; /* amount of data in rawdata */
-	 * setting up an old tag extension scheme. */
+    uint8_t *tif_rawcp;         /* current spot in raw buffer */
-	TIFFFieldArray*      tif_fieldscompat;
+    tmsize_t tif_rawcc;         /* bytes unread from raw buffer */
-	size_t               tif_nfieldscompat;
+    /* memory-mapped file support */
+    uint8_t *tif_base; /* base of mapped file */
+    tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */
+    TIFFMapFileProc tif_mapproc;     /* map file method */
+    TIFFUnmapFileProc tif_unmapproc; /* unmap file method */
+    /* input/output callback methods */
+    thandle_t tif_clientdata;        /* callback parameter */
+    TIFFReadWriteProc tif_readproc;  /* read method */
+    TIFFReadWriteProc tif_writeproc; /* write method */
+    TIFFSeekProc tif_seekproc;       /* lseek method */
+    TIFFCloseProc tif_closeproc;     /* close method */
+    TIFFSizeProc tif_sizeproc;       /* filesize method */
+    /* post-decoding support */
+    TIFFPostMethod tif_postdecode; /* post decoding routine */
+    /* tag support */
+    TIFFField **tif_fields;          /* sorted table of registered tags */
+    size_t tif_nfields;              /* # entries in registered tag table */
+    const TIFFField *tif_foundfield; /* cached pointer to already found tag */
+    TIFFTagMethods tif_tagmethods;   /* tag get/set/print routines */
+    TIFFClientInfoLink *tif_clientinfo; /* extra client information. */
+    /* Backward compatibility stuff. We need these two fields for
+     * setting up an old tag extension scheme. */
+    TIFFFieldArray *tif_fieldscompat;
+    size_t tif_nfieldscompat;
+    /* Error handler support */
+    TIFFErrorHandlerExtR tif_errorhandler;
+    void *tif_errorhandler_user_data;
+    TIFFErrorHandlerExtR tif_warnhandler;
+    void *tif_warnhandler_user_data;
+    tmsize_t tif_max_single_mem_alloc; /* in bytes. 0 for unlimited */
 };
 
-#define isPseudoTag(t) (t > 0xffff)            /* is tag value normal or pseudo */
+struct TIFFOpenOptions
+{
+    TIFFErrorHandlerExtR errorhandler; /* may be NULL */
+    void *errorhandler_user_data;      /* may be NULL */
+    TIFFErrorHandlerExtR warnhandler;  /* may be NULL */
+    void *warnhandler_user_data;       /* may be NULL */
+    tmsize_t max_single_mem_alloc;     /* in bytes. 0 for unlimited */
+};
+
+#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
 
 #define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
 #define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
 #define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
 #define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
-#define TIFFReadFile(tif, buf, size) \
+#define TIFFReadFile(tif, buf, size)                                           \
-	((*(tif)->tif_readproc)((tif)->tif_clientdata,(buf),(size)))
+    ((*(tif)->tif_readproc)((tif)->tif_clientdata, (buf), (size)))
-#define TIFFWriteFile(tif, buf, size) \
+#define TIFFWriteFile(tif, buf, size)                                          \
-	((*(tif)->tif_writeproc)((tif)->tif_clientdata,(buf),(size)))
+    ((*(tif)->tif_writeproc)((tif)->tif_clientdata, (buf), (size)))
-#define TIFFSeekFile(tif, off, whence) \
+#define TIFFSeekFile(tif, off, whence)                                         \
-	((*(tif)->tif_seekproc)((tif)->tif_clientdata,(off),(whence)))
+    ((*(tif)->tif_seekproc)((tif)->tif_clientdata, (off), (whence)))
-#define TIFFCloseFile(tif) \
+#define TIFFCloseFile(tif) ((*(tif)->tif_closeproc)((tif)->tif_clientdata))
-	((*(tif)->tif_closeproc)((tif)->tif_clientdata))
+#define TIFFGetFileSize(tif) ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
-#define TIFFGetFileSize(tif) \
+#define TIFFMapFileContents(tif, paddr, psize)                                 \
-	((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
+    ((*(tif)->tif_mapproc)((tif)->tif_clientdata, (paddr), (psize)))
-#define TIFFMapFileContents(tif, paddr, psize) \
+#define TIFFUnmapFileContents(tif, addr, size)                                 \
-	((*(tif)->tif_mapproc)((tif)->tif_clientdata,(paddr),(psize)))
+    ((*(tif)->tif_unmapproc)((tif)->tif_clientdata, (addr), (size)))
-#define TIFFUnmapFileContents(tif, addr, size) \
-	((*(tif)->tif_unmapproc)((tif)->tif_clientdata,(addr),(size)))
 
 /*
  * Default Read/Seek/Write definitions.
  */
 #ifndef ReadOK
-#define ReadOK(tif, buf, size) \
+#define ReadOK(tif, buf, size) (TIFFReadFile((tif), (buf), (size)) == (size))
-	(TIFFReadFile((tif),(buf),(size))==(size))
 #endif
 #ifndef SeekOK
 #define SeekOK(tif, off) _TIFFSeekOK(tif, off)
 #endif
 #ifndef WriteOK
-#define WriteOK(tif, buf, size) \
+#define WriteOK(tif, buf, size) (TIFFWriteFile((tif), (buf), (size)) == (size))
-	(TIFFWriteFile((tif),(buf),(size))==(size))
 #endif
 
-/* NB: the uint32 casts are to silence certain ANSI-C compilers */
+/* NB: the uint32_t casts are to silence certain ANSI-C compilers */
-#define TIFFhowmany_32(x, y) (((uint32)x < (0xffffffff - (uint32)(y-1))) ? \
+#define TIFFhowmany_32(x, y)                                                   \
-			   ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) : \
+    (((uint32_t)x < (0xffffffff - (uint32_t)(y - 1)))                          \
-			   0U)
+         ? ((((uint32_t)(x)) + (((uint32_t)(y)) - 1)) / ((uint32_t)(y)))       \
+         : 0U)
 /* Variant of TIFFhowmany_32() that doesn't return 0 if x close to MAXUINT. */
 /* Caution: TIFFhowmany_32_maxuint_compat(x,y)*y might overflow */
-#define TIFFhowmany_32_maxuint_compat(x, y) \
+#define TIFFhowmany_32_maxuint_compat(x, y)                                    \
-			   (((uint32)(x) / (uint32)(y)) + ((((uint32)(x) % (uint32)(y)) != 0) ? 1 : 0))
+    (((uint32_t)(x) / (uint32_t)(y)) +                                         \
-#define TIFFhowmany8_32(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
+     ((((uint32_t)(x) % (uint32_t)(y)) != 0) ? 1 : 0))
-#define TIFFroundup_32(x, y) (TIFFhowmany_32(x,y)*(y))
+#define TIFFhowmany8_32(x)                                                     \
-#define TIFFhowmany_64(x, y) ((((uint64)(x))+(((uint64)(y))-1))/((uint64)(y)))
+    (((x)&0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)
-#define TIFFhowmany8_64(x) (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(x)>>3)
+#define TIFFroundup_32(x, y) (TIFFhowmany_32(x, y) * (y))
-#define TIFFroundup_64(x, y) (TIFFhowmany_64(x,y)*(y))
+#define TIFFhowmany_64(x, y)                                                   \
+    ((((uint64_t)(x)) + (((uint64_t)(y)) - 1)) / ((uint64_t)(y)))
+#define TIFFhowmany8_64(x)                                                     \
+    (((x)&0x07) ? ((uint64_t)(x) >> 3) + 1 : (uint64_t)(x) >> 3)
+#define TIFFroundup_64(x, y) (TIFFhowmany_64(x, y) * (y))
 
-/* Safe multiply which returns zero if there is an *unsigned* integer overflow. This macro is not safe for *signed* integer types */
+/* Safe multiply which returns zero if there is an *unsigned* integer overflow.
-#define TIFFSafeMultiply(t,v,m) ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0)
+ * This macro is not safe for *signed* integer types */
+#define TIFFSafeMultiply(t, v, m)                                              \
+    ((((t)(m) != (t)0) && (((t)(((v) * (m)) / (m))) == (t)(v)))                \
+         ? (t)((v) * (m))                                                      \
+         : (t)0)
 
-#define TIFFmax(A,B) ((A)>(B)?(A):(B))
+#define TIFFmax(A, B) ((A) > (B) ? (A) : (B))
-#define TIFFmin(A,B) ((A)<(B)?(A):(B))
+#define TIFFmin(A, B) ((A) < (B) ? (A) : (B))
 
-#define TIFFArrayCount(a) (sizeof (a) / sizeof ((a)[0]))
+#define TIFFArrayCount(a) (sizeof(a) / sizeof((a)[0]))
 
 /*
   Support for large files.
@@ -301,28 +327,31 @@ struct tiff {
   must be available on the target computer in order for the program to run.
 */
 #if defined(HAVE_FSEEKO)
-#  define fseek(stream,offset,whence)  fseeko(stream,offset,whence)
+#define fseek(stream, offset, whence) fseeko(stream, offset, whence)
-#  define ftell(stream,offset,whence)  ftello(stream,offset,whence)
+#define ftell(stream, offset, whence) ftello(stream, offset, whence)
 #endif
 #endif
-#if defined(__WIN32__) && \
+#if defined(__WIN32__) && !(defined(_MSC_VER) && _MSC_VER < 1400) &&           \
-        !(defined(_MSC_VER) && _MSC_VER < 1400) && \
+    !(defined(__MSVCRT_VERSION__) && __MSVCRT_VERSION__ < 0x800)
-        !(defined(__MSVCRT_VERSION__) && __MSVCRT_VERSION__ < 0x800)
 typedef unsigned int TIFFIOSize_t;
-#define _TIFF_lseek_f(fildes,offset,whence)  _lseeki64(fildes,/* __int64 */ offset,whence)
+#define _TIFF_lseek_f(fildes, offset, whence)                                  \
+    _lseeki64(fildes, /* __int64 */ offset, whence)
 /* #define _TIFF_tell_f(fildes) /\* __int64 *\/ _telli64(fildes) */
-#define _TIFF_fseek_f(stream,offset,whence) _fseeki64(stream,/* __int64 */ offset,whence)
+#define _TIFF_fseek_f(stream, offset, whence)                                  \
-#define _TIFF_fstat_f(fildes,stat_buff) _fstati64(fildes,/* struct _stati64 */ stat_buff)
+    _fseeki64(stream, /* __int64 */ offset, whence)
+#define _TIFF_fstat_f(fildes, stat_buff)                                       \
+    _fstati64(fildes, /* struct _stati64 */ stat_buff)
 /* #define _TIFF_ftell_f(stream) /\* __int64 *\/ _ftelli64(stream) */
-/* #define _TIFF_stat_f(path,stat_buff) _stati64(path,/\* struct _stati64 *\/ stat_buff) */
+/* #define _TIFF_stat_f(path,stat_buff) _stati64(path,/\* struct _stati64 *\/
+ * stat_buff) */
 #define _TIFF_stat_s struct _stati64
 #define _TIFF_off_t __int64
 #else
 typedef size_t TIFFIOSize_t;
-#define _TIFF_lseek_f(fildes,offset,whence) lseek(fildes,offset,whence)
+#define _TIFF_lseek_f(fildes, offset, whence) lseek(fildes, offset, whence)
 /* #define _TIFF_tell_f(fildes) (_TIFF_lseek_f(fildes,0,SEEK_CUR)) */
-#define _TIFF_fseek_f(stream,offset,whence) fseek(stream,offset,whence)
+#define _TIFF_fseek_f(stream, offset, whence) fseek(stream, offset, whence)
-#define _TIFF_fstat_f(fildes,stat_buff) fstat(fildes,stat_buff)
+#define _TIFF_fstat_f(fildes, stat_buff) fstat(fildes, stat_buff)
 /* #define _TIFF_ftell_f(stream) ftell(stream) */
 /* #define _TIFF_stat_f(path,stat_buff) stat(path,stat_buff) */
 #define _TIFF_stat_s struct stat
@@ -331,7 +360,8 @@ typedef size_t TIFFIOSize_t;
 
 #if defined(__has_attribute) && defined(__clang__)
 #if __has_attribute(no_sanitize)
-#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW __attribute__((no_sanitize("unsigned-integer-overflow")))
+#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW                                  \
+    __attribute__((no_sanitize("unsigned-integer-overflow")))
 #else
 #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
 #endif
@@ -339,139 +369,155 @@ typedef size_t TIFFIOSize_t;
 #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
 #endif
 
-
 #if defined(__cplusplus)
-extern "C" {
+extern "C"
+{
 #endif
-extern int _TIFFgetMode(const char* mode, const char* module);
+    extern int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata,
-extern int _TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
+                            const char *mode, const char *module);
-extern int _TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
+    extern int _TIFFNoRowEncode(TIFF *tif, uint8_t *pp, tmsize_t cc,
-extern int _TIFFNoTileEncode(TIFF*, uint8* pp, tmsize_t cc, uint16 s);
+                                uint16_t s);
-extern int _TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
+    extern int _TIFFNoStripEncode(TIFF *tif, uint8_t *pp, tmsize_t cc,
-extern int _TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
+                                  uint16_t s);
-extern int _TIFFNoTileDecode(TIFF*, uint8* pp, tmsize_t cc, uint16 s);
+    extern int _TIFFNoTileEncode(TIFF *, uint8_t *pp, tmsize_t cc, uint16_t s);
-extern void _TIFFNoPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
+    extern int _TIFFNoRowDecode(TIFF *tif, uint8_t *pp, tmsize_t cc,
-extern int _TIFFNoPreCode(TIFF* tif, uint16 s);
+                                uint16_t s);
-extern int _TIFFNoSeek(TIFF* tif, uint32 off);
+    extern int _TIFFNoStripDecode(TIFF *tif, uint8_t *pp, tmsize_t cc,
-extern void _TIFFSwab16BitData(TIFF* tif, uint8* buf, tmsize_t cc);
+                                  uint16_t s);
-extern void _TIFFSwab24BitData(TIFF* tif, uint8* buf, tmsize_t cc);
+    extern int _TIFFNoTileDecode(TIFF *, uint8_t *pp, tmsize_t cc, uint16_t s);
-extern void _TIFFSwab32BitData(TIFF* tif, uint8* buf, tmsize_t cc);
+    extern void _TIFFNoPostDecode(TIFF *tif, uint8_t *buf, tmsize_t cc);
-extern void _TIFFSwab64BitData(TIFF* tif, uint8* buf, tmsize_t cc);
+    extern int _TIFFNoPreCode(TIFF *tif, uint16_t s);
-extern int TIFFFlushData1(TIFF* tif);
+    extern int _TIFFNoSeek(TIFF *tif, uint32_t off);
-extern int TIFFDefaultDirectory(TIFF* tif);
+    extern void _TIFFSwab16BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
-extern void _TIFFSetDefaultCompressionState(TIFF* tif);
+    extern void _TIFFSwab24BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
-extern int _TIFFRewriteField(TIFF *, uint16, TIFFDataType, tmsize_t, void *);
+    extern void _TIFFSwab32BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
-extern int TIFFSetCompressionScheme(TIFF* tif, int scheme);
+    extern void _TIFFSwab64BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
-extern int TIFFSetDefaultCompressionState(TIFF* tif);
+    extern int TIFFFlushData1(TIFF *tif);
-extern uint32 _TIFFDefaultStripSize(TIFF* tif, uint32 s);
+    extern int TIFFDefaultDirectory(TIFF *tif);
-extern void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th);
+    extern void _TIFFSetDefaultCompressionState(TIFF *tif);
-extern int _TIFFDataSize(TIFFDataType type);
+    extern int _TIFFRewriteField(TIFF *, uint16_t, TIFFDataType, tmsize_t,
+                                 void *);
+    extern int TIFFSetCompressionScheme(TIFF *tif, int scheme);
+    extern int TIFFSetDefaultCompressionState(TIFF *tif);
+    extern uint32_t _TIFFDefaultStripSize(TIFF *tif, uint32_t s);
+    extern void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th);
 
-/*--: Rational2Double: Return size of TIFFSetGetFieldType in bytes. */
+    extern void _TIFFsetByteArray(void **, const void *, uint32_t);
-extern int _TIFFSetGetFieldSize(TIFFSetGetFieldType setgettype);
+    extern void _TIFFsetByteArrayExt(TIFF *, void **, const void *, uint32_t);
+    extern void _TIFFsetShortArray(uint16_t **, const uint16_t *, uint32_t);
+    extern void _TIFFsetShortArrayExt(TIFF *, uint16_t **, const uint16_t *,
+                                      uint32_t);
+    extern void _TIFFsetLongArray(uint32_t **, const uint32_t *, uint32_t);
+    extern void _TIFFsetLongArrayExt(TIFF *, uint32_t **, const uint32_t *,
+                                     uint32_t);
+    extern void _TIFFsetFloatArray(float **, const float *, uint32_t);
+    extern void _TIFFsetFloatArrayExt(TIFF *, float **, const float *,
+                                      uint32_t);
+    extern void _TIFFsetDoubleArray(double **, const double *, uint32_t);
+    extern void _TIFFsetDoubleArrayExt(TIFF *, double **, const double *,
+                                       uint32_t);
 
-extern void _TIFFsetByteArray(void**, void*, uint32);
+    extern void _TIFFprintAscii(FILE *, const char *);
-extern void _TIFFsetString(char**, char*);
+    extern void _TIFFprintAsciiTag(FILE *, const char *, const char *);
-extern void _TIFFsetShortArray(uint16**, uint16*, uint32);
-extern void _TIFFsetLongArray(uint32**, uint32*, uint32);
-extern void _TIFFsetFloatArray(float**, float*, uint32);
-extern void _TIFFsetDoubleArray(double**, double*, uint32);
 
-extern void _TIFFprintAscii(FILE*, const char*);
+    extern TIFFErrorHandler _TIFFwarningHandler;
-extern void _TIFFprintAsciiTag(FILE*, const char*, const char*);
+    extern TIFFErrorHandler _TIFFerrorHandler;
+    extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
+    extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
+    void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata,
+                         const char *module, const char *fmt, ...)
+        TIFF_ATTRIBUTE((__format__(__printf__, 4, 5)));
 
-extern TIFFErrorHandler _TIFFwarningHandler;
+    extern uint32_t _TIFFMultiply32(TIFF *, uint32_t, uint32_t, const char *);
-extern TIFFErrorHandler _TIFFerrorHandler;
+    extern uint64_t _TIFFMultiply64(TIFF *, uint64_t, uint64_t, const char *);
-extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
+    extern tmsize_t _TIFFMultiplySSize(TIFF *, tmsize_t, tmsize_t,
-extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
+                                       const char *);
+    extern tmsize_t _TIFFCastUInt64ToSSize(TIFF *, uint64_t, const char *);
+    extern void *_TIFFCheckMalloc(TIFF *, tmsize_t, tmsize_t, const char *);
+    extern void *_TIFFCheckRealloc(TIFF *, void *, tmsize_t, tmsize_t,
+                                   const char *);
 
-extern uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*);
+    extern double _TIFFUInt64ToDouble(uint64_t);
-extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*);
+    extern float _TIFFUInt64ToFloat(uint64_t);
-extern tmsize_t _TIFFMultiplySSize(TIFF*, tmsize_t, tmsize_t, const char*);
-extern tmsize_t _TIFFCastUInt64ToSSize(TIFF*, uint64, const char*);
-extern void* _TIFFCheckMalloc(TIFF*, tmsize_t, tmsize_t, const char*);
-extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*);
 
-extern double _TIFFUInt64ToDouble(uint64);
+    extern float _TIFFClampDoubleToFloat(double);
-extern float _TIFFUInt64ToFloat(uint64);
+    extern uint32_t _TIFFClampDoubleToUInt32(double);
 
-extern float _TIFFClampDoubleToFloat(double);
+    extern void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif);
 
-extern tmsize_t
+    extern tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif,
-_TIFFReadEncodedStripAndAllocBuffer(TIFF* tif, uint32 strip,
+                                                        uint32_t strip,
-                                    void **buf, tmsize_t bufsizetoalloc,
+                                                        void **buf,
-                                    tmsize_t size_to_read);
+                                                        tmsize_t bufsizetoalloc,
-extern tmsize_t
+                                                        tmsize_t size_to_read);
-_TIFFReadEncodedTileAndAllocBuffer(TIFF* tif, uint32 tile,
+    extern tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32_t tile,
-                                    void **buf, tmsize_t bufsizetoalloc,
+                                                       void **buf,
-                                    tmsize_t size_to_read);
+                                                       tmsize_t bufsizetoalloc,
-extern tmsize_t
+                                                       tmsize_t size_to_read);
-_TIFFReadTileAndAllocBuffer(TIFF* tif,
+    extern tmsize_t _TIFFReadTileAndAllocBuffer(TIFF *tif, void **buf,
-                            void **buf, tmsize_t bufsizetoalloc,
+                                                tmsize_t bufsizetoalloc,
-                            uint32 x, uint32 y, uint32 z, uint16 s);
+                                                uint32_t x, uint32_t y,
-extern int _TIFFSeekOK(TIFF* tif, toff_t off);
+                                                uint32_t z, uint16_t s);
+    extern int _TIFFSeekOK(TIFF *tif, toff_t off);
 
-extern int TIFFInitDumpMode(TIFF*, int);
+    extern int TIFFInitDumpMode(TIFF *, int);
 #ifdef PACKBITS_SUPPORT
-extern int TIFFInitPackBits(TIFF*, int);
+    extern int TIFFInitPackBits(TIFF *, int);
 #endif
 #ifdef CCITT_SUPPORT
-extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int);
+    extern int TIFFInitCCITTRLE(TIFF *, int), TIFFInitCCITTRLEW(TIFF *, int);
-extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int);
+    extern int TIFFInitCCITTFax3(TIFF *, int), TIFFInitCCITTFax4(TIFF *, int);
 #endif
 #ifdef THUNDER_SUPPORT
-extern int TIFFInitThunderScan(TIFF*, int);
+    extern int TIFFInitThunderScan(TIFF *, int);
 #endif
 #ifdef NEXT_SUPPORT
-extern int TIFFInitNeXT(TIFF*, int);
+    extern int TIFFInitNeXT(TIFF *, int);
 #endif
 #ifdef LZW_SUPPORT
-extern int TIFFInitLZW(TIFF*, int);
+    extern int TIFFInitLZW(TIFF *, int);
 #endif
 #ifdef OJPEG_SUPPORT
-extern int TIFFInitOJPEG(TIFF*, int);
+    extern int TIFFInitOJPEG(TIFF *, int);
 #endif
 #ifdef JPEG_SUPPORT
-extern int TIFFInitJPEG(TIFF*, int);
+    extern int TIFFInitJPEG(TIFF *, int);
-extern int TIFFJPEGIsFullStripRequired(TIFF*);
+    extern int TIFFJPEGIsFullStripRequired(TIFF *);
 #endif
 #ifdef JBIG_SUPPORT
-extern int TIFFInitJBIG(TIFF*, int);
+    extern int TIFFInitJBIG(TIFF *, int);
 #endif
 #ifdef ZIP_SUPPORT
-extern int TIFFInitZIP(TIFF*, int);
+    extern int TIFFInitZIP(TIFF *, int);
 #endif
 #ifdef PIXARLOG_SUPPORT
-extern int TIFFInitPixarLog(TIFF*, int);
+    extern int TIFFInitPixarLog(TIFF *, int);
 #endif
 #ifdef LOGLUV_SUPPORT
-extern int TIFFInitSGILog(TIFF*, int);
+    extern int TIFFInitSGILog(TIFF *, int);
+#endif
+#ifdef LERC_SUPPORT
+    extern int TIFFInitLERC(TIFF *tif, int);
 #endif
 #ifdef LZMA_SUPPORT
-extern int TIFFInitLZMA(TIFF*, int);
+    extern int TIFFInitLZMA(TIFF *, int);
 #endif
 #ifdef ZSTD_SUPPORT
-extern int TIFFInitZSTD(TIFF*, int);
+    extern int TIFFInitZSTD(TIFF *, int);
 #endif
 #ifdef WEBP_SUPPORT
-extern int TIFFInitWebP(TIFF*, int);
+    extern int TIFFInitWebP(TIFF *, int);
-#endif
-#ifdef VMS
-extern const TIFFCodec _TIFFBuiltinCODECS[];
-#else
-extern TIFFCodec _TIFFBuiltinCODECS[];
 #endif
+    extern const TIFFCodec _TIFFBuiltinCODECS[];
+    extern void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *, uint32_t l, int32_t a,
+                                  int32_t b, float *, float *, float *);
+
+    extern void *_TIFFmallocExt(TIFF *tif, tmsize_t s);
+    extern void *_TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz);
+    extern void *_TIFFreallocExt(TIFF *tif, void *p, tmsize_t s);
+    extern void _TIFFfreeExt(TIFF *tif, void *p);
 
 #if defined(__cplusplus)
 }
 #endif
 #endif /* _TIFFIOP_ */
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/libtiff/tiffvers.h

@@ -1,9 +0,0 @@
-#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.2.0\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
-/*
- * This define can be used in code that requires
- * compilation-related definitions specific to a
- * version or versions of the library.  Runtime
- * version checking should be done based on the
- * string returned by TIFFGetVersion.
- */
-#define TIFFLIB_VERSION 20201219

3rdparty/libtiff/tiffvers.h.cmake.in

@@ -0,0 +1,36 @@
+/* tiffvers.h version information is updated according to version information
+ * in configure.ac */
+
+/* clang-format off */
+
+/* clang-format disabled because FindTIFF.cmake is very sensitive to the
+ * formatting of below line being a single line.
+ * Furthermore, configure_file variables of type "@VAR@" are
+ * modified by clang-format and won't be substituted by CMake.
+ */
+#define TIFFLIB_VERSION_STR "LIBTIFF, Version @LIBTIFF_VERSION@\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
+/*
+ * This define can be used in code that requires
+ * compilation-related definitions specific to a
+ * version or versions of the library.  Runtime
+ * version checking should be done based on the
+ * string returned by TIFFGetVersion.
+ */
+#define TIFFLIB_VERSION @LIBTIFF_RELEASE_DATE@
+
+/* The following defines have been added in 4.5.0 */
+#define TIFFLIB_MAJOR_VERSION @LIBTIFF_MAJOR_VERSION@
+#define TIFFLIB_MINOR_VERSION @LIBTIFF_MINOR_VERSION@
+#define TIFFLIB_MICRO_VERSION @LIBTIFF_MICRO_VERSION@
+#define TIFFLIB_VERSION_STR_MAJ_MIN_MIC "@LIBTIFF_VERSION@"
+
+/* Macro added in 4.5.0. Returns TRUE if the current libtiff version is
+ * greater or equal to major.minor.micro
+ */
+#define TIFFLIB_AT_LEAST(major, minor, micro) \
+    (TIFFLIB_MAJOR_VERSION > (major) || \
+     (TIFFLIB_MAJOR_VERSION == (major) && TIFFLIB_MINOR_VERSION > (minor)) || \
+     (TIFFLIB_MAJOR_VERSION == (major) && TIFFLIB_MINOR_VERSION == (minor) && \
+      TIFFLIB_MICRO_VERSION >= (micro)))
+
+/* clang-format on */

3rdparty/libtiff/uvcode.h

@@ -1,180 +1,93 @@
 /* Version 1.0 generated April 7, 1997 by Greg Ward Larson, SGI */
-#define UV_SQSIZ	(float)0.003500
+#define UV_SQSIZ (float)0.003500
-#define UV_NDIVS	16289
+#define UV_NDIVS 16289
-#define UV_VSTART	(float)0.016940
+#define UV_VSTART (float)0.016940
-#define UV_NVS		163
+#define UV_NVS 163
-static const struct {
+static const struct
-	float	ustart;
+{
-	short	nus, ncum;
+    float ustart;
-}	uv_row[UV_NVS] = {
+    short nus, ncum;
-	{ (float)0.247663,	4,	0 },
+} uv_row[UV_NVS] = {
-	{ (float)0.243779,	6,	4 },
+    {(float)0.247663, 4, 0},       {(float)0.243779, 6, 4},
-	{ (float)0.241684,	7,	10 },
+    {(float)0.241684, 7, 10},      {(float)0.237874, 9, 17},
-	{ (float)0.237874,	9,	17 },
+    {(float)0.235906, 10, 26},     {(float)0.232153, 12, 36},
-	{ (float)0.235906,	10,	26 },
+    {(float)0.228352, 14, 48},     {(float)0.226259, 15, 62},
-	{ (float)0.232153,	12,	36 },
+    {(float)0.222371, 17, 77},     {(float)0.220410, 18, 94},
-	{ (float)0.228352,	14,	48 },
+    {(float)0.214710, 21, 112},    {(float)0.212714, 22, 133},
-	{ (float)0.226259,	15,	62 },
+    {(float)0.210721, 23, 155},    {(float)0.204976, 26, 178},
-	{ (float)0.222371,	17,	77 },
+    {(float)0.202986, 27, 204},    {(float)0.199245, 29, 231},
-	{ (float)0.220410,	18,	94 },
+    {(float)0.195525, 31, 260},    {(float)0.193560, 32, 291},
-	{ (float)0.214710,	21,	112 },
+    {(float)0.189878, 34, 323},    {(float)0.186216, 36, 357},
-	{ (float)0.212714,	22,	133 },
+    {(float)0.186216, 36, 393},    {(float)0.182592, 38, 429},
-	{ (float)0.210721,	23,	155 },
+    {(float)0.179003, 40, 467},    {(float)0.175466, 42, 507},
-	{ (float)0.204976,	26,	178 },
+    {(float)0.172001, 44, 549},    {(float)0.172001, 44, 593},
-	{ (float)0.202986,	27,	204 },
+    {(float)0.168612, 46, 637},    {(float)0.168612, 46, 683},
-	{ (float)0.199245,	29,	231 },
+    {(float)0.163575, 49, 729},    {(float)0.158642, 52, 778},
-	{ (float)0.195525,	31,	260 },
+    {(float)0.158642, 52, 830},    {(float)0.158642, 52, 882},
-	{ (float)0.193560,	32,	291 },
+    {(float)0.153815, 55, 934},    {(float)0.153815, 55, 989},
-	{ (float)0.189878,	34,	323 },
+    {(float)0.149097, 58, 1044},   {(float)0.149097, 58, 1102},
-	{ (float)0.186216,	36,	357 },
+    {(float)0.142746, 62, 1160},   {(float)0.142746, 62, 1222},
-	{ (float)0.186216,	36,	393 },
+    {(float)0.142746, 62, 1284},   {(float)0.138270, 65, 1346},
-	{ (float)0.182592,	38,	429 },
+    {(float)0.138270, 65, 1411},   {(float)0.138270, 65, 1476},
-	{ (float)0.179003,	40,	467 },
+    {(float)0.132166, 69, 1541},   {(float)0.132166, 69, 1610},
-	{ (float)0.175466,	42,	507 },
+    {(float)0.126204, 73, 1679},   {(float)0.126204, 73, 1752},
-	{ (float)0.172001,	44,	549 },
+    {(float)0.126204, 73, 1825},   {(float)0.120381, 77, 1898},
-	{ (float)0.172001,	44,	593 },
+    {(float)0.120381, 77, 1975},   {(float)0.120381, 77, 2052},
-	{ (float)0.168612,	46,	637 },
+    {(float)0.120381, 77, 2129},   {(float)0.112962, 82, 2206},
-	{ (float)0.168612,	46,	683 },
+    {(float)0.112962, 82, 2288},   {(float)0.112962, 82, 2370},
-	{ (float)0.163575,	49,	729 },
+    {(float)0.107450, 86, 2452},   {(float)0.107450, 86, 2538},
-	{ (float)0.158642,	52,	778 },
+    {(float)0.107450, 86, 2624},   {(float)0.107450, 86, 2710},
-	{ (float)0.158642,	52,	830 },
+    {(float)0.100343, 91, 2796},   {(float)0.100343, 91, 2887},
-	{ (float)0.158642,	52,	882 },
+    {(float)0.100343, 91, 2978},   {(float)0.095126, 95, 3069},
-	{ (float)0.153815,	55,	934 },
+    {(float)0.095126, 95, 3164},   {(float)0.095126, 95, 3259},
-	{ (float)0.153815,	55,	989 },
+    {(float)0.095126, 95, 3354},   {(float)0.088276, 100, 3449},
-	{ (float)0.149097,	58,	1044 },
+    {(float)0.088276, 100, 3549},  {(float)0.088276, 100, 3649},
-	{ (float)0.149097,	58,	1102 },
+    {(float)0.088276, 100, 3749},  {(float)0.081523, 105, 3849},
-	{ (float)0.142746,	62,	1160 },
+    {(float)0.081523, 105, 3954},  {(float)0.081523, 105, 4059},
-	{ (float)0.142746,	62,	1222 },
+    {(float)0.081523, 105, 4164},  {(float)0.074861, 110, 4269},
-	{ (float)0.142746,	62,	1284 },
+    {(float)0.074861, 110, 4379},  {(float)0.074861, 110, 4489},
-	{ (float)0.138270,	65,	1346 },
+    {(float)0.074861, 110, 4599},  {(float)0.068290, 115, 4709},
-	{ (float)0.138270,	65,	1411 },
+    {(float)0.068290, 115, 4824},  {(float)0.068290, 115, 4939},
-	{ (float)0.138270,	65,	1476 },
+    {(float)0.068290, 115, 5054},  {(float)0.063573, 119, 5169},
-	{ (float)0.132166,	69,	1541 },
+    {(float)0.063573, 119, 5288},  {(float)0.063573, 119, 5407},
-	{ (float)0.132166,	69,	1610 },
+    {(float)0.063573, 119, 5526},  {(float)0.057219, 124, 5645},
-	{ (float)0.126204,	73,	1679 },
+    {(float)0.057219, 124, 5769},  {(float)0.057219, 124, 5893},
-	{ (float)0.126204,	73,	1752 },
+    {(float)0.057219, 124, 6017},  {(float)0.050985, 129, 6141},
-	{ (float)0.126204,	73,	1825 },
+    {(float)0.050985, 129, 6270},  {(float)0.050985, 129, 6399},
-	{ (float)0.120381,	77,	1898 },
+    {(float)0.050985, 129, 6528},  {(float)0.050985, 129, 6657},
-	{ (float)0.120381,	77,	1975 },
+    {(float)0.044859, 134, 6786},  {(float)0.044859, 134, 6920},
-	{ (float)0.120381,	77,	2052 },
+    {(float)0.044859, 134, 7054},  {(float)0.044859, 134, 7188},
-	{ (float)0.120381,	77,	2129 },
+    {(float)0.040571, 138, 7322},  {(float)0.040571, 138, 7460},
-	{ (float)0.112962,	82,	2206 },
+    {(float)0.040571, 138, 7598},  {(float)0.040571, 138, 7736},
-	{ (float)0.112962,	82,	2288 },
+    {(float)0.036339, 142, 7874},  {(float)0.036339, 142, 8016},
-	{ (float)0.112962,	82,	2370 },
+    {(float)0.036339, 142, 8158},  {(float)0.036339, 142, 8300},
-	{ (float)0.107450,	86,	2452 },
+    {(float)0.032139, 146, 8442},  {(float)0.032139, 146, 8588},
-	{ (float)0.107450,	86,	2538 },
+    {(float)0.032139, 146, 8734},  {(float)0.032139, 146, 8880},
-	{ (float)0.107450,	86,	2624 },
+    {(float)0.027947, 150, 9026},  {(float)0.027947, 150, 9176},
-	{ (float)0.107450,	86,	2710 },
+    {(float)0.027947, 150, 9326},  {(float)0.023739, 154, 9476},
-	{ (float)0.100343,	91,	2796 },
+    {(float)0.023739, 154, 9630},  {(float)0.023739, 154, 9784},
-	{ (float)0.100343,	91,	2887 },
+    {(float)0.023739, 154, 9938},  {(float)0.019504, 158, 10092},
-	{ (float)0.100343,	91,	2978 },
+    {(float)0.019504, 158, 10250}, {(float)0.019504, 158, 10408},
-	{ (float)0.095126,	95,	3069 },
+    {(float)0.016976, 161, 10566}, {(float)0.016976, 161, 10727},
-	{ (float)0.095126,	95,	3164 },
+    {(float)0.016976, 161, 10888}, {(float)0.016976, 161, 11049},
-	{ (float)0.095126,	95,	3259 },
+    {(float)0.012639, 165, 11210}, {(float)0.012639, 165, 11375},
-	{ (float)0.095126,	95,	3354 },
+    {(float)0.012639, 165, 11540}, {(float)0.009991, 168, 11705},
-	{ (float)0.088276,	100,	3449 },
+    {(float)0.009991, 168, 11873}, {(float)0.009991, 168, 12041},
-	{ (float)0.088276,	100,	3549 },
+    {(float)0.009016, 170, 12209}, {(float)0.009016, 170, 12379},
-	{ (float)0.088276,	100,	3649 },
+    {(float)0.009016, 170, 12549}, {(float)0.006217, 173, 12719},
-	{ (float)0.088276,	100,	3749 },
+    {(float)0.006217, 173, 12892}, {(float)0.005097, 175, 13065},
-	{ (float)0.081523,	105,	3849 },
+    {(float)0.005097, 175, 13240}, {(float)0.005097, 175, 13415},
-	{ (float)0.081523,	105,	3954 },
+    {(float)0.003909, 177, 13590}, {(float)0.003909, 177, 13767},
-	{ (float)0.081523,	105,	4059 },
+    {(float)0.002340, 177, 13944}, {(float)0.002389, 170, 14121},
-	{ (float)0.081523,	105,	4164 },
+    {(float)0.001068, 164, 14291}, {(float)0.001653, 157, 14455},
-	{ (float)0.074861,	110,	4269 },
+    {(float)0.000717, 150, 14612}, {(float)0.001614, 143, 14762},
-	{ (float)0.074861,	110,	4379 },
+    {(float)0.000270, 136, 14905}, {(float)0.000484, 129, 15041},
-	{ (float)0.074861,	110,	4489 },
+    {(float)0.001103, 123, 15170}, {(float)0.001242, 115, 15293},
-	{ (float)0.074861,	110,	4599 },
+    {(float)0.001188, 109, 15408}, {(float)0.001011, 103, 15517},
-	{ (float)0.068290,	115,	4709 },
+    {(float)0.000709, 97, 15620},  {(float)0.000301, 89, 15717},
-	{ (float)0.068290,	115,	4824 },
+    {(float)0.002416, 82, 15806},  {(float)0.003251, 76, 15888},
-	{ (float)0.068290,	115,	4939 },
+    {(float)0.003246, 69, 15964},  {(float)0.004141, 62, 16033},
-	{ (float)0.068290,	115,	5054 },
+    {(float)0.005963, 55, 16095},  {(float)0.008839, 47, 16150},
-	{ (float)0.063573,	119,	5169 },
+    {(float)0.010490, 40, 16197},  {(float)0.016994, 31, 16237},
-	{ (float)0.063573,	119,	5288 },
+    {(float)0.023659, 21, 16268},
-	{ (float)0.063573,	119,	5407 },
-	{ (float)0.063573,	119,	5526 },
-	{ (float)0.057219,	124,	5645 },
-	{ (float)0.057219,	124,	5769 },
-	{ (float)0.057219,	124,	5893 },
-	{ (float)0.057219,	124,	6017 },
-	{ (float)0.050985,	129,	6141 },
-	{ (float)0.050985,	129,	6270 },
-	{ (float)0.050985,	129,	6399 },
-	{ (float)0.050985,	129,	6528 },
-	{ (float)0.050985,	129,	6657 },
-	{ (float)0.044859,	134,	6786 },
-	{ (float)0.044859,	134,	6920 },
-	{ (float)0.044859,	134,	7054 },
-	{ (float)0.044859,	134,	7188 },
-	{ (float)0.040571,	138,	7322 },
-	{ (float)0.040571,	138,	7460 },
-	{ (float)0.040571,	138,	7598 },
-	{ (float)0.040571,	138,	7736 },
-	{ (float)0.036339,	142,	7874 },
-	{ (float)0.036339,	142,	8016 },
-	{ (float)0.036339,	142,	8158 },
-	{ (float)0.036339,	142,	8300 },
-	{ (float)0.032139,	146,	8442 },
-	{ (float)0.032139,	146,	8588 },
-	{ (float)0.032139,	146,	8734 },
-	{ (float)0.032139,	146,	8880 },
-	{ (float)0.027947,	150,	9026 },
-	{ (float)0.027947,	150,	9176 },
-	{ (float)0.027947,	150,	9326 },
-	{ (float)0.023739,	154,	9476 },
-	{ (float)0.023739,	154,	9630 },
-	{ (float)0.023739,	154,	9784 },
-	{ (float)0.023739,	154,	9938 },
-	{ (float)0.019504,	158,	10092 },
-	{ (float)0.019504,	158,	10250 },
-	{ (float)0.019504,	158,	10408 },
-	{ (float)0.016976,	161,	10566 },
-	{ (float)0.016976,	161,	10727 },
-	{ (float)0.016976,	161,	10888 },
-	{ (float)0.016976,	161,	11049 },
-	{ (float)0.012639,	165,	11210 },
-	{ (float)0.012639,	165,	11375 },
-	{ (float)0.012639,	165,	11540 },
-	{ (float)0.009991,	168,	11705 },
-	{ (float)0.009991,	168,	11873 },
-	{ (float)0.009991,	168,	12041 },
-	{ (float)0.009016,	170,	12209 },
-	{ (float)0.009016,	170,	12379 },
-	{ (float)0.009016,	170,	12549 },
-	{ (float)0.006217,	173,	12719 },
-	{ (float)0.006217,	173,	12892 },
-	{ (float)0.005097,	175,	13065 },
-	{ (float)0.005097,	175,	13240 },
-	{ (float)0.005097,	175,	13415 },
-	{ (float)0.003909,	177,	13590 },
-	{ (float)0.003909,	177,	13767 },
-	{ (float)0.002340,	177,	13944 },
-	{ (float)0.002389,	170,	14121 },
-	{ (float)0.001068,	164,	14291 },
-	{ (float)0.001653,	157,	14455 },
-	{ (float)0.000717,	150,	14612 },
-	{ (float)0.001614,	143,	14762 },
-	{ (float)0.000270,	136,	14905 },
-	{ (float)0.000484,	129,	15041 },
-	{ (float)0.001103,	123,	15170 },
-	{ (float)0.001242,	115,	15293 },
-	{ (float)0.001188,	109,	15408 },
-	{ (float)0.001011,	103,	15517 },
-	{ (float)0.000709,	97,	15620 },
-	{ (float)0.000301,	89,	15717 },
-	{ (float)0.002416,	82,	15806 },
-	{ (float)0.003251,	76,	15888 },
-	{ (float)0.003246,	69,	15964 },
-	{ (float)0.004141,	62,	16033 },
-	{ (float)0.005963,	55,	16095 },
-	{ (float)0.008839,	47,	16150 },
-	{ (float)0.010490,	40,	16197 },
-	{ (float)0.016994,	31,	16237 },
-	{ (float)0.023659,	21,	16268 },
 };
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */

3rdparty/orbbecsdk/orbbecsdk.cmake

@@ -0,0 +1,18 @@
+function(download_orbbec_sdk root_var)
+    set(ORBBECSDK_DOWNLOAD_DIR "${OpenCV_BINARY_DIR}/3rdparty/orbbecsdk")
+    set(ORBBECSDK_FILE_HASH_CMAKE "e7566fa915a1b0c02640df41891916fe")
+    ocv_download(FILENAME "v1.9.4.tar.gz"
+                HASH ${ORBBECSDK_FILE_HASH_CMAKE}
+                URL "https://github.com/orbbec/OrbbecSDK/archive/refs/tags/v1.9.4/"
+                DESTINATION_DIR ${ORBBECSDK_DOWNLOAD_DIR}
+                ID OrbbecSDK
+                STATUS res
+                UNPACK RELATIVE_URL
+                )
+    if(${res})
+        message(STATUS "orbbec sdk downloaded to: ${ORBBECSDK_DOWNLOAD_DIR}")
+        set(${root_var} "${ORBBECSDK_DOWNLOAD_DIR}/OrbbecSDK-1.9.4" PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "Failed to download orbbec sdk")
+    endif()
+endfunction()

3rdparty/zlib/CMakeLists.txt

@@ -23,9 +23,6 @@ endif()
 #
 if(NOT MSVC)
   check_include_file(unistd.h Z_HAVE_UNISTD_H)
-  if(Z_HAVE_UNISTD_H)
-    add_definitions(-DZ_HAVE_UNISTD_H)
-  endif()
 endif()
 
 if(MSVC)
@@ -41,10 +38,13 @@ if(HAVE_OFF64_T)
   add_definitions(-D_LARGEFILE64_SOURCE=1)
 endif()
 
-ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+configure_file(	${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein
+                ${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
+
+ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
 
 set(ZLIB_PUBLIC_HDRS
-    zconf.h
+    ${CMAKE_CURRENT_BINARY_DIR}/zconf.h
     zlib.h
 )
 set(ZLIB_PRIVATE_HDRS

3rdparty/zlib/ChangeLog

@@ -1,6 +1,16 @@
 
                 ChangeLog file for zlib
 
+Changes in 1.3.1 (22 Jan 2024)
+- Reject overflows of zip header fields in minizip
+- Fix bug in inflateSync() for data held in bit buffer
+- Add LIT_MEM define to use more memory for a small deflate speedup
+- Fix decision on the emission of Zip64 end records in minizip
+- Add bounds checking to ERR_MSG() macro, used by zError()
+- Neutralize zip file traversal attacks in miniunz
+- Fix a bug in ZLIB_DEBUG compiles in check_match()
+- Various portability and appearance improvements
+
 Changes in 1.3 (18 Aug 2023)
 - Remove K&R function definitions and zlib2ansi
 - Fix bug in deflateBound() for level 0 and memLevel 9