"Fossies" - the Fresh Open Source Software Archive

Member "PDFlib-Lite-7.0.5p3/libs/tiff/tif_tile.c" (6 Jun 2012, 7572 Bytes) of package /linux/misc/old/PDFlib-Lite-7.0.5p3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "tif_tile.c" see the Fossies "Dox" file reference documentation.

    1 /* PDFlib GmbH cvsid: $Id: tif_tile.c,v 1.12 2005/12/21 14:12:52 rjs 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 static uint32
   35 summarize(TIFF* tif, size_t summand1, size_t summand2, const char* where)
   36 {
   37     /*
   38      * XXX: We are using casting to uint32 here, because sizeof(size_t)
   39      * may be larger than sizeof(uint32) on 64-bit architectures.
   40      */
   41     uint32  bytes = summand1 + summand2;
   42 
   43     if (bytes - summand1 != summand2) {
   44         _TIFFError(tif, tif->tif_name, "Integer overflow in %s", where);
   45         bytes = 0;
   46     }
   47 
   48     return (bytes);
   49 }
   50 
   51 static uint32
   52 multiply(TIFF* tif, size_t nmemb, size_t elem_size, const char* where)
   53 {
   54     uint32  bytes = nmemb * elem_size;
   55 
   56     if (elem_size && bytes / elem_size != nmemb) {
   57         _TIFFError(tif, tif->tif_name, "Integer overflow in %s", where);
   58         bytes = 0;
   59     }
   60 
   61     return (bytes);
   62 }
   63 
   64 /*
   65  * Compute which tile an (x,y,z,s) value is in.
   66  */
   67 ttile_t
   68 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
   69 {
   70     TIFFDirectory *td = &tif->tif_dir;
   71     uint32 dx = td->td_tilewidth;
   72     uint32 dy = td->td_tilelength;
   73     uint32 dz = td->td_tiledepth;
   74     ttile_t tile = 1;
   75 
   76     if (td->td_imagedepth == 1)
   77         z = 0;
   78     if (dx == (uint32) -1)
   79         dx = td->td_imagewidth;
   80     if (dy == (uint32) -1)
   81         dy = td->td_imagelength;
   82     if (dz == (uint32) -1)
   83         dz = td->td_imagedepth;
   84     if (dx != 0 && dy != 0 && dz != 0) {
   85         uint32 xpt = TIFFhowmany(td->td_imagewidth, dx);
   86         uint32 ypt = TIFFhowmany(td->td_imagelength, dy);
   87         uint32 zpt = TIFFhowmany(td->td_imagedepth, dz);
   88 
   89         if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
   90             tile = (xpt*ypt*zpt)*s +
   91                  (xpt*ypt)*(z/dz) +
   92                  xpt*(y/dy) +
   93                  x/dx;
   94         else
   95             tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx;
   96     }
   97     return (tile);
   98 }
   99 
  100 /*
  101  * Check an (x,y,z,s) coordinate
  102  * against the image bounds.
  103  */
  104 int
  105 TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
  106 {
  107     TIFFDirectory *td = &tif->tif_dir;
  108 
  109     if (x >= td->td_imagewidth) {
  110         _TIFFError(tif, tif->tif_name, "%lu: Col out of range, max %lu",
  111             (unsigned long) x, (unsigned long) td->td_imagewidth);
  112         return (0);
  113     }
  114     if (y >= td->td_imagelength) {
  115         _TIFFError(tif, tif->tif_name, "%lu: Row out of range, max %lu",
  116             (unsigned long) y, (unsigned long) td->td_imagelength);
  117         return (0);
  118     }
  119     if (z >= td->td_imagedepth) {
  120         _TIFFError(tif,tif->tif_name,"%lu: Depth out of range, max %lu",
  121             (unsigned long) z, (unsigned long) td->td_imagedepth);
  122         return (0);
  123     }
  124     if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
  125         s >= td->td_samplesperpixel) {
  126         _TIFFError(tif, tif->tif_name,
  127             "%lu: Sample out of range, max %lu",
  128             (unsigned long) s, (unsigned long) td->td_samplesperpixel);
  129         return (0);
  130     }
  131     return (1);
  132 }
  133 
  134 /*
  135  * Compute how many tiles are in an image.
  136  */
  137 ttile_t
  138 TIFFNumberOfTiles(TIFF* tif)
  139 {
  140     TIFFDirectory *td = &tif->tif_dir;
  141     uint32 dx = td->td_tilewidth;
  142     uint32 dy = td->td_tilelength;
  143     uint32 dz = td->td_tiledepth;
  144     ttile_t ntiles;
  145 
  146     if (dx == (uint32) -1)
  147         dx = td->td_imagewidth;
  148     if (dy == (uint32) -1)
  149         dy = td->td_imagelength;
  150     if (dz == (uint32) -1)
  151         dz = td->td_imagedepth;
  152     ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
  153         multiply(tif, multiply(tif, TIFFhowmany(td->td_imagewidth, dx),
  154                    TIFFhowmany(td->td_imagelength, dy),
  155                    "TIFFNumberOfTiles"),
  156              TIFFhowmany(td->td_imagedepth, dz), "TIFFNumberOfTiles");
  157     if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  158         ntiles = multiply(tif, ntiles, td->td_samplesperpixel,
  159                   "TIFFNumberOfTiles");
  160     return (ntiles);
  161 }
  162 
  163 /*
  164  * Compute the # bytes in each row of a tile.
  165  */
  166 tsize_t
  167 TIFFTileRowSize(TIFF* tif)
  168 {
  169     TIFFDirectory *td = &tif->tif_dir;
  170     tsize_t rowsize;
  171 
  172     if (td->td_tilelength == 0 || td->td_tilewidth == 0)
  173         return ((tsize_t) 0);
  174     rowsize = multiply(tif, td->td_bitspersample, td->td_tilewidth,
  175                "TIFFTileRowSize");
  176     if (td->td_planarconfig == PLANARCONFIG_CONTIG)
  177         rowsize = multiply(tif, rowsize, td->td_samplesperpixel,
  178                    "TIFFTileRowSize");
  179     return ((tsize_t) TIFFhowmany8(rowsize));
  180 }
  181 
  182 /*
  183  * Compute the # bytes in a variable length, row-aligned tile.
  184  */
  185 tsize_t
  186 TIFFVTileSize(TIFF* tif, uint32 nrows)
  187 {
  188     TIFFDirectory *td = &tif->tif_dir;
  189     tsize_t tilesize;
  190 
  191     if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
  192         td->td_tiledepth == 0)
  193         return ((tsize_t) 0);
  194     if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
  195         td->td_photometric == PHOTOMETRIC_YCBCR &&
  196         !isUpSampled(tif)) {
  197         /*
  198          * Packed YCbCr data contain one Cb+Cr for every
  199          * HorizontalSampling*VerticalSampling Y values.
  200          * Must also roundup width and height when calculating
  201          * since images that are not a multiple of the
  202          * horizontal/vertical subsampling area include
  203          * YCbCr data for the extended image.
  204          */
  205         tsize_t w =
  206             TIFFroundup(td->td_tilewidth, td->td_ycbcrsubsampling[0]);
  207         tsize_t rowsize =
  208             TIFFhowmany8(multiply(tif, w, td->td_bitspersample,
  209                       "TIFFVTileSize"));
  210         tsize_t samplingarea =
  211             td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1];
  212         if (samplingarea == 0) {
  213             _TIFFError(tif, tif->tif_name,
  214                 "Invalid YCbCr subsampling");
  215             return 0;
  216         }
  217         nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]);
  218         /* NB: don't need TIFFhowmany here 'cuz everything is rounded */
  219         tilesize = multiply(tif, nrows, rowsize, "TIFFVTileSize");
  220         tilesize = summarize(tif, tilesize,
  221                      multiply(tif, 2, tilesize / samplingarea,
  222                           "TIFFVTileSize"),
  223                      "TIFFVTileSize");
  224     } else
  225         tilesize = multiply(tif, nrows, TIFFTileRowSize(tif),
  226                     "TIFFVTileSize");
  227     return ((tsize_t)
  228         multiply(tif, tilesize, td->td_tiledepth, "TIFFVTileSize"));
  229 }
  230 
  231 /*
  232  * Compute the # bytes in a row-aligned tile.
  233  */
  234 tsize_t
  235 TIFFTileSize(TIFF* tif)
  236 {
  237     return (TIFFVTileSize(tif, tif->tif_dir.td_tilelength));
  238 }
  239 
  240 /*
  241  * Compute a default tile size based on the image
  242  * characteristics and a requested value.  If a
  243  * request is <1 then we choose a size according
  244  * to certain heuristics.
  245  */
  246 void
  247 TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
  248 {
  249     (*tif->tif_deftilesize)(tif, tw, th);
  250 }
  251 
  252 void
  253 _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
  254 {
  255     (void) tif;
  256     if (*(int32*) tw < 1)
  257         *tw = 256;
  258     if (*(int32*) th < 1)
  259         *th = 256;
  260     /* roundup to a multiple of 16 per the spec */
  261     if (*tw & 0xf)
  262         *tw = TIFFroundup(*tw, 16);
  263     if (*th & 0xf)
  264         *th = TIFFroundup(*th, 16);
  265 }
  266 
  267 /* vim: set ts=8 sts=8 sw=8 noet: */