dll/3rdparty/libtiff/tif_aux.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  * Auxiliary Support Routines.
  29  */
  30
  31 #include <precomp.h>
  32 #include "tif_predict.h"
  33 #include <math.h>
  34 #include <float.h>
  35
  36 uint32
  37 _TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where)
  38 {
  39         if (second && first > TIFF_UINT32_MAX / second) {
  40                 TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
  41                 return 0;
  42         }
  43
  44         return first * second;
  45 }
  46
  47 uint64
  48 _TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where)
  49 {
  50         if (second && first > TIFF_UINT64_MAX / second) {
  51                 TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
  52                 return 0;
  53         }
  54
  55         return first * second;
  56 }
  57
  58 tmsize_t
  59 _TIFFMultiplySSize(TIFF* tif, tmsize_t first, tmsize_t second, const char* where)
  60 {
  61     if( first <= 0 || second <= 0 )
  62     {
  63         if( tif != NULL && where != NULL )
  64         {
  65             TIFFErrorExt(tif->tif_clientdata, where,
  66                         "Invalid argument to _TIFFMultiplySSize() in %s", where);
  67         }
  68         return 0;
  69     }
  70
  71     if( first > TIFF_TMSIZE_T_MAX / second )
  72     {
  73         if( tif != NULL && where != NULL )
  74         {
  75             TIFFErrorExt(tif->tif_clientdata, where,
  76                         "Integer overflow in %s", where);
  77         }
  78         return 0;
  79     }
  80     return first * second;
  81 }
  82
  83 tmsize_t _TIFFCastUInt64ToSSize(TIFF* tif, uint64 val, const char* module)
  84 {
  85     if( val > (uint64)TIFF_TMSIZE_T_MAX )
  86     {
  87         if( tif != NULL && module != NULL )
  88         {
  89             TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
  90         }
  91         return 0;
  92     }
  93     return (tmsize_t)val;
  94 }
  95
  96 void*
  97 _TIFFCheckRealloc(TIFF* tif, void* buffer,
  98                   tmsize_t nmemb, tmsize_t elem_size, const char* what)
  99 {
 100         void* cp = NULL;
 101         tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
 102         /*
 103          * Check for integer overflow.
 104          */
 105         if (count != 0)
 106         {
 107                 cp = _TIFFrealloc(buffer, count);
 108         }
 109
 110         if (cp == NULL) {
 111                 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 112                              "Failed to allocate memory for %s "
 113                              "(%ld elements of %ld bytes each)",
 114                              what,(long) nmemb, (long) elem_size);
 115         }
 116
 117         return cp;
 118 }
 119
 120 void*
 121 _TIFFCheckMalloc(TIFF* tif, tmsize_t nmemb, tmsize_t elem_size, const char* what)
 122 {
 123         return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
 124 }
 125
 126 static int
 127 TIFFDefaultTransferFunction(TIFFDirectory* td)
 128 {
 129         uint16 **tf = td->td_transferfunction;
 130         tmsize_t i, n, nbytes;
 131
 132         tf[0] = tf[1] = tf[2] = 0;
 133         if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2)
 134                 return 0;
 135
 136         n = ((tmsize_t)1)<<td->td_bitspersample;
 137         nbytes = n * sizeof (uint16);
 138         tf[0] = (uint16 *)_TIFFmalloc(nbytes);
 139         if (tf[0] == NULL)
 140                 return 0;
 141         tf[0][0] = 0;
 142         for (i = 1; i < n; i++) {
 143                 double t = (double)i/((double) n-1.);
 144                 tf[0][i] = (uint16)floor(65535.*pow(t, 2.2) + .5);
 145         }
 146
 147         if (td->td_samplesperpixel - td->td_extrasamples > 1) {
 148                 tf[1] = (uint16 *)_TIFFmalloc(nbytes);
 149                 if(tf[1] == NULL)
 150                         goto bad;
 151                 _TIFFmemcpy(tf[1], tf[0], nbytes);
 152                 tf[2] = (uint16 *)_TIFFmalloc(nbytes);
 153                 if (tf[2] == NULL)
 154                         goto bad;
 155                 _TIFFmemcpy(tf[2], tf[0], nbytes);
 156         }
 157         return 1;
 158
 159 bad:
 160         if (tf[0])
 161                 _TIFFfree(tf[0]);
 162         if (tf[1])
 163                 _TIFFfree(tf[1]);
 164         if (tf[2])
 165                 _TIFFfree(tf[2]);
 166         tf[0] = tf[1] = tf[2] = 0;
 167         return 0;
 168 }
 169
 170 static int
 171 TIFFDefaultRefBlackWhite(TIFFDirectory* td)
 172 {
 173         int i;
 174
 175         td->td_refblackwhite = (float *)_TIFFmalloc(6*sizeof (float));
 176         if (td->td_refblackwhite == NULL)
 177                 return 0;
 178         if (td->td_photometric == PHOTOMETRIC_YCBCR) {
 179                 /*
 180                  * YCbCr (Class Y) images must have the ReferenceBlackWhite
 181                  * tag set. Fix the broken images, which lacks that tag.
 182                  */
 183                 td->td_refblackwhite[0] = 0.0F;
 184                 td->td_refblackwhite[1] = td->td_refblackwhite[3] =
 185                         td->td_refblackwhite[5] = 255.0F;
 186                 td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
 187         } else {
 188                 /*
 189                  * Assume RGB (Class R)
 190                  */
 191                 for (i = 0; i < 3; i++) {
 192                     td->td_refblackwhite[2*i+0] = 0;
 193                     td->td_refblackwhite[2*i+1] =
 194                             (float)((1L<<td->td_bitspersample)-1L);
 195                 }
 196         }
 197         return 1;
 198 }
 199
 200 /*
 201  * Like TIFFGetField, but return any default
 202  * value if the tag is not present in the directory.
 203  *
 204  * NB:  We use the value in the directory, rather than
 205  *      explicit values so that defaults exist only one
 206  *      place in the library -- in TIFFDefaultDirectory.
 207  */
 208 int
 209 TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap)
 210 {
 211         TIFFDirectory *td = &tif->tif_dir;
 212
 213         if (TIFFVGetField(tif, tag, ap))
 214                 return (1);
 215         switch (tag) {
 216         case TIFFTAG_SUBFILETYPE:
 217                 *va_arg(ap, uint32 *) = td->td_subfiletype;
 218                 return (1);
 219         case TIFFTAG_BITSPERSAMPLE:
 220                 *va_arg(ap, uint16 *) = td->td_bitspersample;
 221                 return (1);
 222         case TIFFTAG_THRESHHOLDING:
 223                 *va_arg(ap, uint16 *) = td->td_threshholding;
 224                 return (1);
 225         case TIFFTAG_FILLORDER:
 226                 *va_arg(ap, uint16 *) = td->td_fillorder;
 227                 return (1);
 228         case TIFFTAG_ORIENTATION:
 229                 *va_arg(ap, uint16 *) = td->td_orientation;
 230                 return (1);
 231         case TIFFTAG_SAMPLESPERPIXEL:
 232                 *va_arg(ap, uint16 *) = td->td_samplesperpixel;
 233                 return (1);
 234         case TIFFTAG_ROWSPERSTRIP:
 235                 *va_arg(ap, uint32 *) = td->td_rowsperstrip;
 236                 return (1);
 237         case TIFFTAG_MINSAMPLEVALUE:
 238                 *va_arg(ap, uint16 *) = td->td_minsamplevalue;
 239                 return (1);
 240         case TIFFTAG_MAXSAMPLEVALUE:
 241                 *va_arg(ap, uint16 *) = td->td_maxsamplevalue;
 242                 return (1);
 243         case TIFFTAG_PLANARCONFIG:
 244                 *va_arg(ap, uint16 *) = td->td_planarconfig;
 245                 return (1);
 246         case TIFFTAG_RESOLUTIONUNIT:
 247                 *va_arg(ap, uint16 *) = td->td_resolutionunit;
 248                 return (1);
 249         case TIFFTAG_PREDICTOR:
 250     {
 251         TIFFPredictorState* sp = (TIFFPredictorState*) tif->tif_data;
 252         if( sp == NULL )
 253         {
 254             TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 255                          "Cannot get \"Predictor\" tag as plugin is not configured");
 256             *va_arg(ap, uint16*) = 0;
 257             return 0;
 258         }
 259         *va_arg(ap, uint16*) = (uint16) sp->predictor;
 260         return 1;
 261     }
 262         case TIFFTAG_DOTRANGE:
 263                 *va_arg(ap, uint16 *) = 0;
 264                 *va_arg(ap, uint16 *) = (1<<td->td_bitspersample)-1;
 265                 return (1);
 266         case TIFFTAG_INKSET:
 267                 *va_arg(ap, uint16 *) = INKSET_CMYK;
 268                 return 1;
 269         case TIFFTAG_NUMBEROFINKS:
 270                 *va_arg(ap, uint16 *) = 4;
 271                 return (1);
 272         case TIFFTAG_EXTRASAMPLES:
 273                 *va_arg(ap, uint16 *) = td->td_extrasamples;
 274                 *va_arg(ap, uint16 **) = td->td_sampleinfo;
 275                 return (1);
 276         case TIFFTAG_MATTEING:
 277                 *va_arg(ap, uint16 *) =
 278                     (td->td_extrasamples == 1 &&
 279                      td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
 280                 return (1);
 281         case TIFFTAG_TILEDEPTH:
 282                 *va_arg(ap, uint32 *) = td->td_tiledepth;
 283                 return (1);
 284         case TIFFTAG_DATATYPE:
 285                 *va_arg(ap, uint16 *) = td->td_sampleformat-1;
 286                 return (1);
 287         case TIFFTAG_SAMPLEFORMAT:
 288                 *va_arg(ap, uint16 *) = td->td_sampleformat;
 289                 return(1);
 290         case TIFFTAG_IMAGEDEPTH:
 291                 *va_arg(ap, uint32 *) = td->td_imagedepth;
 292                 return (1);
 293         case TIFFTAG_YCBCRCOEFFICIENTS:
 294                 {
 295                         /* defaults are from CCIR Recommendation 601-1 */
 296                         static float ycbcrcoeffs[] = { 0.299f, 0.587f, 0.114f };
 297                         *va_arg(ap, float **) = ycbcrcoeffs;
 298                         return 1;
 299                 }
 300         case TIFFTAG_YCBCRSUBSAMPLING:
 301                 *va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[0];
 302                 *va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1];
 303                 return (1);
 304         case TIFFTAG_YCBCRPOSITIONING:
 305                 *va_arg(ap, uint16 *) = td->td_ycbcrpositioning;
 306                 return (1);
 307         case TIFFTAG_WHITEPOINT:
 308                 {
 309                         static float whitepoint[2];
 310
 311                         /* TIFF 6.0 specification tells that it is no default
 312                            value for the WhitePoint, but AdobePhotoshop TIFF
 313                            Technical Note tells that it should be CIE D50. */
 314                         whitepoint[0] = D50_X0 / (D50_X0 + D50_Y0 + D50_Z0);
 315                         whitepoint[1] = D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0);
 316                         *va_arg(ap, float **) = whitepoint;
 317                         return 1;
 318                 }
 319         case TIFFTAG_TRANSFERFUNCTION:
 320                 if (!td->td_transferfunction[0] &&
 321                     !TIFFDefaultTransferFunction(td)) {
 322                         TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space for \"TransferFunction\" tag");
 323                         return (0);
 324                 }
 325                 *va_arg(ap, uint16 **) = td->td_transferfunction[0];
 326                 if (td->td_samplesperpixel - td->td_extrasamples > 1) {
 327                         *va_arg(ap, uint16 **) = td->td_transferfunction[1];
 328                         *va_arg(ap, uint16 **) = td->td_transferfunction[2];
 329                 }
 330                 return (1);
 331         case TIFFTAG_REFERENCEBLACKWHITE:
 332                 if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(td))
 333                         return (0);
 334                 *va_arg(ap, float **) = td->td_refblackwhite;
 335                 return (1);
 336         }
 337         return 0;
 338 }
 339
 340 /*
 341  * Like TIFFGetField, but return any default
 342  * value if the tag is not present in the directory.
 343  */
 344 int
 345 TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...)
 346 {
 347         int ok;
 348         va_list ap;
 349
 350         va_start(ap, tag);
 351         ok =  TIFFVGetFieldDefaulted(tif, tag, ap);
 352         va_end(ap);
 353         return (ok);
 354 }
 355
 356 struct _Int64Parts {
 357         int32 low, high;
 358 };
 359
 360 typedef union {
 361         struct _Int64Parts part;
 362         int64 value;
 363 } _Int64;
 364
 365 float
 366 _TIFFUInt64ToFloat(uint64 ui64)
 367 {
 368         _Int64 i;
 369
 370         i.value = ui64;
 371         if (i.part.high >= 0) {
 372                 return (float)i.value;
 373         } else {
 374                 long double df;
 375                 df = (long double)i.value;
 376                 df += 18446744073709551616.0; /* adding 2**64 */
 377                 return (float)df;
 378         }
 379 }
 380
 381 double
 382 _TIFFUInt64ToDouble(uint64 ui64)
 383 {
 384         _Int64 i;
 385
 386         i.value = ui64;
 387         if (i.part.high >= 0) {
 388                 return (double)i.value;
 389         } else {
 390                 long double df;
 391                 df = (long double)i.value;
 392                 df += 18446744073709551616.0; /* adding 2**64 */
 393                 return (double)df;
 394         }
 395 }
 396
 397 float _TIFFClampDoubleToFloat( double val )
 398 {
 399     if( val > FLT_MAX )
 400         return FLT_MAX;
 401     if( val < -FLT_MAX )
 402         return -FLT_MAX;
 403     return (float)val;
 404 }
 405
 406 int _TIFFSeekOK(TIFF* tif, toff_t off)
 407 {
 408     /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
 409     /* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
 410     return off <= (~(uint64)0)/2 && TIFFSeekFile(tif,off,SEEK_SET)==off;
 411 }
 412
 413 /* vim: set ts=8 sts=8 sw=8 noet: */
 414 /*
 415  * Local Variables:
 416  * mode: c
 417  * c-basic-offset: 8
 418  * fill-column: 78
 419  * End:
 420  */