home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / tiff / tif_dirread.c < prev    next >
C/C++ Source or Header  |  2002-11-10  |  40KB  |  1,375 lines
  1. /* $Header: /pack/cvsroots/wxwindows/wxWindows/src/tiff/tif_dirread.c,v 1.1.6.1 2002/11/10 13:13:55 JS Exp $ */
  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. }
  1375.