1 files changed, 200 insertions, 215 deletions

diff --git a/src/3rdparty/libtiff/libtiff/tif_tile.c b/src/3rdparty/libtiff/libtiff/tif_tile.c
index 058be9f..f07032f 100644
--- a/src/3rdparty/libtiff/libtiff/tif_tile.c
+++ b/src/3rdparty/libtiff/libtiff/tif_tile.c
@@ -2,23 +2,23 @@
  * Copyright (c) 1991-1997 Sam Leffler
  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  *
- * 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
  * 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.  
- * 
+ *
+ * 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 
+ * 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.
  */
 
@@ -32,234 +32,230 @@
 /*
  * Compute which tile an (x,y,z,s) value is in.
  */
-uint32_t
-TIFFComputeTile(TIFF* tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
+uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
+                         uint16_t s)
 {
-	TIFFDirectory *td = &tif->tif_dir;
-	uint32_t dx = td->td_tilewidth;
-	uint32_t dy = td->td_tilelength;
-	uint32_t dz = td->td_tiledepth;
-	uint32_t tile = 1;
+    TIFFDirectory *td = &tif->tif_dir;
+    uint32_t dx = td->td_tilewidth;
+    uint32_t dy = td->td_tilelength;
+    uint32_t dz = td->td_tiledepth;
+    uint32_t tile = 1;
 
-	if (td->td_imagedepth == 1)
-		z = 0;
-	if (dx == (uint32_t) -1)
-		dx = td->td_imagewidth;
-	if (dy == (uint32_t) -1)
-		dy = td->td_imagelength;
-	if (dz == (uint32_t) -1)
-		dz = td->td_imagedepth;
-	if (dx != 0 && dy != 0 && dz != 0) {
-		uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
-		uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
-		uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
+    if (td->td_imagedepth == 1)
+        z = 0;
+    if (dx == (uint32_t)-1)
+        dx = td->td_imagewidth;
+    if (dy == (uint32_t)-1)
+        dy = td->td_imagelength;
+    if (dz == (uint32_t)-1)
+        dz = td->td_imagedepth;
+    if (dx != 0 && dy != 0 && dz != 0)
+    {
+        uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
+        uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
+        uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
 
-		if (td->td_planarconfig == PLANARCONFIG_SEPARATE) 
-			tile = (xpt*ypt*zpt)*s +
-			     (xpt*ypt)*(z/dz) +
-			     xpt*(y/dy) +
-			     x/dx;
-		else
-			tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx;
-	}
-	return (tile);
+        if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
+            tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
+                   xpt * (y / dy) + x / dx;
+        else
+            tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
+    }
+    return (tile);
 }
 
 /*
  * Check an (x,y,z,s) coordinate
  * against the image bounds.
  */
-int
-TIFFCheckTile(TIFF* tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
+int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
 {
-	TIFFDirectory *td = &tif->tif_dir;
+    TIFFDirectory *td = &tif->tif_dir;
 
-	if (x >= td->td_imagewidth) {
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
-			     "%lu: Col out of range, max %lu",
-			     (unsigned long) x,
-			     (unsigned long) (td->td_imagewidth - 1));
-		return (0);
-	}
-	if (y >= td->td_imagelength) {
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
-			     "%lu: Row out of range, max %lu",
-			     (unsigned long) y,
-			     (unsigned long) (td->td_imagelength - 1));
-		return (0);
-	}
-	if (z >= td->td_imagedepth) {
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
-			     "%lu: Depth out of range, max %lu",
-			     (unsigned long) z,
-			     (unsigned long) (td->td_imagedepth - 1));
-		return (0);
-	}
-	if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
-	    s >= td->td_samplesperpixel) {
-		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
-			     "%lu: Sample out of range, max %lu",
-			     (unsigned long) s,
-			     (unsigned long) (td->td_samplesperpixel - 1));
-		return (0);
-	}
-	return (1);
+    if (x >= td->td_imagewidth)
+    {
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu",
+                      (unsigned long)x, (unsigned long)(td->td_imagewidth - 1));
+        return (0);
+    }
+    if (y >= td->td_imagelength)
+    {
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu",
+                      (unsigned long)y,
+                      (unsigned long)(td->td_imagelength - 1));
+        return (0);
+    }
+    if (z >= td->td_imagedepth)
+    {
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
+                      (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
+        return (0);
+    }
+    if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
+        s >= td->td_samplesperpixel)
+    {
+        TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
+                      (unsigned long)s,
+                      (unsigned long)(td->td_samplesperpixel - 1));
+        return (0);
+    }
+    return (1);
 }
 
 /*
  * Compute how many tiles are in an image.
  */
-uint32_t
-TIFFNumberOfTiles(TIFF* tif)
+uint32_t TIFFNumberOfTiles(TIFF *tif)
 {
-	TIFFDirectory *td = &tif->tif_dir;
-	uint32_t dx = td->td_tilewidth;
-	uint32_t dy = td->td_tilelength;
-	uint32_t dz = td->td_tiledepth;
-	uint32_t ntiles;
+    TIFFDirectory *td = &tif->tif_dir;
+    uint32_t dx = td->td_tilewidth;
+    uint32_t dy = td->td_tilelength;
+    uint32_t dz = td->td_tiledepth;
+    uint32_t ntiles;
 
-	if (dx == (uint32_t) -1)
-		dx = td->td_imagewidth;
-	if (dy == (uint32_t) -1)
-		dy = td->td_imagelength;
-	if (dz == (uint32_t) -1)
-		dz = td->td_imagedepth;
-	ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
-	    _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
-	    TIFFhowmany_32(td->td_imagelength, dy),
-	    "TIFFNumberOfTiles"),
-	    TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
-	if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
-		ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
-		    "TIFFNumberOfTiles");
-	return (ntiles);
+    if (dx == (uint32_t)-1)
+        dx = td->td_imagewidth;
+    if (dy == (uint32_t)-1)
+        dy = td->td_imagelength;
+    if (dz == (uint32_t)-1)
+        dz = td->td_imagedepth;
+    ntiles =
+        (dx == 0 || dy == 0 || dz == 0)
+            ? 0
+            : _TIFFMultiply32(
+                  tif,
+                  _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
+                                  TIFFhowmany_32(td->td_imagelength, dy),
+                                  "TIFFNumberOfTiles"),
+                  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_t
-TIFFTileRowSize64(TIFF* tif)
+uint64_t TIFFTileRowSize64(TIFF *tif)
 {
-        static const char module[] = "TIFFTileRowSize64";
-	TIFFDirectory *td = &tif->tif_dir;
-	uint64_t rowsize;
-	uint64_t tilerowsize;
+    static const char module[] = "TIFFTileRowSize64";
+    TIFFDirectory *td = &tif->tif_dir;
+    uint64_t rowsize;
+    uint64_t tilerowsize;
 
-	if (td->td_tilelength == 0)
-        {
-                TIFFErrorExt(tif->tif_clientdata,module,"Tile length is zero");
-                return 0;
-        }
-        if (td->td_tilewidth == 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 width is zero");
-		return (0);
+            TIFFErrorExtR(tif, module, "Samples per pixel 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,"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);
+        rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
+                                  "TIFFTileRowSize");
+    }
+    tilerowsize = TIFFhowmany8_64(rowsize);
+    if (tilerowsize == 0)
+    {
+        TIFFErrorExtR(tif, module, "Computed tile row size is zero");
+        return 0;
+    }
+    return (tilerowsize);
 }
-tmsize_t
-TIFFTileRowSize(TIFF* tif)
+tmsize_t TIFFTileRowSize(TIFF *tif)
 {
-	static const char module[] = "TIFFTileRowSize";
-	uint64_t m;
-	m=TIFFTileRowSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    static const char module[] = "TIFFTileRowSize";
+    uint64_t m;
+    m = TIFFTileRowSize64(tif);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
  * Compute the # bytes in a variable length, row-aligned tile.
  */
-uint64_t
-TIFFVTileSize64(TIFF* tif, uint32_t nrows)
+uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
 {
-	static const char module[] = "TIFFVTileSize64";
-	TIFFDirectory *td = &tif->tif_dir;
-	if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
-	    td->td_tiledepth == 0)
-		return (0);
-	if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
-	    (td->td_photometric==PHOTOMETRIC_YCBCR)&&
-	    (td->td_samplesperpixel==3)&&
-	    (!isUpSampled(tif)))
-	{
-		/*
-		 * Packed YCbCr data contain one Cb+Cr for every
-		 * HorizontalSampling*VerticalSampling Y values.
-		 * Must also roundup width and height when calculating
-		 * since images that are not a multiple of the
-		 * horizontal/vertical subsampling area include
-		 * YCbCr data for the extended image.
-		 */
-		uint16_t ycbcrsubsampling[2];
-		uint16_t samplingblock_samples;
-		uint32_t samplingblocks_hor;
-		uint32_t samplingblocks_ver;
-		uint64_t samplingrow_samples;
-		uint64_t samplingrow_size;
-		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 (%dx%d)", 
-				     ycbcrsubsampling[0], 
-				     ycbcrsubsampling[1] );
-			return 0;
-		}
-		samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
-		samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
-		samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
-		samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
-		samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
-		return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
-	}
-	else
-		return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
+    static const char module[] = "TIFFVTileSize64";
+    TIFFDirectory *td = &tif->tif_dir;
+    if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
+        td->td_tiledepth == 0)
+        return (0);
+    if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
+        (td->td_photometric == PHOTOMETRIC_YCBCR) &&
+        (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
+    {
+        /*
+         * Packed YCbCr data contain one Cb+Cr for every
+         * HorizontalSampling*VerticalSampling Y values.
+         * Must also roundup width and height when calculating
+         * since images that are not a multiple of the
+         * horizontal/vertical subsampling area include
+         * YCbCr data for the extended image.
+         */
+        uint16_t ycbcrsubsampling[2];
+        uint16_t samplingblock_samples;
+        uint32_t samplingblocks_hor;
+        uint32_t samplingblocks_ver;
+        uint64_t samplingrow_samples;
+        uint64_t samplingrow_size;
+        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 (%dx%d)",
+                          ycbcrsubsampling[0], ycbcrsubsampling[1]);
+            return 0;
+        }
+        samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
+        samplingblocks_hor =
+            TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
+        samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
+        samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
+                                              samplingblock_samples, module);
+        samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
+            tif, samplingrow_samples, td->td_bitspersample, module));
+        return (
+            _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
+    }
+    else
+        return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
 }
-tmsize_t
-TIFFVTileSize(TIFF* tif, uint32_t nrows)
+tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows)
 {
-	static const char module[] = "TIFFVTileSize";
-	uint64_t m;
-	m=TIFFVTileSize64(tif,nrows);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    static const char module[] = "TIFFVTileSize";
+    uint64_t m;
+    m = TIFFVTileSize64(tif, nrows);
+    return _TIFFCastUInt64ToSSize(tif, m, module);
 }
 
 /*
  * Compute the # bytes in a row-aligned tile.
  */
-uint64_t
-TIFFTileSize64(TIFF* tif)
+uint64_t TIFFTileSize64(TIFF *tif)
 {
-	return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
+    return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
 }
-tmsize_t
-TIFFTileSize(TIFF* tif)
+tmsize_t TIFFTileSize(TIFF *tif)
 {
-	static const char module[] = "TIFFTileSize";
-	uint64_t m;
-	m=TIFFTileSize64(tif);
-	return _TIFFCastUInt64ToSSize(tif, m, module);
+    static const char module[] = "TIFFTileSize";
+    uint64_t m;
+    m = TIFFTileSize64(tif);
+    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
-TIFFDefaultTileSize(TIFF* tif, uint32_t* tw, uint32_t* th)
+void TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
 {
-	(*tif->tif_deftilesize)(tif, tw, th);
+    (*tif->tif_deftilesize)(tif, tw, th);
 }
 
-void
-_TIFFDefaultTileSize(TIFF* tif, uint32_t* tw, uint32_t* th)
+void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
 {
-	(void) tif;
-	if (*(int32_t*) tw < 1)
-		*tw = 256;
-	if (*(int32_t*) th < 1)
-		*th = 256;
-	/* roundup to a multiple of 16 per the spec */
-	if (*tw & 0xf)
-		*tw = TIFFroundup_32(*tw, 16);
-	if (*th & 0xf)
-		*th = TIFFroundup_32(*th, 16);
+    (void)tif;
+    if (*(int32_t *)tw < 1)
+        *tw = 256;
+    if (*(int32_t *)th < 1)
+        *th = 256;
+    /* roundup to a multiple of 16 per the spec */
+    if (*tw & 0xf)
+        *tw = TIFFroundup_32(*tw, 16);
+    if (*th & 0xf)
+        *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:
- */