home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / xloadimg.zip / xloadimage.4.1 / tiff / tif_dirread.c < prev    next >
C/C++ Source or Header  |  1996-03-18  |  33KB  |  1,209 lines
  1. #ifndef lint
  2. static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_dirread.c,v 1.20 92/03/25 09:58:09 sam Exp $";
  3. #endif
  4.  
  5. /*
  6.  * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
  7.  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and 
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  * 
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20.  * 
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library.
  31.  *
  32.  * Directory Read Support Routines.
  33.  *
  34.  * NB: Beware of the varargs declarations for routines in
  35.  *     this file.  The names and types of variables has been
  36.  *     carefully chosen to make things work with compilers that
  37.  *     are busted in one way or another (e.g. SGI/MIPS).
  38.  */
  39.  
  40. #define sun
  41.  
  42. #include "tiffioP.h"
  43.  
  44. #define    IGNORE    0        /* tag placeholder used below */
  45.  
  46.  
  47. #if HAVE_IEEEFP
  48. #define    TIFFCvtIEEEFloatToNative(tif, n, fp)
  49. #else
  50. #error e che cazzo
  51. #endif
  52.  
  53.  
  54. #include "prototypes.h"
  55. #if USE_PROTOTYPES
  56. static    EstimateStripByteCounts(TIFF *, TIFFDirEntry *, u_int);
  57. static    MissingRequired(TIFF *, char *);
  58. static    CheckDirCount(TIFF *, TIFFDirEntry *, u_long);
  59. static    TIFFFetchData(TIFF *, TIFFDirEntry *, char *);
  60. static    TIFFFetchString(TIFF *, TIFFDirEntry *, char *);
  61. static    float TIFFFetchRational(TIFF *, TIFFDirEntry *);
  62. static    TIFFFetchNormalTag(TIFF *, TIFFDirEntry *);
  63. static    TIFFFetchPerSampleShorts(TIFF *, TIFFDirEntry *, long *);
  64. static    TIFFFetchShortArray(TIFF *, TIFFDirEntry *, u_short []);
  65. static    TIFFFetchStripThing(TIFF *, TIFFDirEntry *, long, u_long **);
  66. static    TIFFFetchRefBlackWhite(TIFF *, TIFFDirEntry *);
  67. static    TIFFFetchJPEGQTables(TIFF *, TIFFDirEntry *);
  68. static    TIFFFetchJPEGCTables(TIFF *, TIFFDirEntry *, u_char ***);
  69. static    TIFFFetchExtraSamples(TIFF *, TIFFDirEntry *);
  70. static    float TIFFFetchFloat(TIFF *, TIFFDirEntry *);
  71. static    int TIFFFetchFloatArray(TIFF *, TIFFDirEntry *, float *);
  72. extern    int TIFFSetCompressionScheme(TIFF *, int);
  73. extern    int TIFFDefaultDirectory(TIFF*);
  74. extern    int TIFFFreeDirectory(TIFF*);
  75. #else
  76. static    EstimateStripByteCounts();
  77. static    MissingRequired();
  78. static    CheckDirCount();
  79. static    TIFFFetchData();
  80. static    TIFFFetchString();
  81. static    float TIFFFetchRational();
  82. static    TIFFFetchNormalTag();
  83. static    TIFFFetchPerSampleShorts();
  84. static    TIFFFetchShortArray();
  85. static    TIFFFetchStripThing();
  86. static    TIFFFetchRefBlackWhite();
  87. static    TIFFFetchJPEGQTables();
  88. static    TIFFFetchJPEGCTables();
  89. static    TIFFFetchExtraSamples();
  90. static    float TIFFFetchFloat();
  91. static    int TIFFFetchFloatArray();
  92. extern    int TIFFSetCompressionScheme();
  93. extern    int TIFFDefaultDirectory();
  94. extern    int TIFFFreeDirectory();
  95. #endif
  96.  
  97. static char *
  98. CheckMalloc(tif, n, what)
  99.     TIFF *tif;
  100.     int n;
  101.     char *what;
  102. {
  103.     char *cp = malloc(n);
  104.     if (cp == NULL)
  105.         TIFFError(tif->tif_name, "No space %s", what);
  106.     return (cp);
  107. }
  108.  
  109. /*
  110.  * Read the next TIFF directory from a file
  111.  * and convert it to the internal format.
  112.  * We read directories sequentially.
  113.  */
  114. TIFFReadDirectory(tif)
  115.     TIFF *tif;
  116. {
  117.     register TIFFDirEntry *dp;
  118.     register int n;
  119.     register TIFFDirectory *td;
  120.     TIFFDirEntry *dir;
  121.     long v;
  122.     TIFFFieldInfo *fip;
  123.     u_short dircount;
  124.     char *cp;
  125.     int diroutoforderwarning = 0;
  126.  
  127.     tif->tif_diroff = tif->tif_nextdiroff;
  128.     if (tif->tif_diroff == 0)        /* no more directories */
  129.         return (0);
  130.     tif->tif_curdir++;
  131.     if (!isMapped(tif)) {
  132.         if (!SeekOK(tif->tif_fd, tif->tif_diroff)) {
  133.             TIFFError(tif->tif_name,
  134.                 "Seek error accessing TIFF directory");
  135.             return (0);
  136.         }
  137.         if (!ReadOK(tif->tif_fd, &dircount, sizeof (short))) {
  138.             TIFFError(tif->tif_name,
  139.                 "Can not read TIFF directory count");
  140.             return (0);
  141.         }
  142.         if (tif->tif_flags & TIFF_SWAB)
  143.             TIFFSwabShort(&dircount);
  144.         dir = (TIFFDirEntry *)CheckMalloc(tif,
  145.             dircount * sizeof (TIFFDirEntry), "to read TIFF directory");
  146.         if (dir == NULL)
  147.             return (0);
  148.         if (!ReadOK(tif->tif_fd, dir, dircount*sizeof (TIFFDirEntry))) {
  149.             TIFFError(tif->tif_name, "Can not read TIFF directory");
  150.             goto bad;
  151.         }
  152.         /*
  153.          * Read offset to next directory for sequential scans.
  154.          */
  155.         if (!ReadOK(tif->tif_fd, &tif->tif_nextdiroff, sizeof (long)))
  156.             tif->tif_nextdiroff = 0;
  157. #ifdef MMAP_SUPPORT
  158.     } else {
  159.         off_t off = tif->tif_diroff;
  160.  
  161.         if (off + sizeof (short) > tif->tif_size) {
  162.             TIFFError(tif->tif_name,
  163.                 "Can not read TIFF directory count");
  164.             return (0);
  165.         } else
  166.             bcopy(tif->tif_base + off, &dircount, sizeof (short));
  167.         off += sizeof (short);
  168.         if (tif->tif_flags & TIFF_SWAB)
  169.             TIFFSwabShort(&dircount);
  170.         dir = (TIFFDirEntry *)CheckMalloc(tif,
  171.             dircount * sizeof (TIFFDirEntry), "to read TIFF directory");
  172.         if (dir == NULL)
  173.             return (0);
  174.         if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {
  175.             TIFFError(tif->tif_name, "Can not read TIFF directory");
  176.             goto bad;
  177.         } else
  178.             bcopy(tif->tif_base + off, dir,
  179.                 dircount*sizeof (TIFFDirEntry));
  180.         off += dircount* sizeof (TIFFDirEntry);
  181.         if (off + sizeof (long) < tif->tif_size)
  182.             bcopy(tif->tif_base + off, &tif->tif_nextdiroff,
  183.                 sizeof (long));
  184.         else
  185.             tif->tif_nextdiroff = 0;
  186. #endif
  187.     }
  188.     if (tif->tif_flags & TIFF_SWAB)
  189.         TIFFSwabLong((u_long *)&tif->tif_nextdiroff);
  190.  
  191.     tif->tif_flags &= ~TIFF_BEENWRITING;    /* reset before new dir */
  192.     /*
  193.      * Setup default value and then make a pass over
  194.      * the fields to check type and tag information,
  195.      * and to extract info required to size data
  196.      * structures.  A second pass is made afterwards
  197.      * to read in everthing not taken in the first pass.
  198.      */
  199.     td = &tif->tif_dir;
  200.     /* free any old stuff and reinit */
  201.     TIFFFreeDirectory(tif);
  202.     TIFFDefaultDirectory(tif);
  203.     /*
  204.      * Electronic Arts writes gray-scale TIFF files
  205.      * without a PlanarConfiguration directory entry.
  206.      * Thus we setup a default value here, even though
  207.      * the TIFF spec says there is no default value.
  208.      */
  209.     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  210.     for (fip = tiffFieldInfo, dp = dir, n = dircount; n > 0; n--, dp++) {
  211.         if (tif->tif_flags & TIFF_SWAB) {
  212.             TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
  213.             TIFFSwabArrayOfLong(&dp->tdir_count, 2);
  214.         }
  215.         /*
  216.          * Find the field information entry for this tag.
  217.          */
  218.         /*
  219.          * Silicon Beach (at least) writes unordered
  220.          * directory tags (violating the spec).  Handle
  221.          * it here, but be obnoxious (maybe they'll fix it?).
  222.          */
  223.         if (dp->tdir_tag < fip->field_tag) {
  224.             if (!diroutoforderwarning) {
  225.                 TIFFWarning(tif->tif_name,
  226.     "invalid TIFF directory; tags are not sorted in ascending order");
  227.                 diroutoforderwarning = 1;
  228.             }
  229.             fip = tiffFieldInfo;    /* O(n^2) */
  230.         }
  231.         while (fip->field_tag && fip->field_tag < dp->tdir_tag)
  232.             fip++;
  233.         if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {
  234.             TIFFWarning(tif->tif_name,
  235.                 "unknown field with tag %d (0x%x) ignored",
  236.                 dp->tdir_tag,  dp->tdir_tag);
  237.             dp->tdir_tag = IGNORE;
  238.             fip = tiffFieldInfo;    /* restart search */
  239.             continue;
  240.         }
  241.         /*
  242.          * Null out old tags that we ignore.
  243.          */
  244.         if (fip->field_bit == FIELD_IGNORE) {
  245.     ignore:
  246.             dp->tdir_tag = IGNORE;
  247.             continue;
  248.         }
  249.         /*
  250.          * Check data type.
  251.          */
  252.         while (dp->tdir_type != (u_short)fip->field_type) {
  253.             if (fip->field_type == TIFF_ANY)    /* wildcard */
  254.                 break;
  255.             fip++;
  256.             if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {
  257.                 TIFFWarning(tif->tif_name,
  258.                    "wrong data type %d for \"%s\"; tag ignored",
  259.                     dp->tdir_type, fip[-1].field_name);
  260.                 goto ignore;
  261.             }
  262.         }
  263.         /*
  264.          * Check count if known in advance.
  265.          */
  266.         if (fip->field_readcount != TIFF_VARIABLE) {
  267.             u_long expected = (fip->field_readcount == TIFF_SPP) ?
  268.                 (u_long) td->td_samplesperpixel :
  269.                 (u_long) fip->field_readcount;
  270.             if (!CheckDirCount(tif, dp, expected))
  271.                 goto ignore;
  272.         }
  273.  
  274.         switch (dp->tdir_tag) {
  275.         case TIFFTAG_STRIPOFFSETS:
  276.         case TIFFTAG_STRIPBYTECOUNTS:
  277.         case TIFFTAG_TILEOFFSETS:
  278.         case TIFFTAG_TILEBYTECOUNTS:
  279.             TIFFSetFieldBit(tif, fip->field_bit);
  280.             break;
  281.         case TIFFTAG_IMAGEWIDTH:
  282.         case TIFFTAG_IMAGELENGTH:
  283.         case TIFFTAG_IMAGEDEPTH:
  284.         case TIFFTAG_TILELENGTH:
  285.         case TIFFTAG_TILEWIDTH:
  286.         case TIFFTAG_TILEDEPTH:
  287.         case TIFFTAG_PLANARCONFIG:
  288.         case TIFFTAG_SAMPLESPERPIXEL:
  289.         case TIFFTAG_ROWSPERSTRIP:
  290.             if (!TIFFFetchNormalTag(tif, dp))
  291.                 goto bad;
  292.             break;
  293.         }
  294.     }
  295.  
  296.     /*
  297.      * Allocate directory structure and setup defaults.
  298.      */
  299.     if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
  300.         MissingRequired(tif, "ImageLength");
  301.         goto bad;
  302.     }
  303.     if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
  304.         MissingRequired(tif, "PlanarConfiguration");
  305.         goto bad;
  306.     }
  307.     /* 
  308.       * Setup appropriate structures (by strip or by tile)
  309.      */
  310.     if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  311.         td->td_stripsperimage = (td->td_rowsperstrip == 0xffffffff ?
  312.              (td->td_imagelength != 0 ? 1 : 0) :
  313.              howmany(td->td_imagelength, td->td_rowsperstrip));
  314.         td->td_tilewidth = td->td_imagewidth;
  315.         td->td_tilelength = td->td_rowsperstrip;
  316.         td->td_tiledepth = td->td_imagedepth;
  317.         tif->tif_flags &= ~TIFF_ISTILED;
  318.     } else {
  319.         td->td_stripsperimage = TIFFNumberOfTiles(tif);
  320.         tif->tif_flags |= TIFF_ISTILED;
  321.     }
  322.     td->td_nstrips = td->td_stripsperimage;
  323.     if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  324.         td->td_nstrips *= td->td_samplesperpixel;
  325.     if (td->td_nstrips > 0 && !TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
  326.         MissingRequired(tif,
  327.             isTiled(tif) ? "TileOffsets" : "StripOffsets");
  328.         goto bad;
  329.     }
  330.  
  331.     /*
  332.      * Second pass: extract other information.
  333.      */
  334.     for (dp = dir, n = dircount; n > 0; n--, dp++) {
  335.         if (dp->tdir_tag == IGNORE)
  336.             continue;
  337.         switch (dp->tdir_tag) {
  338.         case TIFFTAG_COMPRESSION:
  339.         case TIFFTAG_MINSAMPLEVALUE:
  340.         case TIFFTAG_MAXSAMPLEVALUE:
  341.         case TIFFTAG_BITSPERSAMPLE:
  342.             /*
  343.              * The 5.0 spec says the Compression tag has
  344.              * one value, while earlier specs say it has
  345.              * one value per sample.  Because of this, we
  346.              * accept the tag if one value is supplied.
  347.              *
  348.              * The MinSampleValue, MaxSampleValue and
  349.              * BitsPerSample tags are supposed to be written
  350.              * as one value/sample, but some vendors incorrectly
  351.              * write one value only -- so we accept that
  352.              * as well (yech).
  353.              */
  354.             if (dp->tdir_count == 1) {
  355.                 v = TIFFExtractData(tif,
  356.                     dp->tdir_type, dp->tdir_offset);
  357.                 if (!TIFFSetField(tif, dp->tdir_tag, (int)v))
  358.                     goto bad;
  359.                 break;
  360.             }
  361.             /* fall thru... */
  362.         case TIFFTAG_DATATYPE:
  363.         case TIFFTAG_SAMPLEFORMAT:
  364.             if (!TIFFFetchPerSampleShorts(tif, dp, &v) ||
  365.                 !TIFFSetField(tif, dp->tdir_tag, (int)v))
  366.                 goto bad;
  367.             break;
  368.         case TIFFTAG_STRIPOFFSETS:
  369.         case TIFFTAG_TILEOFFSETS:
  370.             if (!TIFFFetchStripThing(tif, dp,
  371.                 td->td_nstrips, &td->td_stripoffset))
  372.                 goto bad;
  373.             break;
  374.         case TIFFTAG_STRIPBYTECOUNTS:
  375.         case TIFFTAG_TILEBYTECOUNTS:
  376.             if (!TIFFFetchStripThing(tif, dp,
  377.                 td->td_nstrips, &td->td_stripbytecount))
  378.                 goto bad;
  379.             break;
  380.         case TIFFTAG_IMAGELENGTH:
  381.         case TIFFTAG_ROWSPERSTRIP:
  382.         case TIFFTAG_TILELENGTH:
  383.         case TIFFTAG_TILEWIDTH:
  384.         case TIFFTAG_TILEDEPTH:
  385.         case TIFFTAG_SAMPLESPERPIXEL:
  386.         case TIFFTAG_PLANARCONFIG:
  387.             /* handled in first pass above */
  388.             break;
  389.         case TIFFTAG_COLORMAP:
  390.             if (!CheckDirCount(tif,dp,3*(1L<<td->td_bitspersample)))
  391.                 break;
  392.             /* fall thru... */
  393.         case TIFFTAG_TRANSFERFUNCTION:
  394.             v = (1L<<td->td_bitspersample) * sizeof (u_short);
  395.             cp = CheckMalloc(tif,
  396.                 dp->tdir_count * sizeof (u_short),
  397.                 "to read \"TransferFunction\" tag");
  398.             if (cp != NULL) {
  399.                 if (TIFFFetchData(tif, dp, cp)) {
  400.                     /*
  401.                      * This deals with there being only
  402.                      * one array to apply to all samples.
  403.                      */
  404.                     if (dp->tdir_count == 1L<<td->td_bitspersample)
  405.                         v = 0;
  406.                     /* NB: we assume samples/pixel <= 4 */
  407.                     TIFFSetField(tif, dp->tdir_tag,
  408.                         cp, cp+v, cp+2*v, cp+3*v);
  409.                 }
  410.                 free(cp);
  411.             }
  412.             break;
  413.         case TIFFTAG_PAGENUMBER:
  414.             if (TIFFFetchShortArray(tif, dp, td->td_pagenumber))
  415.                 TIFFSetFieldBit(tif, FIELD_PAGENUMBER);
  416.             break;
  417.         case TIFFTAG_HALFTONEHINTS:
  418.             if (TIFFFetchShortArray(tif, dp, td->td_halftonehints))
  419.                 TIFFSetFieldBit(tif, FIELD_HALFTONEHINTS);
  420.             break;
  421. #ifdef COLORIMETRY_SUPPORT
  422.         case TIFFTAG_REFERENCEBLACKWHITE:
  423.             (void) TIFFFetchRefBlackWhite(tif, dp);
  424.             break;
  425. #endif
  426. #ifdef YCBCR_SUPPORT
  427.         case TIFFTAG_YCBCRSUBSAMPLING:
  428.             if (TIFFFetchShortArray(tif, dp, td->td_ycbcrsubsampling))
  429.                 TIFFSetFieldBit(tif, FIELD_YCBCRSUBSAMPLING);
  430.             break;
  431. #endif
  432. #ifdef CMYK_SUPPORT
  433.         case TIFFTAG_DOTRANGE:
  434.             if (TIFFFetchShortArray(tif, dp, td->td_dotrange))
  435.                 TIFFSetFieldBit(tif, FIELD_DOTRANGE);
  436.             break;
  437. #endif
  438. #ifdef JPEG_SUPPORT
  439.         case TIFFTAG_JPEGQTABLES:
  440.             if (TIFFFetchJPEGQTables(tif, dp))
  441.                 TIFFSetFieldBit(tif, FIELD_JPEGQTABLES);
  442.             break;
  443.         case TIFFTAG_JPEGDCTABLES:
  444.             if (TIFFFetchJPEGCTables(tif, dp, &td->td_dctab))
  445.                 TIFFSetFieldBit(tif, FIELD_JPEGDCTABLES);
  446.             break;
  447.         case TIFFTAG_JPEGACTABLES:
  448.             if (TIFFFetchJPEGCTables(tif, dp, &td->td_actab))
  449.                 TIFFSetFieldBit(tif, FIELD_JPEGACTABLES);
  450.             break;
  451. #endif
  452.         case TIFFTAG_EXTRASAMPLES:
  453.             (void) TIFFFetchExtraSamples(tif, dp);
  454.             break;
  455. /* BEGIN REV 4.0 COMPATIBILITY */
  456.         case TIFFTAG_OSUBFILETYPE:
  457.             v = 0;
  458.             switch (TIFFExtractData(tif, dp->tdir_type,
  459.                 dp->tdir_offset)) {
  460.             case OFILETYPE_REDUCEDIMAGE:
  461.                 v = FILETYPE_REDUCEDIMAGE;
  462.                 break;
  463.             case OFILETYPE_PAGE:
  464.                 v = FILETYPE_PAGE;
  465.                 break;
  466.             }
  467.             if (v)
  468.                 (void) TIFFSetField(tif,
  469.                     TIFFTAG_SUBFILETYPE, (int)v);
  470.             break;
  471. /* END REV 4.0 COMPATIBILITY */
  472.         default:
  473.             (void) TIFFFetchNormalTag(tif, dp);
  474.             break;
  475.         }
  476.     }
  477.     /*
  478.      * Verify Palette image has a Colormap.
  479.      */
  480.     if (td->td_photometric == PHOTOMETRIC_PALETTE &&
  481.         !TIFFFieldSet(tif, FIELD_COLORMAP)) {
  482.         MissingRequired(tif, "Colormap");
  483.         goto bad;
  484.     }
  485.     /*
  486.      * Attempt to deal with a missing StripByteCounts tag.
  487.      */
  488.     if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
  489.         /*
  490.          * Some manufacturers violate the spec by not giving
  491.          * the size of the strips.  In this case, assume there
  492.          * is one uncompressed strip of data.
  493.          */
  494.         if (td->td_nstrips > 1) {
  495.             MissingRequired(tif, "StripByteCounts");
  496.             goto bad;
  497.         }
  498.         TIFFWarning(tif->tif_name,
  499. "TIFF directory is missing required \"%s\" field, calculating from imagelength",
  500.             TIFFFieldWithTag(TIFFTAG_STRIPBYTECOUNTS)->field_name);
  501.         EstimateStripByteCounts(tif, dir, dircount);
  502.     } else if (td->td_nstrips == 1 && td->td_stripbytecount[0] == 0) {
  503.         /*
  504.          * Plexus (and others) sometimes give a value
  505.          * of zero for a tag when they don't know what
  506.          * the correct value is!  Try and handle the
  507.          * simple case of estimating the size of a one
  508.          * strip image.
  509.          */
  510.         TIFFWarning(tif->tif_name,
  511. "Bogus \"%s\" field, ignoring and calculating from imagelength",
  512.             TIFFFieldWithTag(TIFFTAG_STRIPBYTECOUNTS)->field_name);
  513.         EstimateStripByteCounts(tif, dir, dircount);
  514.     }
  515.     if (dir)
  516.         free((char *)dir);
  517.     if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
  518.         td->td_maxsamplevalue = (1L<<td->td_bitspersample)-1;
  519.     /*
  520.      * Setup default compression scheme.
  521.      */
  522.     if (!TIFFFieldSet(tif, FIELD_COMPRESSION))
  523.         TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  524.     /*
  525.      * Reinitialize i/o since we are starting on a new directory.
  526.      */
  527.     tif->tif_row = -1;
  528.     tif->tif_curstrip = -1;
  529.     tif->tif_col = -1;
  530.     tif->tif_curtile = -1;
  531.     tif->tif_tilesize = TIFFTileSize(tif);
  532.     tif->tif_scanlinesize = TIFFScanlineSize(tif);
  533.     return (1);
  534. bad:
  535.     if (dir)
  536.         free((char *)dir);
  537.     return (0);
  538. }
  539.  
  540. static
  541. EstimateStripByteCounts(tif, dir, dircount)
  542.     TIFF *tif;
  543.     TIFFDirEntry *dir;
  544.     u_int dircount;
  545. {
  546.     register TIFFDirEntry *dp;
  547.     register TIFFDirectory *td = &tif->tif_dir;
  548.     register int n;
  549.  
  550.     td->td_stripbytecount = (u_long *)
  551.         CheckMalloc(tif, sizeof (u_long), "for \"StripByteCounts\" array");
  552.     if (td->td_compression != COMPRESSION_NONE) {
  553.         u_long space = sizeof (TIFFHeader)
  554.             + sizeof (short)
  555.             + (dircount * sizeof (TIFFDirEntry))
  556.             + sizeof (long);
  557.         long filesize = TIFFGetFileSize(tif->tif_fd);
  558.         /* calculate amount of space used by indirect values */
  559.         for (dp = dir, n = dircount; n > 0; n--, dp++) {
  560.             int cc = dp->tdir_count * tiffDataWidth[dp->tdir_type];
  561.             if (cc > sizeof (long))
  562.                 space += cc;
  563.         }
  564.         td->td_stripbytecount[0] = filesize - space;
  565.         /*
  566.          * This gross hack handles the case were the offset to
  567.          * the strip is past the place where we think the strip
  568.          * should begin.  Since a strip of data must be contiguous,
  569.          * it's safe to assume that we've overestimated the amount
  570.          * of data in the strip and trim this number back accordingly.
  571.          */ 
  572.         if (td->td_stripoffset[0] + td->td_stripbytecount[0] > filesize)
  573.             td->td_stripbytecount[0] =
  574.                 filesize - td->td_stripoffset[0];
  575.     } else {
  576.         u_long rowbytes = howmany(td->td_bitspersample *
  577.             td->td_samplesperpixel * td->td_imagewidth, 8);
  578.         td->td_stripbytecount[0] = td->td_imagelength * rowbytes;
  579.     }
  580.     TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
  581.     if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
  582.         td->td_rowsperstrip = td->td_imagelength;
  583. }
  584.  
  585. static
  586. MissingRequired(tif, tagname)
  587.     TIFF *tif;
  588.     char *tagname;
  589. {
  590.     TIFFError(tif->tif_name,
  591.         "TIFF directory is missing required \"%s\" field", tagname);
  592. }
  593.  
  594. /*
  595.  * Check the count field of a directory
  596.  * entry against a known value.  The caller
  597.  * is expected to skip/ignore the tag if
  598.  * there is a mismatch.
  599.  */
  600. static
  601. CheckDirCount(tif, dir, count)
  602.     TIFF *tif;
  603.     TIFFDirEntry *dir;
  604.     u_long count;
  605. {
  606.     if (count != dir->tdir_count) {
  607.         TIFFWarning(tif->tif_name,
  608.     "incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored",
  609.             TIFFFieldWithTag(dir->tdir_tag)->field_name,
  610.             dir->tdir_count, count);
  611.         return (0);
  612.     }
  613.     return (1);
  614. }
  615.  
  616. /*
  617.  * Fetch a contiguous directory item.
  618.  */
  619. static
  620. TIFFFetchData(tif, dir, cp)
  621.     TIFF *tif;
  622.     TIFFDirEntry *dir;
  623.     char *cp;
  624. {
  625.     int cc, w;
  626.  
  627.     w = tiffDataWidth[dir->tdir_type];
  628.     cc = dir->tdir_count * w;
  629.     if (!isMapped(tif)) {
  630.         if (!SeekOK(tif->tif_fd, dir->tdir_offset))
  631.             goto bad;
  632.         if (!ReadOK(tif->tif_fd, cp, cc))
  633.             goto bad;
  634. #ifdef MMAP_SUPPORT
  635.     } else {
  636.         if (dir->tdir_offset + cc > tif->tif_size)
  637.             goto bad;
  638.         bcopy(tif->tif_base + dir->tdir_offset, cp, cc);
  639. #endif
  640.     }
  641.     if (tif->tif_flags & TIFF_SWAB) {
  642.         switch (dir->tdir_type) {
  643.         case TIFF_SHORT:
  644.         case TIFF_SSHORT:
  645.             TIFFSwabArrayOfShort((u_short *)cp, dir->tdir_count);
  646.             break;
  647.         case TIFF_LONG:
  648.         case TIFF_SLONG:
  649.         case TIFF_FLOAT:
  650.             TIFFSwabArrayOfLong((u_long *)cp, dir->tdir_count);
  651.             break;
  652.         case TIFF_RATIONAL:
  653.         case TIFF_SRATIONAL:
  654.             TIFFSwabArrayOfLong((u_long *)cp, 2*dir->tdir_count);
  655.             break;
  656.         }
  657.     }
  658.     return (cc);
  659. bad:
  660.     TIFFError(tif->tif_name, "Error fetching data for field \"%s\"",
  661.         TIFFFieldWithTag(dir->tdir_tag)->field_name);
  662.     return (0);
  663. }
  664.  
  665. /*
  666.  * Fetch an ASCII item from the file.
  667.  */
  668. static
  669. TIFFFetchString(tif, dir, cp)
  670.     TIFF *tif;
  671.     TIFFDirEntry *dir;
  672.     char *cp;
  673. {
  674.     if (dir->tdir_count <= 4) {
  675.         u_long l = dir->tdir_offset;
  676.         if (tif->tif_flags & TIFF_SWAB)
  677.             TIFFSwabLong(&l);
  678.         bcopy(&l, cp, dir->tdir_count);
  679.         return (1);
  680.     }
  681.     return (TIFFFetchData(tif, dir, cp));
  682. }
  683.  
  684. /*
  685.  * Convert numerator+denominator to float.
  686.  */
  687. static int
  688. cvtRational(tif, dir, num, denom, rv)
  689.     TIFF *tif;
  690.     TIFFDirEntry *dir;
  691.     u_long num, denom;
  692.     float *rv;
  693. {
  694.     if (denom == 0) {
  695.         TIFFError(tif->tif_name,
  696.             "%s: Rational with zero denominator (num = %lu)",
  697.             TIFFFieldWithTag(dir->tdir_tag)->field_name, num);
  698.         return (0);
  699.     } else {
  700.         if (dir->tdir_type == TIFF_RATIONAL)
  701.             *rv = ((float)num / (float)denom);
  702.         else
  703.             *rv = ((float)(long)num / (float)(long)denom);
  704.         return (1);
  705.     }
  706. }
  707.  
  708. /*
  709.  * Fetch a rational item from the file
  710.  * at offset off and return the value
  711.  * as a floating point number.
  712.  */
  713. static float
  714. TIFFFetchRational(tif, dir)
  715.     TIFF *tif;
  716.     TIFFDirEntry *dir;
  717. {
  718.     u_long l[2];
  719.     float v;
  720.  
  721.     return (!TIFFFetchData(tif, dir, (char *)l) ||
  722.         !cvtRational(tif, dir, l[0], l[1], &v) ? 1. : v);
  723. }
  724.  
  725. /*
  726.  * Fetch a single floating point value
  727.  * from the offset field and return it
  728.  * as a native float.
  729.  */
  730. static float
  731. TIFFFetchFloat(tif, dir)
  732.     TIFF *tif;
  733.     TIFFDirEntry *dir;
  734. {
  735.     float v = (float)
  736.         TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
  737.     TIFFCvtIEEEFloatToNative(tif, 1, &v);
  738.     return (v);
  739. }
  740.  
  741. /*
  742.  * Fetch an array of BYTE or SBYTE values.
  743.  */
  744. static
  745. TIFFFetchByteArray(tif, dir, v)
  746.     TIFF *tif;
  747.     TIFFDirEntry *dir;
  748.     u_short v[];
  749. {
  750.  
  751.     if (dir->tdir_count <= 4) {
  752.         /*
  753.          * Extract data from offset field.
  754.          */
  755.         if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
  756.             switch (dir->tdir_count) {
  757.             case 4: v[3] = dir->tdir_offset & 0xff;
  758.             case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
  759.             case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
  760.             case 1: v[0] = dir->tdir_offset >> 24;
  761.             }
  762.         } else {
  763.             switch (dir->tdir_count) {
  764.             case 4: v[3] = dir->tdir_offset >> 24;
  765.             case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
  766.             case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
  767.             case 1: v[0] = dir->tdir_offset & 0xff;
  768.             }
  769.         }
  770.         return (1);
  771.     } else
  772.         return (TIFFFetchData(tif, dir, (char *)v));    /* XXX */
  773. }
  774.  
  775. /*
  776.  * Fetch an array of SHORT or SSHORT values.
  777.  */
  778. static
  779. TIFFFetchShortArray(tif, dir, v)
  780.     TIFF *tif;
  781.     TIFFDirEntry *dir;
  782.     u_short v[];
  783. {
  784.     if (dir->tdir_count <= 2) {
  785.         if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
  786.             switch (dir->tdir_count) {
  787.             case 2: v[1] = dir->tdir_offset & 0xffff;
  788.             case 1: v[0] = dir->tdir_offset >> 16;
  789.             }
  790.         } else {
  791.             switch (dir->tdir_count) {
  792.             case 2: v[1] = dir->tdir_offset >> 16;
  793.             case 1: v[0] = dir->tdir_offset & 0xffff;
  794.             }
  795.         }
  796.         return (1);
  797.     } else
  798.         return (TIFFFetchData(tif, dir, (char *)v));
  799. }
  800.  
  801. /*
  802.  * Fetch an array of LONG or SLONG values.
  803.  */
  804. static
  805. TIFFFetchLongArray(tif, dir, v)
  806.     TIFF *tif;
  807.     TIFFDirEntry *dir;
  808.     u_long v[];
  809. {
  810.     if (dir->tdir_count == 1) {
  811.         v[0] = dir->tdir_offset;
  812.         return (1);
  813.     } else
  814.         return (TIFFFetchData(tif, dir, (char *)v));
  815. }
  816.  
  817. /*
  818.  * Fetch an array of RATIONAL or SRATIONAL values.
  819.  */
  820. static
  821. TIFFFetchRationalArray(tif, dir, v)
  822.     TIFF *tif;
  823.     TIFFDirEntry *dir;
  824.     float v[];
  825. {
  826.     int ok = 0;
  827.     u_long *l;
  828.  
  829.     l = (u_long *)CheckMalloc(tif,
  830.         dir->tdir_count*tiffDataWidth[dir->tdir_type],
  831.         "to fetch array of rationals");
  832.     if (l) {
  833.         if (TIFFFetchData(tif, dir, (char *)l)) {
  834.             u_long i;
  835.             for (i = 0; i < dir->tdir_count; i++) {
  836.                 ok = cvtRational(tif, dir,
  837.                     l[2*i+0], l[2*i+1], &v[i]);
  838.                 if (!ok)
  839.                     break;
  840.             }
  841.         }
  842.         free((char *)l);
  843.     }
  844.     return (ok);
  845. }
  846.  
  847. /*
  848.  * Fetch an array of FLOAT values.
  849.  */
  850. static
  851. TIFFFetchFloatArray(tif, dir, v)
  852.     TIFF *tif;
  853.     TIFFDirEntry *dir;
  854.     float v[];
  855. {
  856.     if (TIFFFetchData(tif, dir, (char *)v)) {
  857.         TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
  858.         return (1);
  859.     } else
  860.         return (0);
  861. }
  862.  
  863. /*
  864.  * Fetch a tag that is not handled by special case code.
  865.  *
  866.  * NB: DOUBLE and UNDEFINED types are not handled.
  867.  */
  868. static
  869. TIFFFetchNormalTag(tif, dp)
  870.     TIFF *tif;
  871.     TIFFDirEntry *dp;
  872. {
  873.     static char mesg[] = "to fetch tag value";
  874.     int ok = 0;
  875.  
  876.     if (dp->tdir_count > 1) {        /* array of values */
  877.         char *cp = NULL;
  878.  
  879.         switch (dp->tdir_type) {
  880.         case TIFF_BYTE:
  881.         case TIFF_SBYTE:
  882.             /* NB: always expand BYTE values to shorts */
  883.             cp = CheckMalloc(tif,
  884.                 dp->tdir_count * sizeof (u_short), mesg);
  885.             ok = cp && TIFFFetchByteArray(tif, dp, (u_short *)cp);
  886.             break;
  887.         case TIFF_SHORT:
  888.         case TIFF_SSHORT:
  889.             cp = CheckMalloc(tif,
  890.                 dp->tdir_count * sizeof (u_short), mesg);
  891.             ok = cp && TIFFFetchShortArray(tif, dp, (u_short *)cp);
  892.             break;
  893.         case TIFF_LONG:
  894.         case TIFF_SLONG:
  895.             cp = CheckMalloc(tif,
  896.                 dp->tdir_count * sizeof (u_long), mesg);
  897.             ok = cp && TIFFFetchLongArray(tif, dp, (u_long *)cp);
  898.             break;
  899.         case TIFF_RATIONAL:
  900.         case TIFF_SRATIONAL:
  901.             cp = CheckMalloc(tif,
  902.                 dp->tdir_count * sizeof (float), mesg);
  903.             ok = cp && TIFFFetchRationalArray(tif, dp, (float *)cp);
  904.             break;
  905.         case TIFF_FLOAT:
  906.             cp = CheckMalloc(tif,
  907.                 dp->tdir_count * sizeof (float), mesg);
  908.             ok = cp && TIFFFetchFloatArray(tif, dp, (float *)cp);
  909.             break;
  910.         case TIFF_ASCII:
  911.             /*
  912.              * Some vendors write strings w/o the trailing
  913.              * NULL byte, so always append one just in case.
  914.              */
  915.             cp = CheckMalloc(tif, dp->tdir_count+1, mesg);
  916.             if (ok = (cp && TIFFFetchString(tif, dp, cp)))
  917.                 cp[dp->tdir_count] = '\0';    /* XXX */
  918.             break;
  919.         }
  920.         if (ok)
  921.             ok = TIFFSetField(tif, dp->tdir_tag, cp);
  922.         if (cp != NULL)
  923.             free(cp);
  924.     } else if (CheckDirCount(tif, dp, 1)) {    /* singleton value */
  925.         char c[2];
  926.         switch (dp->tdir_type) {
  927.         case TIFF_BYTE:
  928.         case TIFF_SBYTE:
  929.         case TIFF_SHORT:
  930.         case TIFF_SSHORT:
  931.             ok = TIFFSetField(tif, dp->tdir_tag, (int)
  932.           TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset));
  933.             break;
  934.         case TIFF_LONG:
  935.         case TIFF_SLONG:
  936.             ok = TIFFSetField(tif, dp->tdir_tag, (u_long)
  937.           TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset));
  938.             break;
  939.         case TIFF_RATIONAL:
  940.         case TIFF_SRATIONAL:
  941.             ok = TIFFSetField(tif, dp->tdir_tag,
  942.                 TIFFFetchRational(tif, dp));
  943.             break;
  944.         case TIFF_FLOAT:
  945.             ok = TIFFSetField(tif, dp->tdir_tag,
  946.                 TIFFFetchFloat(tif, dp));
  947.             break;
  948.         case TIFF_ASCII:
  949.             if (ok = (TIFFFetchString(tif, dp, c))) {
  950.                 c[1] = '\0';        /* XXX paranoid */
  951.                 ok = TIFFSetField(tif, dp->tdir_tag, c);
  952.             }
  953.             break;
  954.         }
  955.     }
  956.     return (ok);
  957. }
  958.  
  959. /*
  960.  * Fetch samples/pixel short values for 
  961.  * the specified tag and verify that
  962.  * all values are the same.
  963.  */
  964. static
  965. TIFFFetchPerSampleShorts(tif, dir, pl)
  966.     TIFF *tif;
  967.     TIFFDirEntry *dir;
  968.     long *pl;
  969. {
  970.     u_short v[4];
  971.     int samples = tif->tif_dir.td_samplesperpixel;
  972.  
  973.     if (CheckDirCount(tif, dir, (u_long)samples) &&
  974.         TIFFFetchShortArray(tif, dir, v)) {
  975.         int i;
  976.         for (i = 1; i < samples; i++)
  977.             if (v[i] != v[0]) {
  978.                 TIFFError(tif->tif_name,
  979.         "Cannot handle different per-sample values for field \"%s\"",
  980.                    TIFFFieldWithTag(dir->tdir_tag)->field_name);
  981.                 return (0);
  982.             }
  983.         *pl = v[0];
  984.         return (1);
  985.     }
  986.     return (0);
  987. }
  988.  
  989. /*
  990.  * Fetch a set of offsets or lengths.
  991.  * While this routine says "strips",
  992.  * in fact it's also used for tiles.
  993.  */
  994. static
  995. TIFFFetchStripThing(tif, dir, nstrips, lpp)
  996.     TIFF *tif;
  997.     TIFFDirEntry *dir;
  998.     long nstrips;
  999.     u_long **lpp;
  1000. {
  1001.     register u_long *lp;
  1002.     int status;
  1003.  
  1004.     if (!CheckDirCount(tif, dir, nstrips))
  1005.         return (0);
  1006.     /*
  1007.      * Allocate space for strip information.
  1008.      */
  1009.     if (*lpp == NULL &&
  1010.         (*lpp = (u_long *)CheckMalloc(tif,
  1011.           nstrips * sizeof (u_long), "for strip array")) == NULL)
  1012.         return (0);
  1013.     lp = *lpp;
  1014.     if (dir->tdir_type == (int)TIFF_SHORT) {
  1015.         /*
  1016.          * Handle short->long expansion.
  1017.          */
  1018.         u_short *dp = (u_short *)CheckMalloc(tif,
  1019.             dir->tdir_count* sizeof (u_short), "to fetch strip tag");
  1020.         if (dp == NULL)
  1021.             return (0);
  1022.         if (status = TIFFFetchShortArray(tif, dir, dp)) {
  1023.             register u_short *wp = dp;
  1024.             while (nstrips-- > 0)
  1025.                 *lp++ = *wp++;
  1026.         }
  1027.         free((char *)dp);
  1028.     } else
  1029.         status = TIFFFetchLongArray(tif, dir, lp);
  1030.     return (status);
  1031. }
  1032.  
  1033. #ifdef COLORIMETRY_SUPPORT
  1034. static
  1035. TIFFFetchRefBlackWhite(tif, dir)
  1036.     TIFF *tif;
  1037.     TIFFDirEntry *dir;
  1038. {
  1039.     static char mesg[] = "for \"ReferenceBlackWhite\" array";
  1040.     char *cp;
  1041.     int ok;
  1042.  
  1043.     if (!CheckDirCount(tif, dir, 2*tif->tif_dir.td_samplesperpixel))
  1044.         return (0);
  1045.     if (dir->tdir_type == TIFF_RATIONAL)
  1046.         return (TIFFFetchNormalTag(tif, dir));
  1047.     /*
  1048.      * Handle LONG's for backward compatibility.
  1049.      */
  1050.     cp = CheckMalloc(tif, dir->tdir_count * sizeof (u_long), mesg);
  1051.     if (ok = (cp && TIFFFetchLongArray(tif, dir, (u_long *)cp))) {
  1052.         float *fp = (float *)
  1053.             CheckMalloc(tif, dir->tdir_count * sizeof (float), mesg);
  1054.         if (ok = (fp != NULL)) {
  1055.             int i;
  1056.             for (i = 0; i < dir->tdir_count; i++)
  1057.                 fp[i] = (float)((u_long *)cp)[i];
  1058.             ok = TIFFSetField(tif, dir->tdir_tag, fp);
  1059.             free((char *)fp);
  1060.         }
  1061.     }
  1062.     if (cp)
  1063.         free(cp);
  1064.     return (ok);
  1065. }
  1066. #endif
  1067.  
  1068. #ifdef JPEG_SUPPORT
  1069. /*
  1070.  * Fetch the JPEG Quantization tables
  1071.  * for the specified directory entry.
  1072.  * Storage for the td_qtab array is
  1073.  * allocated as a side effect.
  1074.  */
  1075. static
  1076. TIFFFetchJPEGQTables(tif, dir)
  1077.     TIFF *tif;
  1078.     TIFFDirEntry *dir;
  1079. {
  1080.     TIFFDirectory *td = &tif->tif_dir;
  1081.     long off[4];
  1082.     int i, j;
  1083.     TIFFDirEntry tdir;
  1084.     char *qmat;
  1085.  
  1086.     if (dir->tdir_count > 1) {
  1087.         /* XXX verify count <= 4 */
  1088.         if (!TIFFFetchData(tif, dir, (char *)off))
  1089.             return (0);
  1090.     } else
  1091.         off[0] = dir->tdir_offset;
  1092.     /*
  1093.      * We don't share per-component q matrices because
  1094.      * (besides complicating this logic even more), it
  1095.      * would make it very painful if the user does a ``set''.
  1096.      */
  1097.     td->td_qtab = (u_char **)CheckMalloc(tif,
  1098.         dir->tdir_count*(sizeof (u_char *) + 64*sizeof (u_char)),
  1099.         "for JPEG Q table");
  1100.     if (td->td_qtab == NULL)
  1101.         return (0);
  1102.     tdir.tdir_type = TIFF_BYTE;
  1103.     tdir.tdir_count = 64;
  1104.     qmat = (((char *)td->td_qtab) + dir->tdir_count*sizeof (u_char *));
  1105.     for (i = 0; i < dir->tdir_count; i++) {
  1106.         td->td_qtab[i] = (u_char *)qmat;
  1107.         tdir.tdir_offset = off[i];
  1108.         if (!TIFFFetchData(tif, &tdir, qmat))
  1109.             return (0);
  1110.         qmat += 64*sizeof (u_char);
  1111.     }
  1112.     return (1);
  1113. }
  1114.  
  1115. /*
  1116.  * Fetch JPEG Huffman code tables for the
  1117.  * specified directory entry.  Storage for
  1118.  * the tables are allocated as a side effect.
  1119.  */
  1120. static
  1121. TIFFFetchJPEGCTables(tif, dir, ptab)
  1122.     TIFF *tif;
  1123.     TIFFDirEntry *dir;
  1124.     u_char ***ptab;
  1125. {
  1126.     long off[4];
  1127.     int i, j, ncodes;
  1128.     TIFFDirEntry tdir;
  1129.     char *tab;
  1130.  
  1131.     if (dir->tdir_count > 1) {
  1132.         /* XXX verify count <= 4 */
  1133.         if (!TIFFFetchData(tif, dir, (char *)off))
  1134.             return (0);
  1135.     } else
  1136.         off[0] = dir->tdir_offset;
  1137.     /*
  1138.      * We don't share per-component tables because
  1139.      * (besides complicating this logic even more), it
  1140.      * would make it very painful if the user does a
  1141.      * ``set''.  Note also that we don't try to optimize
  1142.      * storage of the tables -- we just allocate enough
  1143.      * space to hold the largest possible.  All this
  1144.      * stuff is so complicated 'cuz the tag is defined
  1145.      * to be compatible with the JPEG table format,
  1146.      * rather than something that fits well into the
  1147.      * structure of TIFF -- argh!
  1148.      */
  1149.     *ptab = (u_char **)CheckMalloc(tif, dir->tdir_count*
  1150.         (sizeof (u_char *) + (16+256)*sizeof (u_char)),
  1151.         "for JPEG Huffman table");
  1152.     if (*ptab == NULL)
  1153.         return (0);
  1154.     tdir.tdir_type = TIFF_BYTE;
  1155.     tab = (((char *)*ptab) + dir->tdir_count*sizeof (u_char *));
  1156.     for (i = 0; i < dir->tdir_count; i++) {
  1157.         (*ptab)[i] = (u_char *)tab;
  1158.         tdir.tdir_offset = off[i];
  1159.         tdir.tdir_count = 16;
  1160.         /*
  1161.          * We must fetch the array that holds the
  1162.          * count of codes for each bit length first
  1163.          * and the count up the number of codes that
  1164.          * are in the variable length table.  This
  1165.          * information is implicit in the JPEG format
  1166.          * 'cuz it's preceded by a length field.
  1167.          */
  1168.         if (!TIFFFetchData(tif, &tdir, tab))    /* count array */
  1169.             return (0);
  1170.         for (ncodes = 0, j = 0; j < 16; j++)
  1171.             ncodes += tab[j];
  1172.         /*
  1173.          * Adjust offsets and fetch codes separately.
  1174.          */
  1175.         tdir.tdir_offset += 16;
  1176.         tdir.tdir_count = ncodes;
  1177.         tab += 16;
  1178.         if (!TIFFFetchData(tif, &tdir, tab))
  1179.             return (0);
  1180.         tab += ncodes;
  1181.     }
  1182.     return (1);
  1183. }
  1184. #endif
  1185.  
  1186. /*
  1187.  * Accept matteing-only ExtraSamples tag.
  1188.  */
  1189. static
  1190. TIFFFetchExtraSamples(tif, dp)
  1191.     TIFF *tif;
  1192.     TIFFDirEntry *dp;
  1193. {
  1194.     int type;
  1195.     
  1196.     if (dp->tdir_count != 1) {
  1197.         TIFFError(tif->tif_name,
  1198.             "Can not handle more than 1 extra sample/pixel");
  1199.         return (0);
  1200.     }
  1201.     type = TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
  1202.     if (type != EXTRASAMPLE_ASSOCALPHA) {
  1203.         TIFFError(tif->tif_name,
  1204.             "Can only handle associated-alpha extra samples");
  1205.         return (0);
  1206.     }
  1207.     return (TIFFSetField(tif, TIFFTAG_MATTEING, 1));
  1208. }
  1209.