thirdparty/libtiff/tif_tile.c

   1 /* $Id: tif_tile.c,v 1.24 2015-06-07 22:35:40 bfriesen Exp $ */
   2
   3 /*
   4  * Copyright (c) 1991-1997 Sam Leffler
   5  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
   6  *
   7  * Permission to use, copy, modify, distribute, and sell this software and
   8  * its documentation for any purpose is hereby granted without fee, provided
   9  * that (i) the above copyright notices and this permission notice appear in
  10  * all copies of the software and related documentation, and (ii) the names of
  11  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12  * publicity relating to the software without the specific, prior written
  13  * permission of Sam Leffler and Silicon Graphics.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  17  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  18  *
  19  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  23  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  24  * OF THIS SOFTWARE.
  25  */
  26
  27 /*
  28  * TIFF Library.
  29  *
  30  * Tiled Image Support Routines.
  31  */
  32 #include "tiffiop.h"
  33
  34 /*
  35  * Compute which tile an (x,y,z,s) value is in.
  36  */
  37 uint32
  38 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
  39 {
  40         TIFFDirectory *td = &tif->tif_dir;
  41         uint32 dx = td->td_tilewidth;
  42         uint32 dy = td->td_tilelength;
  43         uint32 dz = td->td_tiledepth;
  44         uint32 tile = 1;
  45
  46         if (td->td_imagedepth == 1)
  47                 z = 0;
  48         if (dx == (uint32) -1)
  49                 dx = td->td_imagewidth;
  50         if (dy == (uint32) -1)
  51                 dy = td->td_imagelength;
  52         if (dz == (uint32) -1)
  53                 dz = td->td_imagedepth;
  54         if (dx != 0 && dy != 0 && dz != 0) {
  55                 uint32 xpt = TIFFhowmany_32(td->td_imagewidth, dx);
  56                 uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy);
  57                 uint32 zpt = TIFFhowmany_32(td->td_imagedepth, dz);
  58
  59                 if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  60                         tile = (xpt*ypt*zpt)*s +
  61                              (xpt*ypt)*(z/dz) +
  62                              xpt*(y/dy) +
  63                              x/dx;
  64                 else
  65                         tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx;
  66         }
  67         return (tile);
  68 }
  69
  70 /*
  71  * Check an (x,y,z,s) coordinate
  72  * against the image bounds.
  73  */
  74 int
  75 TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
  76 {
  77         TIFFDirectory *td = &tif->tif_dir;
  78
  79         if (x >= td->td_imagewidth) {
  80                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  81                              "%lu: Col out of range, max %lu",
  82                              (unsigned long) x,
  83                              (unsigned long) (td->td_imagewidth - 1));
  84                 return (0);
  85         }
  86         if (y >= td->td_imagelength) {
  87                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  88                              "%lu: Row out of range, max %lu",
  89                              (unsigned long) y,
  90                              (unsigned long) (td->td_imagelength - 1));
  91                 return (0);
  92         }
  93         if (z >= td->td_imagedepth) {
  94                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  95                              "%lu: Depth out of range, max %lu",
  96                              (unsigned long) z,
  97                              (unsigned long) (td->td_imagedepth - 1));
  98                 return (0);
  99         }
 100         if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
 101             s >= td->td_samplesperpixel) {
 102                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 103                              "%lu: Sample out of range, max %lu",
 104                              (unsigned long) s,
 105                              (unsigned long) (td->td_samplesperpixel - 1));
 106                 return (0);
 107         }
 108         return (1);
 109 }
 110
 111 /*
 112  * Compute how many tiles are in an image.
 113  */
 114 uint32
 115 TIFFNumberOfTiles(TIFF* tif)
 116 {
 117         TIFFDirectory *td = &tif->tif_dir;
 118         uint32 dx = td->td_tilewidth;
 119         uint32 dy = td->td_tilelength;
 120         uint32 dz = td->td_tiledepth;
 121         uint32 ntiles;
 122
 123         if (dx == (uint32) -1)
 124                 dx = td->td_imagewidth;
 125         if (dy == (uint32) -1)
 126                 dy = td->td_imagelength;
 127         if (dz == (uint32) -1)
 128                 dz = td->td_imagedepth;
 129         ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
 130             _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
 131             TIFFhowmany_32(td->td_imagelength, dy),
 132             "TIFFNumberOfTiles"),
 133             TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
 134         if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
 135                 ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
 136                     "TIFFNumberOfTiles");
 137         return (ntiles);
 138 }
 139
 140 /*
 141  * Compute the # bytes in each row of a tile.
 142  */
 143 uint64
 144 TIFFTileRowSize64(TIFF* tif)
 145 {
 146         static const char module[] = "TIFFTileRowSize64";
 147         TIFFDirectory *td = &tif->tif_dir;
 148         uint64 rowsize;
 149         uint64 tilerowsize;
 150
 151         if (td->td_tilelength == 0)
 152         {
 153                 TIFFErrorExt(tif->tif_clientdata,module,"Tile length is zero");
 154                 return 0;
 155         }
 156         if (td->td_tilewidth == 0)
 157         {
 158                 TIFFErrorExt(tif->tif_clientdata,module,"Tile width is zero");
 159                 return (0);
 160         }
 161         rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
 162             "TIFFTileRowSize");
 163         if (td->td_planarconfig == PLANARCONFIG_CONTIG)
 164         {
 165                 if (td->td_samplesperpixel == 0)
 166                 {
 167                         TIFFErrorExt(tif->tif_clientdata,module,"Samples per pixel is zero");
 168                         return 0;
 169                 }
 170                 rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
 171                     "TIFFTileRowSize");
 172         }
 173         tilerowsize=TIFFhowmany8_64(rowsize);
 174         if (tilerowsize == 0)
 175         {
 176                 TIFFErrorExt(tif->tif_clientdata,module,"Computed tile row size is zero");
 177                 return 0;
 178         }
 179         return (tilerowsize);
 180 }
 181 tmsize_t
 182 TIFFTileRowSize(TIFF* tif)
 183 {
 184         static const char module[] = "TIFFTileRowSize";
 185         uint64 m;
 186         tmsize_t n;
 187         m=TIFFTileRowSize64(tif);
 188         n=(tmsize_t)m;
 189         if ((uint64)n!=m)
 190         {
 191                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 192                 n=0;
 193         }
 194         return(n);
 195 }
 196
 197 /*
 198  * Compute the # bytes in a variable length, row-aligned tile.
 199  */
 200 uint64
 201 TIFFVTileSize64(TIFF* tif, uint32 nrows)
 202 {
 203         static const char module[] = "TIFFVTileSize64";
 204         TIFFDirectory *td = &tif->tif_dir;
 205         if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
 206             td->td_tiledepth == 0)
 207                 return (0);
 208         if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
 209             (td->td_photometric==PHOTOMETRIC_YCBCR)&&
 210             (td->td_samplesperpixel==3)&&
 211             (!isUpSampled(tif)))
 212         {
 213                 /*
 214                  * Packed YCbCr data contain one Cb+Cr for every
 215                  * HorizontalSampling*VerticalSampling Y values.
 216                  * Must also roundup width and height when calculating
 217                  * since images that are not a multiple of the
 218                  * horizontal/vertical subsampling area include
 219                  * YCbCr data for the extended image.
 220                  */
 221                 uint16 ycbcrsubsampling[2];
 222                 uint16 samplingblock_samples;
 223                 uint32 samplingblocks_hor;
 224                 uint32 samplingblocks_ver;
 225                 uint64 samplingrow_samples;
 226                 uint64 samplingrow_size;
 227                 TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
 228                     ycbcrsubsampling+1);
 229                 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
 230                     ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
 231                 {
 232                         TIFFErrorExt(tif->tif_clientdata,module,
 233                                      "Invalid YCbCr subsampling (%dx%d)",
 234                                      ycbcrsubsampling[0],
 235                                      ycbcrsubsampling[1] );
 236                         return 0;
 237                 }
 238                 samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
 239                 samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
 240                 samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
 241                 samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
 242                 samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
 243                 return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
 244         }
 245         else
 246                 return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
 247 }
 248 tmsize_t
 249 TIFFVTileSize(TIFF* tif, uint32 nrows)
 250 {
 251         static const char module[] = "TIFFVTileSize";
 252         uint64 m;
 253         tmsize_t n;
 254         m=TIFFVTileSize64(tif,nrows);
 255         n=(tmsize_t)m;
 256         if ((uint64)n!=m)
 257         {
 258                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 259                 n=0;
 260         }
 261         return(n);
 262 }
 263
 264 /*
 265  * Compute the # bytes in a row-aligned tile.
 266  */
 267 uint64
 268 TIFFTileSize64(TIFF* tif)
 269 {
 270         return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
 271 }
 272 tmsize_t
 273 TIFFTileSize(TIFF* tif)
 274 {
 275         static const char module[] = "TIFFTileSize";
 276         uint64 m;
 277         tmsize_t n;
 278         m=TIFFTileSize64(tif);
 279         n=(tmsize_t)m;
 280         if ((uint64)n!=m)
 281         {
 282                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 283                 n=0;
 284         }
 285         return(n);
 286 }
 287
 288 /*
 289  * Compute a default tile size based on the image
 290  * characteristics and a requested value.  If a
 291  * request is <1 then we choose a size according
 292  * to certain heuristics.
 293  */
 294 void
 295 TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
 296 {
 297         (*tif->tif_deftilesize)(tif, tw, th);
 298 }
 299
 300 void
 301 _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
 302 {
 303         (void) tif;
 304         if (*(int32*) tw < 1)
 305                 *tw = 256;
 306         if (*(int32*) th < 1)
 307                 *th = 256;
 308         /* roundup to a multiple of 16 per the spec */
 309         if (*tw & 0xf)
 310                 *tw = TIFFroundup_32(*tw, 16);
 311         if (*th & 0xf)
 312                 *th = TIFFroundup_32(*th, 16);
 313 }
 314
 315 /* vim: set ts=8 sts=8 sw=8 noet: */
 316 /*
 317  * Local Variables:
 318  * mode: c
 319  * c-basic-offset: 8
 320  * fill-column: 78
 321  * End:
 322  */