reactos/dll/3rdparty/libtiff/tif_tile.c

   1 /* $Id: tif_tile.c,v 1.23 2012-06-06 05:33:55 fwarmerdam 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
  33 #include <precomp.h>
  34
  35 /*
  36  * Compute which tile an (x,y,z,s) value is in.
  37  */
  38 uint32
  39 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
  40 {
  41         TIFFDirectory *td = &tif->tif_dir;
  42         uint32 dx = td->td_tilewidth;
  43         uint32 dy = td->td_tilelength;
  44         uint32 dz = td->td_tiledepth;
  45         uint32 tile = 1;
  46
  47         if (td->td_imagedepth == 1)
  48                 z = 0;
  49         if (dx == (uint32) -1)
  50                 dx = td->td_imagewidth;
  51         if (dy == (uint32) -1)
  52                 dy = td->td_imagelength;
  53         if (dz == (uint32) -1)
  54                 dz = td->td_imagedepth;
  55         if (dx != 0 && dy != 0 && dz != 0) {
  56                 uint32 xpt = TIFFhowmany_32(td->td_imagewidth, dx);
  57                 uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy);
  58                 uint32 zpt = TIFFhowmany_32(td->td_imagedepth, dz);
  59
  60                 if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  61                         tile = (xpt*ypt*zpt)*s +
  62                              (xpt*ypt)*(z/dz) +
  63                              xpt*(y/dy) +
  64                              x/dx;
  65                 else
  66                         tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx;
  67         }
  68         return (tile);
  69 }
  70
  71 /*
  72  * Check an (x,y,z,s) coordinate
  73  * against the image bounds.
  74  */
  75 int
  76 TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
  77 {
  78         TIFFDirectory *td = &tif->tif_dir;
  79
  80         if (x >= td->td_imagewidth) {
  81                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  82                              "%lu: Col out of range, max %lu",
  83                              (unsigned long) x,
  84                              (unsigned long) (td->td_imagewidth - 1));
  85                 return (0);
  86         }
  87         if (y >= td->td_imagelength) {
  88                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  89                              "%lu: Row out of range, max %lu",
  90                              (unsigned long) y,
  91                              (unsigned long) (td->td_imagelength - 1));
  92                 return (0);
  93         }
  94         if (z >= td->td_imagedepth) {
  95                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  96                              "%lu: Depth out of range, max %lu",
  97                              (unsigned long) z,
  98                              (unsigned long) (td->td_imagedepth - 1));
  99                 return (0);
 100         }
 101         if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
 102             s >= td->td_samplesperpixel) {
 103                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 104                              "%lu: Sample out of range, max %lu",
 105                              (unsigned long) s,
 106                              (unsigned long) (td->td_samplesperpixel - 1));
 107                 return (0);
 108         }
 109         return (1);
 110 }
 111
 112 /*
 113  * Compute how many tiles are in an image.
 114  */
 115 uint32
 116 TIFFNumberOfTiles(TIFF* tif)
 117 {
 118         TIFFDirectory *td = &tif->tif_dir;
 119         uint32 dx = td->td_tilewidth;
 120         uint32 dy = td->td_tilelength;
 121         uint32 dz = td->td_tiledepth;
 122         uint32 ntiles;
 123
 124         if (dx == (uint32) -1)
 125                 dx = td->td_imagewidth;
 126         if (dy == (uint32) -1)
 127                 dy = td->td_imagelength;
 128         if (dz == (uint32) -1)
 129                 dz = td->td_imagedepth;
 130         ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
 131             _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
 132             TIFFhowmany_32(td->td_imagelength, dy),
 133             "TIFFNumberOfTiles"),
 134             TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
 135         if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
 136                 ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
 137                     "TIFFNumberOfTiles");
 138         return (ntiles);
 139 }
 140
 141 /*
 142  * Compute the # bytes in each row of a tile.
 143  */
 144 uint64
 145 TIFFTileRowSize64(TIFF* tif)
 146 {
 147         TIFFDirectory *td = &tif->tif_dir;
 148         uint64 rowsize;
 149
 150         if (td->td_tilelength == 0 || td->td_tilewidth == 0)
 151                 return (0);
 152         rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
 153             "TIFFTileRowSize");
 154         if (td->td_planarconfig == PLANARCONFIG_CONTIG)
 155                 rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
 156                     "TIFFTileRowSize");
 157         return (TIFFhowmany8_64(rowsize));
 158 }
 159 tmsize_t
 160 TIFFTileRowSize(TIFF* tif)
 161 {
 162         static const char module[] = "TIFFTileRowSize";
 163         uint64 m;
 164         tmsize_t n;
 165         m=TIFFTileRowSize64(tif);
 166         n=(tmsize_t)m;
 167         if ((uint64)n!=m)
 168         {
 169                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 170                 n=0;
 171         }
 172         return(n);
 173 }
 174
 175 /*
 176  * Compute the # bytes in a variable length, row-aligned tile.
 177  */
 178 uint64
 179 TIFFVTileSize64(TIFF* tif, uint32 nrows)
 180 {
 181         static const char module[] = "TIFFVTileSize64";
 182         TIFFDirectory *td = &tif->tif_dir;
 183         if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
 184             td->td_tiledepth == 0)
 185                 return (0);
 186         if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
 187             (td->td_photometric==PHOTOMETRIC_YCBCR)&&
 188             (td->td_samplesperpixel==3)&&
 189             (!isUpSampled(tif)))
 190         {
 191                 /*
 192                  * Packed YCbCr data contain one Cb+Cr for every
 193                  * HorizontalSampling*VerticalSampling Y values.
 194                  * Must also roundup width and height when calculating
 195                  * since images that are not a multiple of the
 196                  * horizontal/vertical subsampling area include
 197                  * YCbCr data for the extended image.
 198                  */
 199                 uint16 ycbcrsubsampling[2];
 200                 uint16 samplingblock_samples;
 201                 uint32 samplingblocks_hor;
 202                 uint32 samplingblocks_ver;
 203                 uint64 samplingrow_samples;
 204                 uint64 samplingrow_size;
 205                 TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
 206                     ycbcrsubsampling+1);
 207                 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
 208                     ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
 209                 {
 210                         TIFFErrorExt(tif->tif_clientdata,module,
 211                                      "Invalid YCbCr subsampling (%dx%d)",
 212                                      ycbcrsubsampling[0],
 213                                      ycbcrsubsampling[1] );
 214                         return 0;
 215                 }
 216                 samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
 217                 samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
 218                 samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
 219                 samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
 220                 samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
 221                 return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
 222         }
 223         else
 224                 return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
 225 }
 226 tmsize_t
 227 TIFFVTileSize(TIFF* tif, uint32 nrows)
 228 {
 229         static const char module[] = "TIFFVTileSize";
 230         uint64 m;
 231         tmsize_t n;
 232         m=TIFFVTileSize64(tif,nrows);
 233         n=(tmsize_t)m;
 234         if ((uint64)n!=m)
 235         {
 236                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 237                 n=0;
 238         }
 239         return(n);
 240 }
 241
 242 /*
 243  * Compute the # bytes in a row-aligned tile.
 244  */
 245 uint64
 246 TIFFTileSize64(TIFF* tif)
 247 {
 248         return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
 249 }
 250 tmsize_t
 251 TIFFTileSize(TIFF* tif)
 252 {
 253         static const char module[] = "TIFFTileSize";
 254         uint64 m;
 255         tmsize_t n;
 256         m=TIFFTileSize64(tif);
 257         n=(tmsize_t)m;
 258         if ((uint64)n!=m)
 259         {
 260                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 261                 n=0;
 262         }
 263         return(n);
 264 }
 265
 266 /*
 267  * Compute a default tile size based on the image
 268  * characteristics and a requested value.  If a
 269  * request is <1 then we choose a size according
 270  * to certain heuristics.
 271  */
 272 void
 273 TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
 274 {
 275         (*tif->tif_deftilesize)(tif, tw, th);
 276 }
 277
 278 void
 279 _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
 280 {
 281         (void) tif;
 282         if (*(int32*) tw < 1)
 283                 *tw = 256;
 284         if (*(int32*) th < 1)
 285                 *th = 256;
 286         /* roundup to a multiple of 16 per the spec */
 287         if (*tw & 0xf)
 288                 *tw = TIFFroundup_32(*tw, 16);
 289         if (*th & 0xf)
 290                 *th = TIFFroundup_32(*th, 16);
 291 }
 292
 293 /* vim: set ts=8 sts=8 sw=8 noet: */
 294 /*
 295  * Local Variables:
 296  * mode: c
 297  * c-basic-offset: 8
 298  * fill-column: 78
 299  * End:
 300  */