dll/3rdparty/libtiff/tif_strip.c

   1 /*
   2  * Copyright (c) 1991-1997 Sam Leffler
   3  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and
   6  * its documentation for any purpose is hereby granted without fee, provided
   7  * that (i) the above copyright notices and this permission notice appear in
   8  * all copies of the software and related documentation, and (ii) the names of
   9  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  10  * publicity relating to the software without the specific, prior written
  11  * permission of Sam Leffler and Silicon Graphics.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  14  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  15  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  16  *
  17  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  18  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  19  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  21  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22  * OF THIS SOFTWARE.
  23  */
  24
  25 /*
  26  * TIFF Library.
  27  *
  28  * Strip-organized Image Support Routines.
  29  */
  30
  31 #include <precomp.h>
  32
  33 /*
  34  * Compute which strip a (row,sample) value is in.
  35  */
  36 uint32
  37 TIFFComputeStrip(TIFF* tif, uint32 row, uint16 sample)
  38 {
  39         static const char module[] = "TIFFComputeStrip";
  40         TIFFDirectory *td = &tif->tif_dir;
  41         uint32 strip;
  42
  43         strip = row / td->td_rowsperstrip;
  44         if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
  45                 if (sample >= td->td_samplesperpixel) {
  46                         TIFFErrorExt(tif->tif_clientdata, module,
  47                             "%lu: Sample out of range, max %lu",
  48                             (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
  49                         return (0);
  50                 }
  51                 strip += (uint32)sample*td->td_stripsperimage;
  52         }
  53         return (strip);
  54 }
  55
  56 /*
  57  * Compute how many strips are in an image.
  58  */
  59 uint32
  60 TIFFNumberOfStrips(TIFF* tif)
  61 {
  62         TIFFDirectory *td = &tif->tif_dir;
  63         uint32 nstrips;
  64
  65         nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 :
  66              TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
  67         if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  68                 nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel,
  69                     "TIFFNumberOfStrips");
  70         return (nstrips);
  71 }
  72
  73 /*
  74  * Compute the # bytes in a variable height, row-aligned strip.
  75  */
  76 uint64
  77 TIFFVStripSize64(TIFF* tif, uint32 nrows)
  78 {
  79         static const char module[] = "TIFFVStripSize64";
  80         TIFFDirectory *td = &tif->tif_dir;
  81         if (nrows==(uint32)(-1))
  82                 nrows=td->td_imagelength;
  83         if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
  84             (td->td_photometric == PHOTOMETRIC_YCBCR)&&
  85             (!isUpSampled(tif)))
  86         {
  87                 /*
  88                  * Packed YCbCr data contain one Cb+Cr for every
  89                  * HorizontalSampling*VerticalSampling Y values.
  90                  * Must also roundup width and height when calculating
  91                  * since images that are not a multiple of the
  92                  * horizontal/vertical subsampling area include
  93                  * YCbCr data for the extended image.
  94                  */
  95                 uint16 ycbcrsubsampling[2];
  96                 uint16 samplingblock_samples;
  97                 uint32 samplingblocks_hor;
  98                 uint32 samplingblocks_ver;
  99                 uint64 samplingrow_samples;
 100                 uint64 samplingrow_size;
 101                 if(td->td_samplesperpixel!=3)
 102                 {
 103                         TIFFErrorExt(tif->tif_clientdata,module,
 104                             "Invalid td_samplesperpixel value");
 105                         return 0;
 106                 }
 107                 TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
 108                     ycbcrsubsampling+1);
 109                 if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
 110                     ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
 111                 {
 112                         TIFFErrorExt(tif->tif_clientdata,module,
 113                                      "Invalid YCbCr subsampling (%dx%d)",
 114                                      ycbcrsubsampling[0],
 115                                      ycbcrsubsampling[1] );
 116                         return 0;
 117                 }
 118                 samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
 119                 samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
 120                 samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
 121                 samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
 122                 samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
 123                 return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
 124         }
 125         else
 126                 return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module));
 127 }
 128 tmsize_t
 129 TIFFVStripSize(TIFF* tif, uint32 nrows)
 130 {
 131         static const char module[] = "TIFFVStripSize";
 132         uint64 m;
 133         tmsize_t n;
 134         m=TIFFVStripSize64(tif,nrows);
 135         n=(tmsize_t)m;
 136         if ((uint64)n!=m)
 137         {
 138                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 139                 n=0;
 140         }
 141         return(n);
 142 }
 143
 144 /*
 145  * Compute the # bytes in a raw strip.
 146  */
 147 uint64
 148 TIFFRawStripSize64(TIFF* tif, uint32 strip)
 149 {
 150         static const char module[] = "TIFFRawStripSize64";
 151         TIFFDirectory* td = &tif->tif_dir;
 152         uint64 bytecount = td->td_stripbytecount[strip];
 153
 154         if (bytecount == 0)
 155         {
 156 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
 157                 TIFFErrorExt(tif->tif_clientdata, module,
 158                              "%I64u: Invalid strip byte count, strip %lu",
 159                              (unsigned __int64) bytecount,
 160                              (unsigned long) strip);
 161 #else
 162                 TIFFErrorExt(tif->tif_clientdata, module,
 163                              "%llu: Invalid strip byte count, strip %lu",
 164                              (unsigned long long) bytecount,
 165                              (unsigned long) strip);
 166 #endif
 167                 bytecount = (uint64) -1;
 168         }
 169
 170         return bytecount;
 171 }
 172 tmsize_t
 173 TIFFRawStripSize(TIFF* tif, uint32 strip)
 174 {
 175         static const char module[] = "TIFFRawStripSize";
 176         uint64 m;
 177         tmsize_t n;
 178         m=TIFFRawStripSize64(tif,strip);
 179         if (m==(uint64)(-1))
 180                 n=(tmsize_t)(-1);
 181         else
 182         {
 183                 n=(tmsize_t)m;
 184                 if ((uint64)n!=m)
 185                 {
 186                         TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 187                         n=0;
 188                 }
 189         }
 190         return(n);
 191 }
 192
 193 /*
 194  * Compute the # bytes in a (row-aligned) strip.
 195  *
 196  * Note that if RowsPerStrip is larger than the
 197  * recorded ImageLength, then the strip size is
 198  * truncated to reflect the actual space required
 199  * to hold the strip.
 200  */
 201 uint64
 202 TIFFStripSize64(TIFF* tif)
 203 {
 204         TIFFDirectory* td = &tif->tif_dir;
 205         uint32 rps = td->td_rowsperstrip;
 206         if (rps > td->td_imagelength)
 207                 rps = td->td_imagelength;
 208         return (TIFFVStripSize64(tif, rps));
 209 }
 210 tmsize_t
 211 TIFFStripSize(TIFF* tif)
 212 {
 213         static const char module[] = "TIFFStripSize";
 214         uint64 m;
 215         tmsize_t n;
 216         m=TIFFStripSize64(tif);
 217         n=(tmsize_t)m;
 218         if ((uint64)n!=m)
 219         {
 220                 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
 221                 n=0;
 222         }
 223         return(n);
 224 }
 225
 226 /*
 227  * Compute a default strip size based on the image
 228  * characteristics and a requested value.  If the
 229  * request is <1 then we choose a strip size according
 230  * to certain heuristics.
 231  */
 232 uint32
 233 TIFFDefaultStripSize(TIFF* tif, uint32 request)
 234 {
 235         return (*tif->tif_defstripsize)(tif, request);
 236 }
 237
 238 uint32
 239 _TIFFDefaultStripSize(TIFF* tif, uint32 s)
 240 {
 241         if ((int32) s < 1) {
 242                 /*
 243                  * If RowsPerStrip is unspecified, try to break the
 244                  * image up into strips that are approximately
 245                  * STRIP_SIZE_DEFAULT bytes long.
 246                  */
 247                 uint64 scanlinesize;
 248                 uint64 rows;
 249                 scanlinesize=TIFFScanlineSize64(tif);
 250                 if (scanlinesize==0)
 251                         scanlinesize=1;
 252                 rows=(uint64)STRIP_SIZE_DEFAULT/scanlinesize;
 253                 if (rows==0)
 254                         rows=1;
 255                 else if (rows>0xFFFFFFFF)
 256                         rows=0xFFFFFFFF;
 257                 s=(uint32)rows;
 258         }
 259         return (s);
 260 }
 261
 262 /*
 263  * Return the number of bytes to read/write in a call to
 264  * one of the scanline-oriented i/o routines.  Note that
 265  * this number may be 1/samples-per-pixel if data is
 266  * stored as separate planes.
 267  * The ScanlineSize in case of YCbCrSubsampling is defined as the
 268  * strip size divided by the strip height, i.e. the size of a pack of vertical
 269  * subsampling lines divided by vertical subsampling. It should thus make
 270  * sense when multiplied by a multiple of vertical subsampling.
 271  */
 272 uint64
 273 TIFFScanlineSize64(TIFF* tif)
 274 {
 275         static const char module[] = "TIFFScanlineSize64";
 276         TIFFDirectory *td = &tif->tif_dir;
 277         uint64 scanline_size;
 278         if (td->td_planarconfig==PLANARCONFIG_CONTIG)
 279         {
 280                 if ((td->td_photometric==PHOTOMETRIC_YCBCR)&&
 281                     (td->td_samplesperpixel==3)&&
 282                     (!isUpSampled(tif)))
 283                 {
 284                         uint16 ycbcrsubsampling[2];
 285                         uint16 samplingblock_samples;
 286                         uint32 samplingblocks_hor;
 287                         uint64 samplingrow_samples;
 288                         uint64 samplingrow_size;
 289                         if(td->td_samplesperpixel!=3)
 290                         {
 291                             TIFFErrorExt(tif->tif_clientdata,module,
 292                                          "Invalid td_samplesperpixel value");
 293                             return 0;
 294                         }
 295                         TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,
 296                                               ycbcrsubsampling+0,
 297                                               ycbcrsubsampling+1);
 298                         if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) ||
 299                             ((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4)))
 300                         {
 301                             TIFFErrorExt(tif->tif_clientdata,module,
 302                                          "Invalid YCbCr subsampling");
 303                             return 0;
 304                         }
 305                         samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
 306                         samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
 307                         samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
 308                         samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8);
 309                         scanline_size = (samplingrow_size/ycbcrsubsampling[1]);
 310                 }
 311                 else
 312                 {
 313                         uint64 scanline_samples;
 314                         scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module);
 315                         scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8);
 316                 }
 317         }
 318         else
 319         {
 320                 scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8);
 321         }
 322         if (scanline_size == 0)
 323         {
 324                 TIFFErrorExt(tif->tif_clientdata,module,"Computed scanline size is zero");
 325                 return 0;
 326         }
 327         return(scanline_size);
 328 }
 329 tmsize_t
 330 TIFFScanlineSize(TIFF* tif)
 331 {
 332         static const char module[] = "TIFFScanlineSize";
 333         uint64 m;
 334         tmsize_t n;
 335         m=TIFFScanlineSize64(tif);
 336         n=(tmsize_t)m;
 337         if ((uint64)n!=m) {
 338                 TIFFErrorExt(tif->tif_clientdata,module,"Integer arithmetic overflow");
 339                 n=0;
 340         }
 341         return(n);
 342 }
 343
 344 /*
 345  * Return the number of bytes required to store a complete
 346  * decoded and packed raster scanline (as opposed to the
 347  * I/O size returned by TIFFScanlineSize which may be less
 348  * if data is store as separate planes).
 349  */
 350 uint64
 351 TIFFRasterScanlineSize64(TIFF* tif)
 352 {
 353         static const char module[] = "TIFFRasterScanlineSize64";
 354         TIFFDirectory *td = &tif->tif_dir;
 355         uint64 scanline;
 356
 357         scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
 358         if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
 359                 scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
 360                 return (TIFFhowmany8_64(scanline));
 361         } else
 362                 return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
 363                     td->td_samplesperpixel, module));
 364 }
 365 tmsize_t
 366 TIFFRasterScanlineSize(TIFF* tif)
 367 {
 368         static const char module[] = "TIFFRasterScanlineSize";
 369         uint64 m;
 370         tmsize_t n;
 371         m=TIFFRasterScanlineSize64(tif);
 372         n=(tmsize_t)m;
 373         if ((uint64)n!=m)
 374         {
 375                 TIFFErrorExt(tif->tif_clientdata,module,"Integer arithmetic overflow");
 376                 n=0;
 377         }
 378         return(n);
 379 }
 380
 381 /* vim: set ts=8 sts=8 sw=8 noet: */
 382 /*
 383  * Local Variables:
 384  * mode: c
 385  * c-basic-offset: 8
 386  * fill-column: 78
 387  * End:
 388  */