Merge XFA to PDFium master at 4dc95e7 on 10/28/2014
[pdfium.git] / core / src / fxcodec / fx_tiff / tiff_v403 / 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 #if (!defined(_FPDFAPI_MINI_) || defined(_TIFF_DECODER_)) && !defined(_USE_ADDIN_) && !defined _FX_NO_ANSIC_ && !defined(_FX_EMB_NOUSE_DECODER_)
33 #include "tiffiop.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  */
301 #endif
302