src/tiff/tif_dirread.c

   1 /* $Header$ */
   2
   3 /*
   4  * Copyright (c) 1988-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  * Directory Read Support Routines.
  31  */
  32 #include "tiffiop.h"
  33
  34 #define IGNORE  0               /* tag placeholder used below */
  35
  36 #if HAVE_IEEEFP
  37 #define TIFFCvtIEEEFloatToNative(tif, n, fp)
  38 #define TIFFCvtIEEEDoubleToNative(tif, n, dp)
  39 #else
  40 extern  void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*);
  41 extern  void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*);
  42 #endif
  43
  44 static  void EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16);
  45 static  void MissingRequired(TIFF*, const char*);
  46 static  int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);
  47 static  tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);
  48 static  tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);
  49 static  float TIFFFetchRational(TIFF*, TIFFDirEntry*);
  50 static  int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*);
  51 static  int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, int*);
  52 static  int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*);
  53 static  int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
  54 static  int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
  55 static  int TIFFFetchExtraSamples(TIFF*, TIFFDirEntry*);
  56 static  int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);
  57 static  float TIFFFetchFloat(TIFF*, TIFFDirEntry*);
  58 static  int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);
  59 static  int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*);
  60 static  int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*);
  61 static  int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);
  62 static  void ChopUpSingleUncompressedStrip(TIFF*);
  63
  64 static char *
  65 CheckMalloc(TIFF* tif, tsize_t n, const char* what)
  66 {
  67         char *cp = (char*)_TIFFmalloc(n);
  68         if (cp == NULL)
  69                 TIFFError(tif->tif_name, "No space %s", what);
  70         return (cp);
  71 }
  72
  73 /*
  74  * Read the next TIFF directory from a file
  75  * and convert it to the internal format.
  76  * We read directories sequentially.
  77  */
  78 int
  79 TIFFReadDirectory(TIFF* tif)
  80 {
  81         register TIFFDirEntry* dp;
  82         register int n;
  83         register TIFFDirectory* td;
  84         TIFFDirEntry* dir;
  85         int iv;
  86         long v;
  87         double dv;
  88         const TIFFFieldInfo* fip;
  89         int fix;
  90         uint16 dircount;
  91         uint32 nextdiroff;
  92         char* cp;
  93         int diroutoforderwarning = 0;
  94
  95         tif->tif_diroff = tif->tif_nextdiroff;
  96         if (tif->tif_diroff == 0)               /* no more directories */
  97                 return (0);
  98         /*
  99          * Cleanup any previous compression state.
 100          */
 101         (*tif->tif_cleanup)(tif);
 102         tif->tif_curdir++;
 103         nextdiroff = 0;
 104         if (!isMapped(tif)) {
 105                 if (!SeekOK(tif, tif->tif_diroff)) {
 106                         TIFFError(tif->tif_name,
 107                             "Seek error accessing TIFF directory");
 108                         return (0);
 109                 }
 110                 if (!ReadOK(tif, &dircount, sizeof (uint16))) {
 111                         TIFFError(tif->tif_name,
 112                             "Can not read TIFF directory count");
 113                         return (0);
 114                 }
 115                 if (tif->tif_flags & TIFF_SWAB)
 116                         TIFFSwabShort(&dircount);
 117                 dir = (TIFFDirEntry *)CheckMalloc(tif,
 118                     dircount * sizeof (TIFFDirEntry), "to read TIFF directory");
 119                 if (dir == NULL)
 120                         return (0);
 121                 if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
 122                         TIFFError(tif->tif_name, "Can not read TIFF directory");
 123                         goto bad;
 124                 }
 125                 /*
 126                  * Read offset to next directory for sequential scans.
 127                  */
 128                 (void) ReadOK(tif, &nextdiroff, sizeof (uint32));
 129         } else {
 130                 toff_t off = tif->tif_diroff;
 131
 132                 if (off + sizeof (uint16) > tif->tif_size) {
 133                         TIFFError(tif->tif_name,
 134                             "Can not read TIFF directory count");
 135                         return (0);
 136                 } else
 137                         _TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));
 138                 off += sizeof (uint16);
 139                 if (tif->tif_flags & TIFF_SWAB)
 140                         TIFFSwabShort(&dircount);
 141                 dir = (TIFFDirEntry *)CheckMalloc(tif,
 142                     dircount * sizeof (TIFFDirEntry), "to read TIFF directory");
 143                 if (dir == NULL)
 144                         return (0);
 145                 if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {
 146                         TIFFError(tif->tif_name, "Can not read TIFF directory");
 147                         goto bad;
 148                 } else
 149                         _TIFFmemcpy(dir, tif->tif_base + off,
 150                             dircount*sizeof (TIFFDirEntry));
 151                 off += dircount* sizeof (TIFFDirEntry);
 152                 if (off + sizeof (uint32) <= tif->tif_size)
 153                         _TIFFmemcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32));
 154         }
 155         if (tif->tif_flags & TIFF_SWAB)
 156                 TIFFSwabLong(&nextdiroff);
 157         tif->tif_nextdiroff = nextdiroff;
 158
 159         tif->tif_flags &= ~TIFF_BEENWRITING;    /* reset before new dir */
 160         /*
 161          * Setup default value and then make a pass over
 162          * the fields to check type and tag information,
 163          * and to extract info required to size data
 164          * structures.  A second pass is made afterwards
 165          * to read in everthing not taken in the first pass.
 166          */
 167         td = &tif->tif_dir;
 168         /* free any old stuff and reinit */
 169         TIFFFreeDirectory(tif);
 170         TIFFDefaultDirectory(tif);
 171         /*
 172          * Electronic Arts writes gray-scale TIFF files
 173          * without a PlanarConfiguration directory entry.
 174          * Thus we setup a default value here, even though
 175          * the TIFF spec says there is no default value.
 176          */
 177         TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 178
 179         /*
 180          * Sigh, we must make a separate pass through the
 181          * directory for the following reason:
 182          *
 183          * We must process the Compression tag in the first pass
 184          * in order to merge in codec-private tag definitions (otherwise
 185          * we may get complaints about unknown tags).  However, the
 186          * Compression tag may be dependent on the SamplesPerPixel
 187          * tag value because older TIFF specs permited Compression
 188          * to be written as a SamplesPerPixel-count tag entry.
 189          * Thus if we don't first figure out the correct SamplesPerPixel
 190          * tag value then we may end up ignoring the Compression tag
 191          * value because it has an incorrect count value (if the
 192          * true value of SamplesPerPixel is not 1).
 193          *
 194          * It sure would have been nice if Aldus had really thought
 195          * this stuff through carefully.
 196          */
 197         for (dp = dir, n = dircount; n > 0; n--, dp++) {
 198                 if (tif->tif_flags & TIFF_SWAB) {
 199                         TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
 200                         TIFFSwabArrayOfLong(&dp->tdir_count, 2);
 201                 }
 202                 if (dp->tdir_tag == TIFFTAG_SAMPLESPERPIXEL) {
 203                         if (!TIFFFetchNormalTag(tif, dp))
 204                                 goto bad;
 205                         dp->tdir_tag = IGNORE;
 206                 }
 207         }
 208         /*
 209          * First real pass over the directory.
 210          */
 211         fix = 0;
 212         for (dp = dir, n = dircount; n > 0; n--, dp++) {
 213
 214                 /*
 215                  * Find the field information entry for this tag.
 216                  * Added check for tags to ignore ... [BFC]
 217                  */
 218                 if( TIFFReassignTagToIgnore(TIS_EXTRACT, dp->tdir_tag) )
 219                     dp->tdir_tag = IGNORE;
 220
 221                 if (dp->tdir_tag == IGNORE)
 222                     continue;
 223
 224                 /*
 225                  * Silicon Beach (at least) writes unordered
 226                  * directory tags (violating the spec).  Handle
 227                  * it here, but be obnoxious (maybe they'll fix it?).
 228                  */
 229                 if (dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag) {
 230                         if (!diroutoforderwarning) {
 231                                 TIFFWarning(tif->tif_name,
 232         "invalid TIFF directory; tags are not sorted in ascending order");
 233                                 diroutoforderwarning = 1;
 234                         }
 235                         fix = 0;                        /* O(n^2) */
 236                 }
 237                 while (fix < tif->tif_nfields &&
 238                     tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
 239                         fix++;
 240                 if (fix == tif->tif_nfields ||
 241                     tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
 242                         TIFFWarning(tif->tif_name,
 243                             "unknown field with tag %d (0x%x) ignored",
 244                             dp->tdir_tag,  dp->tdir_tag);
 245                         dp->tdir_tag = IGNORE;
 246                         fix = 0;                        /* restart search */
 247                         continue;
 248                 }
 249                 /*
 250                  * Null out old tags that we ignore.
 251                  */
 252                 if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) {
 253         ignore:
 254                         dp->tdir_tag = IGNORE;
 255                         continue;
 256                 }
 257                 /*
 258                  * Check data type.
 259                  */
 260                 fip = tif->tif_fieldinfo[fix];
 261                 while (dp->tdir_type != (u_short) fip->field_type) {
 262                         if (fip->field_type == TIFF_ANY)        /* wildcard */
 263                                 break;
 264                         fip++, fix++;
 265                         if (fix == tif->tif_nfields ||
 266                             fip->field_tag != dp->tdir_tag) {
 267                                 TIFFWarning(tif->tif_name,
 268                                    "wrong data type %d for \"%s\"; tag ignored",
 269                                     dp->tdir_type, fip[-1].field_name);
 270                                 goto ignore;
 271                         }
 272                 }
 273                 /*
 274                  * Check count if known in advance.
 275                  */
 276                 if (fip->field_readcount != TIFF_VARIABLE) {
 277                         uint32 expected = (fip->field_readcount == TIFF_SPP) ?
 278                             (uint32) td->td_samplesperpixel :
 279                             (uint32) fip->field_readcount;
 280                         if (!CheckDirCount(tif, dp, expected))
 281                                 goto ignore;
 282                 }
 283
 284                 switch (dp->tdir_tag) {
 285                 case TIFFTAG_COMPRESSION:
 286                         /*
 287                          * The 5.0 spec says the Compression tag has
 288                          * one value, while earlier specs say it has
 289                          * one value per sample.  Because of this, we
 290                          * accept the tag if one value is supplied.
 291                          */
 292                         if (dp->tdir_count == 1) {
 293                                 v = TIFFExtractData(tif,
 294                                     dp->tdir_type, dp->tdir_offset);
 295                                 if (!TIFFSetField(tif, dp->tdir_tag, (int)v))
 296                                         goto bad;
 297                                 break;
 298                         }
 299                         if (!TIFFFetchPerSampleShorts(tif, dp, &iv) ||
 300                             !TIFFSetField(tif, dp->tdir_tag, iv))
 301                                 goto bad;
 302                         dp->tdir_tag = IGNORE;
 303                         break;
 304                 case TIFFTAG_STRIPOFFSETS:
 305                 case TIFFTAG_STRIPBYTECOUNTS:
 306                 case TIFFTAG_TILEOFFSETS:
 307                 case TIFFTAG_TILEBYTECOUNTS:
 308                         TIFFSetFieldBit(tif, fip->field_bit);
 309                         break;
 310                 case TIFFTAG_IMAGEWIDTH:
 311                 case TIFFTAG_IMAGELENGTH:
 312                 case TIFFTAG_IMAGEDEPTH:
 313                 case TIFFTAG_TILELENGTH:
 314                 case TIFFTAG_TILEWIDTH:
 315                 case TIFFTAG_TILEDEPTH:
 316                 case TIFFTAG_PLANARCONFIG:
 317                 case TIFFTAG_ROWSPERSTRIP:
 318                         if (!TIFFFetchNormalTag(tif, dp))
 319                                 goto bad;
 320                         dp->tdir_tag = IGNORE;
 321                         break;
 322                 case TIFFTAG_EXTRASAMPLES:
 323                         (void) TIFFFetchExtraSamples(tif, dp);
 324                         dp->tdir_tag = IGNORE;
 325                         break;
 326                 }
 327         }
 328
 329         /*
 330          * Allocate directory structure and setup defaults.
 331          */
 332         if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
 333                 MissingRequired(tif, "ImageLength");
 334                 goto bad;
 335         }
 336         if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
 337                 MissingRequired(tif, "PlanarConfiguration");
 338                 goto bad;
 339         }
 340         /*
 341          * Setup appropriate structures (by strip or by tile)
 342          */
 343         if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
 344                 td->td_nstrips = TIFFNumberOfStrips(tif);
 345                 td->td_tilewidth = td->td_imagewidth;
 346                 td->td_tilelength = td->td_rowsperstrip;
 347                 td->td_tiledepth = td->td_imagedepth;
 348                 tif->tif_flags &= ~TIFF_ISTILED;
 349         } else {
 350                 td->td_nstrips = TIFFNumberOfTiles(tif);
 351                 tif->tif_flags |= TIFF_ISTILED;
 352         }
 353         td->td_stripsperimage = td->td_nstrips;
 354         if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
 355                 td->td_stripsperimage /= td->td_samplesperpixel;
 356         if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
 357                 MissingRequired(tif,
 358                     isTiled(tif) ? "TileOffsets" : "StripOffsets");
 359                 goto bad;
 360         }
 361
 362         /*
 363          * Second pass: extract other information.
 364          */
 365         for (dp = dir, n = dircount; n > 0; n--, dp++) {
 366                 if (dp->tdir_tag == IGNORE)
 367                         continue;
 368                 switch (dp->tdir_tag) {
 369                 case TIFFTAG_MINSAMPLEVALUE:
 370                 case TIFFTAG_MAXSAMPLEVALUE:
 371                 case TIFFTAG_BITSPERSAMPLE:
 372                         /*
 373                          * The 5.0 spec says the Compression tag has
 374                          * one value, while earlier specs say it has
 375                          * one value per sample.  Because of this, we
 376                          * accept the tag if one value is supplied.
 377                          *
 378                          * The MinSampleValue, MaxSampleValue and
 379                          * BitsPerSample tags are supposed to be written
 380                          * as one value/sample, but some vendors incorrectly
 381                          * write one value only -- so we accept that
 382                          * as well (yech).
 383                          */
 384                         if (dp->tdir_count == 1) {
 385                                 v = TIFFExtractData(tif,
 386                                     dp->tdir_type, dp->tdir_offset);
 387                                 if (!TIFFSetField(tif, dp->tdir_tag, (int)v))
 388                                         goto bad;
 389                                 break;
 390                         }
 391                         /* fall thru... */
 392                 case TIFFTAG_DATATYPE:
 393                 case TIFFTAG_SAMPLEFORMAT:
 394                         if (!TIFFFetchPerSampleShorts(tif, dp, &iv) ||
 395                             !TIFFSetField(tif, dp->tdir_tag, iv))
 396                                 goto bad;
 397                         break;
 398                 case TIFFTAG_SMINSAMPLEVALUE:
 399                 case TIFFTAG_SMAXSAMPLEVALUE:
 400                         if (!TIFFFetchPerSampleAnys(tif, dp, &dv) ||
 401                             !TIFFSetField(tif, dp->tdir_tag, dv))
 402                                 goto bad;
 403                         break;
 404                 case TIFFTAG_STRIPOFFSETS:
 405                 case TIFFTAG_TILEOFFSETS:
 406                         if (!TIFFFetchStripThing(tif, dp,
 407                             td->td_nstrips, &td->td_stripoffset))
 408                                 goto bad;
 409                         break;
 410                 case TIFFTAG_STRIPBYTECOUNTS:
 411                 case TIFFTAG_TILEBYTECOUNTS:
 412                         if (!TIFFFetchStripThing(tif, dp,
 413                             td->td_nstrips, &td->td_stripbytecount))
 414                                 goto bad;
 415                         break;
 416                 case TIFFTAG_COLORMAP:
 417                 case TIFFTAG_TRANSFERFUNCTION:
 418                         /*
 419                          * TransferFunction can have either 1x or 3x data
 420                          * values; Colormap can have only 3x items.
 421                          */
 422                         v = 1L<<td->td_bitspersample;
 423                         if (dp->tdir_tag == TIFFTAG_COLORMAP ||
 424                             dp->tdir_count != (uint32) v) {
 425                                 if (!CheckDirCount(tif, dp, (uint32)(3*v)))
 426                                         break;
 427                         }
 428                         v *= sizeof (uint16);
 429                         cp = CheckMalloc(tif, dp->tdir_count * sizeof (uint16),
 430                             "to read \"TransferFunction\" tag");
 431                         if (cp != NULL) {
 432                                 if (TIFFFetchData(tif, dp, cp)) {
 433                                         /*
 434                                          * This deals with there being only
 435                                          * one array to apply to all samples.
 436                                          */
 437                                         uint32 c =
 438                                             (uint32)1 << td->td_bitspersample;
 439                                         if (dp->tdir_count == c)
 440                                                 v = 0;
 441                                         TIFFSetField(tif, dp->tdir_tag,
 442                                             cp, cp+v, cp+2*v);
 443                                 }
 444                                 _TIFFfree(cp);
 445                         }
 446                         break;
 447                 case TIFFTAG_PAGENUMBER:
 448                 case TIFFTAG_HALFTONEHINTS:
 449                 case TIFFTAG_YCBCRSUBSAMPLING:
 450                 case TIFFTAG_DOTRANGE:
 451                         (void) TIFFFetchShortPair(tif, dp);
 452                         break;
 453 #ifdef COLORIMETRY_SUPPORT
 454                 case TIFFTAG_REFERENCEBLACKWHITE:
 455                         (void) TIFFFetchRefBlackWhite(tif, dp);
 456                         break;
 457 #endif
 458 /* BEGIN REV 4.0 COMPATIBILITY */
 459                 case TIFFTAG_OSUBFILETYPE:
 460                         v = 0;
 461                         switch (TIFFExtractData(tif, dp->tdir_type,
 462                             dp->tdir_offset)) {
 463                         case OFILETYPE_REDUCEDIMAGE:
 464                                 v = FILETYPE_REDUCEDIMAGE;
 465                                 break;
 466                         case OFILETYPE_PAGE:
 467                                 v = FILETYPE_PAGE;
 468                                 break;
 469                         }
 470                         if (v)
 471                                 (void) TIFFSetField(tif,
 472                                     TIFFTAG_SUBFILETYPE, (int)v);
 473                         break;
 474 /* END REV 4.0 COMPATIBILITY */
 475                 default:
 476                         (void) TIFFFetchNormalTag(tif, dp);
 477                         break;
 478                 }
 479         }
 480         /*
 481          * Verify Palette image has a Colormap.
 482          */
 483         if (td->td_photometric == PHOTOMETRIC_PALETTE &&
 484             !TIFFFieldSet(tif, FIELD_COLORMAP)) {
 485                 MissingRequired(tif, "Colormap");
 486                 goto bad;
 487         }
 488         /*
 489          * Attempt to deal with a missing StripByteCounts tag.
 490          */
 491         if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
 492                 /*
 493                  * Some manufacturers violate the spec by not giving
 494                  * the size of the strips.  In this case, assume there
 495                  * is one uncompressed strip of data.
 496                  */
 497                 if ((td->td_planarconfig == PLANARCONFIG_CONTIG &&
 498                     td->td_nstrips > 1) ||
 499                     (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
 500                      td->td_nstrips != td->td_samplesperpixel)) {
 501                     MissingRequired(tif, "StripByteCounts");
 502                     goto bad;
 503                 }
 504                 TIFFWarning(tif->tif_name,
 505 "TIFF directory is missing required \"%s\" field, calculating from imagelength",
 506                     _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
 507                 EstimateStripByteCounts(tif, dir, dircount);
 508 #define BYTECOUNTLOOKSBAD \
 509     (td->td_stripbytecount[0] == 0 || \
 510     (td->td_compression == COMPRESSION_NONE && \
 511      td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]))
 512         } else if (td->td_nstrips == 1 && BYTECOUNTLOOKSBAD) {
 513                 /*
 514                  * Plexus (and others) sometimes give a value
 515                  * of zero for a tag when they don't know what
 516                  * the correct value is!  Try and handle the
 517                  * simple case of estimating the size of a one
 518                  * strip image.
 519                  */
 520                 TIFFWarning(tif->tif_name,
 521             "Bogus \"%s\" field, ignoring and calculating from imagelength",
 522                     _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
 523                 EstimateStripByteCounts(tif, dir, dircount);
 524         }
 525         if (dir)
 526                 _TIFFfree((char *)dir);
 527         if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
 528                 td->td_maxsamplevalue = (uint16)((1L<<td->td_bitspersample)-1);
 529         /*
 530          * Setup default compression scheme.
 531          */
 532         if (!TIFFFieldSet(tif, FIELD_COMPRESSION))
 533                 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
 534         /*
 535          * Some manufacturers make life difficult by writing
 536          * large amounts of uncompressed data as a single strip.
 537          * This is contrary to the recommendations of the spec.
 538          * The following makes an attempt at breaking such images
 539          * into strips closer to the recommended 8k bytes.  A
 540          * side effect, however, is that the RowsPerStrip tag
 541          * value may be changed.
 542          */
 543         if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE &&
 544             (tif->tif_flags & (TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP)
 545                 ChopUpSingleUncompressedStrip(tif);
 546         /*
 547          * Reinitialize i/o since we are starting on a new directory.
 548          */
 549         tif->tif_row = (uint32) -1;
 550         tif->tif_curstrip = (tstrip_t) -1;
 551         tif->tif_col = (uint32) -1;
 552         tif->tif_curtile = (ttile_t) -1;
 553         tif->tif_tilesize = TIFFTileSize(tif);
 554         tif->tif_scanlinesize = TIFFScanlineSize(tif);
 555         return (1);
 556 bad:
 557         if (dir)
 558                 _TIFFfree(dir);
 559         return (0);
 560 }
 561
 562 static void
 563 EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
 564 {
 565         register TIFFDirEntry *dp;
 566         register TIFFDirectory *td = &tif->tif_dir;
 567         uint16 i;
 568
 569         if (td->td_stripbytecount)
 570                 _TIFFfree(td->td_stripbytecount);
 571         td->td_stripbytecount = (uint32*)
 572             CheckMalloc(tif, td->td_nstrips * sizeof (uint32),
 573                 "for \"StripByteCounts\" array");
 574         if (td->td_compression != COMPRESSION_NONE) {
 575                 uint32 space = (uint32)(sizeof (TIFFHeader)
 576                     + sizeof (uint16)
 577                     + (dircount * sizeof (TIFFDirEntry))
 578                     + sizeof (uint32));
 579                 toff_t filesize = TIFFGetFileSize(tif);
 580                 uint16 n;
 581
 582                 /* calculate amount of space used by indirect values */
 583                 for (dp = dir, n = dircount; n > 0; n--, dp++) {
 584                         uint32 cc = dp->tdir_count*tiffDataWidth[dp->tdir_type];
 585                         if (cc > sizeof (uint32))
 586                                 space += cc;
 587                 }
 588                 space = filesize - space;
 589                 if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
 590                         space /= td->td_samplesperpixel;
 591                 for (i = 0; i < td->td_nstrips; i++)
 592                         td->td_stripbytecount[i] = space;
 593                 /*
 594                  * This gross hack handles the case were the offset to
 595                  * the last strip is past the place where we think the strip
 596                  * should begin.  Since a strip of data must be contiguous,
 597                  * it's safe to assume that we've overestimated the amount
 598                  * of data in the strip and trim this number back accordingly.
 599                  */
 600                 i--;
 601                 if (td->td_stripoffset[i] + td->td_stripbytecount[i] > filesize)
 602                         td->td_stripbytecount[i] =
 603                             filesize - td->td_stripoffset[i];
 604         } else {
 605                 uint32 rowbytes = TIFFScanlineSize(tif);
 606                 uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage;
 607                 for (i = 0; i < td->td_nstrips; i++)
 608                         td->td_stripbytecount[i] = rowbytes*rowsperstrip;
 609         }
 610         TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
 611         if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
 612                 td->td_rowsperstrip = td->td_imagelength;
 613 }
 614
 615 static void
 616 MissingRequired(TIFF* tif, const char* tagname)
 617 {
 618         TIFFError(tif->tif_name,
 619             "TIFF directory is missing required \"%s\" field", tagname);
 620 }
 621
 622 /*
 623  * Check the count field of a directory
 624  * entry against a known value.  The caller
 625  * is expected to skip/ignore the tag if
 626  * there is a mismatch.
 627  */
 628 static int
 629 CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
 630 {
 631         if (count != dir->tdir_count) {
 632                 TIFFWarning(tif->tif_name,
 633         "incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored",
 634                     _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
 635                     dir->tdir_count, count);
 636                 return (0);
 637         }
 638         return (1);
 639 }
 640
 641 /*
 642  * Fetch a contiguous directory item.
 643  */
 644 static tsize_t
 645 TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
 646 {
 647         int w = tiffDataWidth[dir->tdir_type];
 648         tsize_t cc = dir->tdir_count * w;
 649
 650         if (!isMapped(tif)) {
 651                 if (!SeekOK(tif, dir->tdir_offset))
 652                         goto bad;
 653                 if (!ReadOK(tif, cp, cc))
 654                         goto bad;
 655         } else {
 656                 if (dir->tdir_offset + cc > tif->tif_size)
 657                         goto bad;
 658                 _TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc);
 659         }
 660         if (tif->tif_flags & TIFF_SWAB) {
 661                 switch (dir->tdir_type) {
 662                 case TIFF_SHORT:
 663                 case TIFF_SSHORT:
 664                         TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
 665                         break;
 666                 case TIFF_LONG:
 667                 case TIFF_SLONG:
 668                 case TIFF_FLOAT:
 669                         TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
 670                         break;
 671                 case TIFF_RATIONAL:
 672                 case TIFF_SRATIONAL:
 673                         TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
 674                         break;
 675                 case TIFF_DOUBLE:
 676                         TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
 677                         break;
 678                 }
 679         }
 680         return (cc);
 681 bad:
 682         TIFFError(tif->tif_name, "Error fetching data for field \"%s\"",
 683             _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
 684         return ((tsize_t) 0);
 685 }
 686
 687 /*
 688  * Fetch an ASCII item from the file.
 689  */
 690 static tsize_t
 691 TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp)
 692 {
 693         if (dir->tdir_count <= 4) {
 694                 uint32 l = dir->tdir_offset;
 695                 if (tif->tif_flags & TIFF_SWAB)
 696                         TIFFSwabLong(&l);
 697                 _TIFFmemcpy(cp, &l, dir->tdir_count);
 698                 return (1);
 699         }
 700         return (TIFFFetchData(tif, dir, cp));
 701 }
 702
 703 /*
 704  * Convert numerator+denominator to float.
 705  */
 706 static int
 707 cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
 708 {
 709         if (denom == 0) {
 710                 TIFFError(tif->tif_name,
 711                     "%s: Rational with zero denominator (num = %lu)",
 712                     _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num);
 713                 return (0);
 714         } else {
 715                 if (dir->tdir_type == TIFF_RATIONAL)
 716                         *rv = ((float)num / (float)denom);
 717                 else
 718                         *rv = ((float)(int32)num / (float)(int32)denom);
 719                 return (1);
 720         }
 721 }
 722
 723 /*
 724  * Fetch a rational item from the file
 725  * at offset off and return the value
 726  * as a floating point number.
 727  */
 728 static float
 729 TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
 730 {
 731         uint32 l[2];
 732         float v;
 733
 734         return (!TIFFFetchData(tif, dir, (char *)l) ||
 735             !cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v);
 736 }
 737
 738 /*
 739  * Fetch a single floating point value
 740  * from the offset field and return it
 741  * as a native float.
 742  */
 743 static float
 744 TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)
 745 {
 746         long l = TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
 747         float v = *(float*) &l;
 748         TIFFCvtIEEEFloatToNative(tif, 1, &v);
 749         return (v);
 750 }
 751
 752 /*
 753  * Fetch an array of BYTE or SBYTE values.
 754  */
 755 static int
 756 TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
 757 {
 758         if (dir->tdir_count <= 4) {
 759                 /*
 760                  * Extract data from offset field.
 761                  */
 762                 if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
 763                         switch (dir->tdir_count) {
 764                         case 4: v[3] = dir->tdir_offset & 0xff;
 765                         case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
 766                         case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
 767                         case 1: v[0] = dir->tdir_offset >> 24;
 768                         }
 769                 } else {
 770                         switch (dir->tdir_count) {
 771                         case 4: v[3] = dir->tdir_offset >> 24;
 772                         case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
 773                         case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
 774                         case 1: v[0] = dir->tdir_offset & 0xff;
 775                         }
 776                 }
 777                 return (1);
 778         } else
 779                 return (TIFFFetchData(tif, dir, (char*) v) != 0);       /* XXX */
 780 }
 781
 782 /*
 783  * Fetch an array of SHORT or SSHORT values.
 784  */
 785 static int
 786 TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
 787 {
 788         if (dir->tdir_count <= 2) {
 789                 if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
 790                         switch (dir->tdir_count) {
 791                         case 2: v[1] = dir->tdir_offset & 0xffff;
 792                         case 1: v[0] = dir->tdir_offset >> 16;
 793                         }
 794                 } else {
 795                         switch (dir->tdir_count) {
 796                         case 2: v[1] = dir->tdir_offset >> 16;
 797                         case 1: v[0] = dir->tdir_offset & 0xffff;
 798                         }
 799                 }
 800                 return (1);
 801         } else
 802                 return (TIFFFetchData(tif, dir, (char *)v) != 0);
 803 }
 804
 805 /*
 806  * Fetch a pair of SHORT or BYTE values.
 807  */
 808 static int
 809 TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
 810 {
 811         uint16 v[2];
 812         int ok = 0;
 813
 814         switch (dir->tdir_type) {
 815         case TIFF_SHORT:
 816         case TIFF_SSHORT:
 817                 ok = TIFFFetchShortArray(tif, dir, v);
 818                 break;
 819         case TIFF_BYTE:
 820         case TIFF_SBYTE:
 821                 ok  = TIFFFetchByteArray(tif, dir, v);
 822                 break;
 823         }
 824         if (ok)
 825                 TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
 826         return (ok);
 827 }
 828
 829 /*
 830  * Fetch an array of LONG or SLONG values.
 831  */
 832 static int
 833 TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
 834 {
 835         if (dir->tdir_count == 1) {
 836                 v[0] = dir->tdir_offset;
 837                 return (1);
 838         } else
 839                 return (TIFFFetchData(tif, dir, (char*) v) != 0);
 840 }
 841
 842 /*
 843  * Fetch an array of RATIONAL or SRATIONAL values.
 844  */
 845 static int
 846 TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
 847 {
 848         int ok = 0;
 849         uint32* l;
 850
 851         l = (uint32*)CheckMalloc(tif,
 852             dir->tdir_count*tiffDataWidth[dir->tdir_type],
 853             "to fetch array of rationals");
 854         if (l) {
 855                 if (TIFFFetchData(tif, dir, (char *)l)) {
 856                         uint32 i;
 857                         for (i = 0; i < dir->tdir_count; i++) {
 858                                 ok = cvtRational(tif, dir,
 859                                     l[2*i+0], l[2*i+1], &v[i]);
 860                                 if (!ok)
 861                                         break;
 862                         }
 863                 }
 864                 _TIFFfree((char *)l);
 865         }
 866         return (ok);
 867 }
 868
 869 /*
 870  * Fetch an array of FLOAT values.
 871  */
 872 static int
 873 TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
 874 {
 875
 876         if (dir->tdir_count == 1) {
 877                 v[0] = *(float*) &dir->tdir_offset;
 878                 TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
 879                 return (1);
 880         } else  if (TIFFFetchData(tif, dir, (char*) v)) {
 881                 TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
 882                 return (1);
 883         } else
 884                 return (0);
 885 }
 886
 887 /*
 888  * Fetch an array of DOUBLE values.
 889  */
 890 static int
 891 TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)
 892 {
 893         if (TIFFFetchData(tif, dir, (char*) v)) {
 894                 TIFFCvtIEEEDoubleToNative(tif, dir->tdir_count, v);
 895                 return (1);
 896         } else
 897                 return (0);
 898 }
 899
 900 /*
 901  * Fetch an array of ANY values.  The actual values are
 902  * returned as doubles which should be able hold all the
 903  * types.  Yes, there really should be an tany_t to avoid
 904  * this potential non-portability ...  Note in particular
 905  * that we assume that the double return value vector is
 906  * large enough to read in any fundamental type.  We use
 907  * that vector as a buffer to read in the base type vector
 908  * and then convert it in place to double (from end
 909  * to front of course).
 910  */
 911 static int
 912 TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v)
 913 {
 914         int i;
 915
 916         switch (dir->tdir_type) {
 917         case TIFF_BYTE:
 918         case TIFF_SBYTE:
 919                 if (!TIFFFetchByteArray(tif, dir, (uint16*) v))
 920                         return (0);
 921                 if (dir->tdir_type == TIFF_BYTE) {
 922                         uint16* vp = (uint16*) v;
 923                         for (i = dir->tdir_count-1; i >= 0; i--)
 924                                 v[i] = vp[i];
 925                 } else {
 926                         int16* vp = (int16*) v;
 927                         for (i = dir->tdir_count-1; i >= 0; i--)
 928                                 v[i] = vp[i];
 929                 }
 930                 break;
 931         case TIFF_SHORT:
 932         case TIFF_SSHORT:
 933                 if (!TIFFFetchShortArray(tif, dir, (uint16*) v))
 934                         return (0);
 935                 if (dir->tdir_type == TIFF_SHORT) {
 936                         uint16* vp = (uint16*) v;
 937                         for (i = dir->tdir_count-1; i >= 0; i--)
 938                                 v[i] = vp[i];
 939                 } else {
 940                         int16* vp = (int16*) v;
 941                         for (i = dir->tdir_count-1; i >= 0; i--)
 942                                 v[i] = vp[i];
 943                 }
 944                 break;
 945         case TIFF_LONG:
 946         case TIFF_SLONG:
 947                 if (!TIFFFetchLongArray(tif, dir, (uint32*) v))
 948                         return (0);
 949                 if (dir->tdir_type == TIFF_LONG) {
 950                         uint32* vp = (uint32*) v;
 951                         for (i = dir->tdir_count-1; i >= 0; i--)
 952                                 v[i] = vp[i];
 953                 } else {
 954                         int32* vp = (int32*) v;
 955                         for (i = dir->tdir_count-1; i >= 0; i--)
 956                                 v[i] = vp[i];
 957                 }
 958                 break;
 959         case TIFF_RATIONAL:
 960         case TIFF_SRATIONAL:
 961                 if (!TIFFFetchRationalArray(tif, dir, (float*) v))
 962                         return (0);
 963                 { float* vp = (float*) v;
 964                   for (i = dir->tdir_count-1; i >= 0; i--)
 965                         v[i] = vp[i];
 966                 }
 967                 break;
 968         case TIFF_FLOAT:
 969                 if (!TIFFFetchFloatArray(tif, dir, (float*) v))
 970                         return (0);
 971                 { float* vp = (float*) v;
 972                   for (i = dir->tdir_count-1; i >= 0; i--)
 973                         v[i] = vp[i];
 974                 }
 975                 break;
 976         case TIFF_DOUBLE:
 977                 return (TIFFFetchDoubleArray(tif, dir, (double*) v));
 978         default:
 979                 /* TIFF_NOTYPE */
 980                 /* TIFF_ASCII */
 981                 /* TIFF_UNDEFINED */
 982                 TIFFError(tif->tif_name,
 983                     "Cannot read TIFF_ANY type %d for field \"%s\"",
 984                     _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
 985                 return (0);
 986         }
 987         return (1);
 988 }
 989
 990 /*
 991  * Fetch a tag that is not handled by special case code.
 992  */
 993 static int
 994 TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp)
 995 {
 996         static const char mesg[] = "to fetch tag value";
 997         int ok = 0;
 998         const TIFFFieldInfo* fip = _TIFFFieldWithTag(tif, dp->tdir_tag);
 999
1000         if (dp->tdir_count > 1) {               /* array of values */
1001                 char* cp = NULL;
1002
1003                 switch (dp->tdir_type) {
1004                 case TIFF_BYTE:
1005                 case TIFF_SBYTE:
1006                         /* NB: always expand BYTE values to shorts */
1007                         cp = CheckMalloc(tif,
1008                             dp->tdir_count * sizeof (uint16), mesg);
1009                         ok = cp && TIFFFetchByteArray(tif, dp, (uint16*) cp);
1010                         break;
1011                 case TIFF_SHORT:
1012                 case TIFF_SSHORT:
1013                         cp = CheckMalloc(tif,
1014                             dp->tdir_count * sizeof (uint16), mesg);
1015                         ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp);
1016                         break;
1017                 case TIFF_LONG:
1018                 case TIFF_SLONG:
1019                         cp = CheckMalloc(tif,
1020                             dp->tdir_count * sizeof (uint32), mesg);
1021                         ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp);
1022                         break;
1023                 case TIFF_RATIONAL:
1024                 case TIFF_SRATIONAL:
1025                         cp = CheckMalloc(tif,
1026                             dp->tdir_count * sizeof (float), mesg);
1027                         ok = cp && TIFFFetchRationalArray(tif, dp, (float*) cp);
1028                         break;
1029                 case TIFF_FLOAT:
1030                         cp = CheckMalloc(tif,
1031                             dp->tdir_count * sizeof (float), mesg);
1032                         ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp);
1033                         break;
1034                 case TIFF_DOUBLE:
1035                         cp = CheckMalloc(tif,
1036                             dp->tdir_count * sizeof (double), mesg);
1037                         ok = cp && TIFFFetchDoubleArray(tif, dp, (double*) cp);
1038                         break;
1039                 case TIFF_ASCII:
1040                 case TIFF_UNDEFINED:            /* bit of a cheat... */
1041                         /*
1042                          * Some vendors write strings w/o the trailing
1043                          * NULL byte, so always append one just in case.
1044                          */
1045                         cp = CheckMalloc(tif, dp->tdir_count+1, mesg);
1046                         if( (ok = (cp && TIFFFetchString(tif, dp, cp))) != 0 )
1047                                 cp[dp->tdir_count] = '\0';      /* XXX */
1048                         break;
1049                 }
1050                 if (ok) {
1051                         ok = (fip->field_passcount ?
1052                             TIFFSetField(tif, dp->tdir_tag, dp->tdir_count, cp)
1053                           : TIFFSetField(tif, dp->tdir_tag, cp));
1054                 }
1055                 if (cp != NULL)
1056                         _TIFFfree(cp);
1057         } else if (CheckDirCount(tif, dp, 1)) { /* singleton value */
1058                 switch (dp->tdir_type) {
1059                 case TIFF_BYTE:
1060                 case TIFF_SBYTE:
1061                 case TIFF_SHORT:
1062                 case TIFF_SSHORT:
1063                         /*
1064                          * If the tag is also acceptable as a LONG or SLONG
1065                          * then TIFFSetField will expect an uint32 parameter
1066                          * passed to it (through varargs).  Thus, for machines
1067                          * where sizeof (int) != sizeof (uint32) we must do
1068                          * a careful check here.  It's hard to say if this
1069                          * is worth optimizing.
1070                          *
1071                          * NB: We use TIFFFieldWithTag here knowing that
1072                          *     it returns us the first entry in the table
1073                          *     for the tag and that that entry is for the
1074                          *     widest potential data type the tag may have.
1075                          */
1076                         { TIFFDataType type = fip->field_type;
1077                           if (type != TIFF_LONG && type != TIFF_SLONG) {
1078                                 uint16 v = (uint16)
1079                            TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
1080                                 ok = (fip->field_passcount ?
1081                                     TIFFSetField(tif, dp->tdir_tag, 1, &v)
1082                                   : TIFFSetField(tif, dp->tdir_tag, v));
1083                                 break;
1084                           }
1085                         }
1086                         /* fall thru... */
1087                 case TIFF_LONG:
1088                 case TIFF_SLONG:
1089                         { uint32 v32 =
1090                     TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
1091                           ok = (fip->field_passcount ?
1092                               TIFFSetField(tif, dp->tdir_tag, 1, &v32)
1093                             : TIFFSetField(tif, dp->tdir_tag, v32));
1094                         }
1095                         break;
1096                 case TIFF_RATIONAL:
1097                 case TIFF_SRATIONAL:
1098                 case TIFF_FLOAT:
1099                         { float v = (dp->tdir_type == TIFF_FLOAT ?
1100                               TIFFFetchFloat(tif, dp)
1101                             : TIFFFetchRational(tif, dp));
1102                           ok = (fip->field_passcount ?
1103                               TIFFSetField(tif, dp->tdir_tag, 1, &v)
1104                             : TIFFSetField(tif, dp->tdir_tag, v));
1105                         }
1106                         break;
1107                 case TIFF_DOUBLE:
1108                         { double v;
1109                           ok = (TIFFFetchDoubleArray(tif, dp, &v) &&
1110                             (fip->field_passcount ?
1111                               TIFFSetField(tif, dp->tdir_tag, 1, &v)
1112                             : TIFFSetField(tif, dp->tdir_tag, v))
1113                           );
1114                         }
1115                         break;
1116                 case TIFF_ASCII:
1117                 case TIFF_UNDEFINED:            /* bit of a cheat... */
1118                         { char c[2];
1119                           if( (ok = (TIFFFetchString(tif, dp, c) != 0)) != 0 ){
1120                                 c[1] = '\0';            /* XXX paranoid */
1121                                 ok = TIFFSetField(tif, dp->tdir_tag, c);
1122                           }
1123                         }
1124                         break;
1125                 }
1126         }
1127         return (ok);
1128 }
1129
1130 #define NITEMS(x)       (sizeof (x) / sizeof (x[0]))
1131 /*
1132  * Fetch samples/pixel short values for
1133  * the specified tag and verify that
1134  * all values are the same.
1135  */
1136 static int
1137 TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, int* pl)
1138 {
1139         int samples = tif->tif_dir.td_samplesperpixel;
1140         int status = 0;
1141
1142         if (CheckDirCount(tif, dir, (uint32) samples)) {
1143                 uint16 buf[10];
1144                 uint16* v = buf;
1145
1146                 if (samples > NITEMS(buf))
1147                         v = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
1148                 if (TIFFFetchShortArray(tif, dir, v)) {
1149                         int i;
1150                         for (i = 1; i < samples; i++)
1151                                 if (v[i] != v[0]) {
1152                                         TIFFError(tif->tif_name,
1153                 "Cannot handle different per-sample values for field \"%s\"",
1154                            _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
1155                                         goto bad;
1156                                 }
1157                         *pl = v[0];
1158                         status = 1;
1159                 }
1160         bad:
1161                 if (v != buf)
1162                         _TIFFfree((char*) v);
1163         }
1164         return (status);
1165 }
1166
1167 /*
1168  * Fetch samples/pixel ANY values for
1169  * the specified tag and verify that
1170  * all values are the same.
1171  */
1172 static int
1173 TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl)
1174 {
1175         int samples = (int) tif->tif_dir.td_samplesperpixel;
1176         int status = 0;
1177
1178         if (CheckDirCount(tif, dir, (uint32) samples)) {
1179                 double buf[10];
1180                 double* v = buf;
1181
1182                 if (samples > NITEMS(buf))
1183                         v = (double*) _TIFFmalloc(samples * sizeof (double));
1184                 if (TIFFFetchAnyArray(tif, dir, v)) {
1185                         int i;
1186                         for (i = 1; i < samples; i++)
1187                                 if (v[i] != v[0]) {
1188                                         TIFFError(tif->tif_name,
1189                 "Cannot handle different per-sample values for field \"%s\"",
1190                            _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
1191                                         goto bad;
1192                                 }
1193                         *pl = v[0];
1194                         status = 1;
1195                 }
1196         bad:
1197                 if (v != buf)
1198                         _TIFFfree(v);
1199         }
1200         return (status);
1201 }
1202 #undef NITEMS
1203
1204 /*
1205  * Fetch a set of offsets or lengths.
1206  * While this routine says "strips",
1207  * in fact it's also used for tiles.
1208  */
1209 static int
1210 TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp)
1211 {
1212         register uint32* lp;
1213         int status;
1214
1215         if (!CheckDirCount(tif, dir, (uint32) nstrips))
1216                 return (0);
1217         /*
1218          * Allocate space for strip information.
1219          */
1220         if (*lpp == NULL &&
1221             (*lpp = (uint32 *)CheckMalloc(tif,
1222               nstrips * sizeof (uint32), "for strip array")) == NULL)
1223                 return (0);
1224         lp = *lpp;
1225         if (dir->tdir_type == (int)TIFF_SHORT) {
1226                 /*
1227                  * Handle uint16->uint32 expansion.
1228                  */
1229                 uint16* dp = (uint16*) CheckMalloc(tif,
1230                     dir->tdir_count* sizeof (uint16), "to fetch strip tag");
1231                 if (dp == NULL)
1232                         return (0);
1233                 if( (status = TIFFFetchShortArray(tif, dir, dp)) != 0 ) {
1234                         register uint16* wp = dp;
1235                         while (nstrips-- > 0)
1236                                 *lp++ = *wp++;
1237                 }
1238                 _TIFFfree((char*) dp);
1239         } else
1240                 status = TIFFFetchLongArray(tif, dir, lp);
1241         return (status);
1242 }
1243
1244 #define NITEMS(x)       (sizeof (x) / sizeof (x[0]))
1245 /*
1246  * Fetch and set the ExtraSamples tag.
1247  */
1248 static int
1249 TIFFFetchExtraSamples(TIFF* tif, TIFFDirEntry* dir)
1250 {
1251         uint16 buf[10];
1252         uint16* v = buf;
1253         int status;
1254
1255         if (dir->tdir_count > NITEMS(buf))
1256                 v = (uint16*) _TIFFmalloc(dir->tdir_count * sizeof (uint16));
1257         if (dir->tdir_type == TIFF_BYTE)
1258                 status = TIFFFetchByteArray(tif, dir, v);
1259         else
1260                 status = TIFFFetchShortArray(tif, dir, v);
1261         if (status)
1262                 status = TIFFSetField(tif, dir->tdir_tag, dir->tdir_count, v);
1263         if (v != buf)
1264                 _TIFFfree((char*) v);
1265         return (status);
1266 }
1267 #undef NITEMS
1268
1269 #ifdef COLORIMETRY_SUPPORT
1270 /*
1271  * Fetch and set the RefBlackWhite tag.
1272  */
1273 static int
1274 TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir)
1275 {
1276         static const char mesg[] = "for \"ReferenceBlackWhite\" array";
1277         char* cp;
1278         int ok;
1279
1280         if (dir->tdir_type == TIFF_RATIONAL)
1281                 return (TIFFFetchNormalTag(tif, dir));
1282         /*
1283          * Handle LONG's for backward compatibility.
1284          */
1285         cp = CheckMalloc(tif, dir->tdir_count * sizeof (uint32), mesg);
1286         if( (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*) cp))) != 0) {
1287                 float* fp = (float*)
1288                     CheckMalloc(tif, dir->tdir_count * sizeof (float), mesg);
1289                 if( (ok = (fp != NULL)) != 0 ) {
1290                         uint32 i;
1291                         for (i = 0; i < dir->tdir_count; i++)
1292                                 fp[i] = (float)((uint32*) cp)[i];
1293                         ok = TIFFSetField(tif, dir->tdir_tag, fp);
1294                         _TIFFfree((char*) fp);
1295                 }
1296         }
1297         if (cp)
1298                 _TIFFfree(cp);
1299         return (ok);
1300 }
1301 #endif
1302
1303 /*
1304  * Replace a single strip (tile) of uncompressed data by
1305  * multiple strips (tiles), each approximately 8Kbytes.
1306  * This is useful for dealing with large images or
1307  * for dealing with machines with a limited amount
1308  * memory.
1309  */
1310 static void
1311 ChopUpSingleUncompressedStrip(TIFF* tif)
1312 {
1313         register TIFFDirectory *td = &tif->tif_dir;
1314         uint32 bytecount = td->td_stripbytecount[0];
1315         uint32 offset = td->td_stripoffset[0];
1316         tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes;
1317         tstrip_t strip, nstrips, rowsperstrip;
1318         uint32* newcounts;
1319         uint32* newoffsets;
1320
1321         /*
1322          * Make the rows hold at least one
1323          * scanline, but fill 8k if possible.
1324          */
1325         if (rowbytes > 8192) {
1326                 stripbytes = rowbytes;
1327                 rowsperstrip = 1;
1328         } else {
1329                 rowsperstrip = 8192 / rowbytes;
1330                 stripbytes = rowbytes * rowsperstrip;
1331         }
1332         /* never increase the number of strips in an image */
1333         if (rowsperstrip >= td->td_rowsperstrip)
1334                 return;
1335         nstrips = (tstrip_t) TIFFhowmany(bytecount, stripbytes);
1336         newcounts = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32),
1337                                 "for chopped \"StripByteCounts\" array");
1338         newoffsets = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32),
1339                                 "for chopped \"StripOffsets\" array");
1340         if (newcounts == NULL || newoffsets == NULL) {
1341                 /*
1342                  * Unable to allocate new strip information, give
1343                  * up and use the original one strip information.
1344                  */
1345                 if (newcounts != NULL)
1346                         _TIFFfree(newcounts);
1347                 if (newoffsets != NULL)
1348                         _TIFFfree(newoffsets);
1349                 return;
1350         }
1351         /*
1352          * Fill the strip information arrays with
1353          * new bytecounts and offsets that reflect
1354          * the broken-up format.
1355          */
1356         for (strip = 0; strip < nstrips; strip++) {
1357                 if (stripbytes > bytecount)
1358                         stripbytes = bytecount;
1359                 newcounts[strip] = stripbytes;
1360                 newoffsets[strip] = offset;
1361                 offset += stripbytes;
1362                 bytecount -= stripbytes;
1363         }
1364         /*
1365          * Replace old single strip info with multi-strip info.
1366          */
1367         td->td_stripsperimage = td->td_nstrips = nstrips;
1368         TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
1369
1370         _TIFFfree(td->td_stripbytecount);
1371         _TIFFfree(td->td_stripoffset);
1372         td->td_stripbytecount = newcounts;
1373         td->td_stripoffset = newoffsets;
1374 }