| OLD | NEW |
|---|
| (Empty) |
| 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 #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_imag
ewidth, 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 TIFFDirectory *td = &tif->tif_dir; | |
| 147 uint64 rowsize; | |
| 148 | |
| 149 if (td->td_tilelength == 0 || td->td_tilewidth == 0) | |
| 150 return (0); | |
| 151 rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth, | |
| 152 "TIFFTileRowSize"); | |
| 153 if (td->td_planarconfig == PLANARCONFIG_CONTIG) | |
| 154 rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel, | |
| 155 "TIFFTileRowSize"); | |
| 156 return (TIFFhowmany8_64(rowsize)); | |
| 157 } | |
| 158 tmsize_t | |
| 159 TIFFTileRowSize(TIFF* tif) | |
| 160 { | |
| 161 static const char module[] = "TIFFTileRowSize"; | |
| 162 uint64 m; | |
| 163 tmsize_t n; | |
| 164 m=TIFFTileRowSize64(tif); | |
| 165 n=(tmsize_t)m; | |
| 166 if ((uint64)n!=m) | |
| 167 { | |
| 168 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); | |
| 169 n=0; | |
| 170 } | |
| 171 return(n); | |
| 172 } | |
| 173 | |
| 174 /* | |
| 175 * Compute the # bytes in a variable length, row-aligned tile. | |
| 176 */ | |
| 177 uint64 | |
| 178 TIFFVTileSize64(TIFF* tif, uint32 nrows) | |
| 179 { | |
| 180 static const char module[] = "TIFFVTileSize64"; | |
| 181 TIFFDirectory *td = &tif->tif_dir; | |
| 182 if (td->td_tilelength == 0 || td->td_tilewidth == 0 || | |
| 183 td->td_tiledepth == 0) | |
| 184 return (0); | |
| 185 if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&& | |
| 186 (td->td_photometric==PHOTOMETRIC_YCBCR)&& | |
| 187 (td->td_samplesperpixel==3)&& | |
| 188 (!isUpSampled(tif))) | |
| 189 { | |
| 190 /* | |
| 191 * Packed YCbCr data contain one Cb+Cr for every | |
| 192 * HorizontalSampling*VerticalSampling Y values. | |
| 193 * Must also roundup width and height when calculating | |
| 194 * since images that are not a multiple of the | |
| 195 * horizontal/vertical subsampling area include | |
| 196 * YCbCr data for the extended image. | |
| 197 */ | |
| 198 uint16 ycbcrsubsampling[2]; | |
| 199 uint16 samplingblock_samples; | |
| 200 uint32 samplingblocks_hor; | |
| 201 uint32 samplingblocks_ver; | |
| 202 uint64 samplingrow_samples; | |
| 203 uint64 samplingrow_size; | |
| 204 TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampl
ing+0, | |
| 205 ycbcrsubsampling+1); | |
| 206 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycb
crsubsampling[0] != 4) | |
| 207 ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && y
cbcrsubsampling[1] != 4)) | |
| 208 { | |
| 209 TIFFErrorExt(tif->tif_clientdata,module, | |
| 210 "Invalid YCbCr subsampling (%dx%d)", | |
| 211 ycbcrsubsampling[0], | |
| 212 ycbcrsubsampling[1] ); | |
| 213 return 0; | |
| 214 } | |
| 215 samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; | |
| 216 samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampl
ing[0]); | |
| 217 samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); | |
| 218 samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,sampl
ingblock_samples,module); | |
| 219 samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow
_samples,td->td_bitspersample,module)); | |
| 220 return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,m
odule)); | |
| 221 } | |
| 222 else | |
| 223 return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module))
; | |
| 224 } | |
| 225 tmsize_t | |
| 226 TIFFVTileSize(TIFF* tif, uint32 nrows) | |
| 227 { | |
| 228 static const char module[] = "TIFFVTileSize"; | |
| 229 uint64 m; | |
| 230 tmsize_t n; | |
| 231 m=TIFFVTileSize64(tif,nrows); | |
| 232 n=(tmsize_t)m; | |
| 233 if ((uint64)n!=m) | |
| 234 { | |
| 235 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); | |
| 236 n=0; | |
| 237 } | |
| 238 return(n); | |
| 239 } | |
| 240 | |
| 241 /* | |
| 242 * Compute the # bytes in a row-aligned tile. | |
| 243 */ | |
| 244 uint64 | |
| 245 TIFFTileSize64(TIFF* tif) | |
| 246 { | |
| 247 return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength)); | |
| 248 } | |
| 249 tmsize_t | |
| 250 TIFFTileSize(TIFF* tif) | |
| 251 { | |
| 252 static const char module[] = "TIFFTileSize"; | |
| 253 uint64 m; | |
| 254 tmsize_t n; | |
| 255 m=TIFFTileSize64(tif); | |
| 256 n=(tmsize_t)m; | |
| 257 if ((uint64)n!=m) | |
| 258 { | |
| 259 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); | |
| 260 n=0; | |
| 261 } | |
| 262 return(n); | |
| 263 } | |
| 264 | |
| 265 /* | |
| 266 * Compute a default tile size based on the image | |
| 267 * characteristics and a requested value. If a | |
| 268 * request is <1 then we choose a size according | |
| 269 * to certain heuristics. | |
| 270 */ | |
| 271 void | |
| 272 TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) | |
| 273 { | |
| 274 (*tif->tif_deftilesize)(tif, tw, th); | |
| 275 } | |
| 276 | |
| 277 void | |
| 278 _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) | |
| 279 { | |
| 280 (void) tif; | |
| 281 if (*(int32*) tw < 1) | |
| 282 *tw = 256; | |
| 283 if (*(int32*) th < 1) | |
| 284 *th = 256; | |
| 285 /* roundup to a multiple of 16 per the spec */ | |
| 286 if (*tw & 0xf) | |
| 287 *tw = TIFFroundup_32(*tw, 16); | |
| 288 if (*th & 0xf) | |
| 289 *th = TIFFroundup_32(*th, 16); | |
| 290 } | |
| 291 | |
| 292 /* vim: set ts=8 sts=8 sw=8 noet: */ | |
| 293 /* | |
| 294 * Local Variables: | |
| 295 * mode: c | |
| 296 * c-basic-offset: 8 | |
| 297 * fill-column: 78 | |
| 298 * End: | |
| 299 */ | |
| 300 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1563103002:
XFA: Upgrade to libtiff 4.0.6. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@xfa