home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / tiff / tif_dirinfo.c < prev    next >
C/C++ Source or Header  |  2000-02-16  |  15KB  |  387 lines
  1. /* $Header: /home/wxcvs/wxWindows/src/tiff/tif_dirinfo.c,v 1.2 2000/02/16 06:26:12 DW 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.  * Core Directory Tag Support.
  31.  */
  32. #include "tiffiop.h"
  33. #include <stdlib.h>
  34.  
  35. /*
  36.  * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
  37.  *     If a tag can have both LONG and SHORT types
  38.  *     then the LONG must be placed before the SHORT for
  39.  *     writing to work properly.
  40.  */
  41. static const TIFFFieldInfo tiffFieldInfo[] = {
  42.     { TIFFTAG_SUBFILETYPE,     1, 1, TIFF_LONG,    FIELD_SUBFILETYPE,
  43.       TRUE,    FALSE,    "SubfileType" },
  44. /* XXX SHORT for compatibility w/ old versions of the library */
  45.     { TIFFTAG_SUBFILETYPE,     1, 1, TIFF_SHORT,    FIELD_SUBFILETYPE,
  46.       TRUE,    FALSE,    "SubfileType" },
  47.     { TIFFTAG_OSUBFILETYPE,     1, 1, TIFF_SHORT,    FIELD_SUBFILETYPE,
  48.       TRUE,    FALSE,    "OldSubfileType" },
  49.     { TIFFTAG_IMAGEWIDTH,     1, 1, TIFF_LONG,    FIELD_IMAGEDIMENSIONS,
  50.       FALSE,    FALSE,    "ImageWidth" },
  51.     { TIFFTAG_IMAGEWIDTH,     1, 1, TIFF_SHORT,    FIELD_IMAGEDIMENSIONS,
  52.       FALSE,    FALSE,    "ImageWidth" },
  53.     { TIFFTAG_IMAGELENGTH,     1, 1, TIFF_LONG,    FIELD_IMAGEDIMENSIONS,
  54.       TRUE,    FALSE,    "ImageLength" },
  55.     { TIFFTAG_IMAGELENGTH,     1, 1, TIFF_SHORT,    FIELD_IMAGEDIMENSIONS,
  56.       TRUE,    FALSE,    "ImageLength" },
  57.     { TIFFTAG_BITSPERSAMPLE,    -1,-1, TIFF_SHORT,    FIELD_BITSPERSAMPLE,
  58.       FALSE,    FALSE,    "BitsPerSample" },
  59.     { TIFFTAG_COMPRESSION,    -1, 1, TIFF_SHORT,    FIELD_COMPRESSION,
  60.       FALSE,    FALSE,    "Compression" },
  61.     { TIFFTAG_PHOTOMETRIC,     1, 1, TIFF_SHORT,    FIELD_PHOTOMETRIC,
  62.       FALSE,    FALSE,    "PhotometricInterpretation" },
  63.     { TIFFTAG_THRESHHOLDING,     1, 1, TIFF_SHORT,    FIELD_THRESHHOLDING,
  64.       TRUE,    FALSE,    "Threshholding" },
  65.     { TIFFTAG_CELLWIDTH,     1, 1, TIFF_SHORT,    FIELD_IGNORE,
  66.       TRUE,    FALSE,    "CellWidth" },
  67.     { TIFFTAG_CELLLENGTH,     1, 1, TIFF_SHORT,    FIELD_IGNORE,
  68.       TRUE,    FALSE,    "CellLength" },
  69.     { TIFFTAG_FILLORDER,     1, 1, TIFF_SHORT,    FIELD_FILLORDER,
  70.       FALSE,    FALSE,    "FillOrder" },
  71.     { TIFFTAG_DOCUMENTNAME,    -1,-1, TIFF_ASCII,    FIELD_DOCUMENTNAME,
  72.       TRUE,    FALSE,    "DocumentName" },
  73.     { TIFFTAG_IMAGEDESCRIPTION,    -1,-1, TIFF_ASCII,    FIELD_IMAGEDESCRIPTION,
  74.       TRUE,    FALSE,    "ImageDescription" },
  75.     { TIFFTAG_MAKE,        -1,-1, TIFF_ASCII,    FIELD_MAKE,
  76.       TRUE,    FALSE,    "Make" },
  77.     { TIFFTAG_MODEL,        -1,-1, TIFF_ASCII,    FIELD_MODEL,
  78.       TRUE,    FALSE,    "Model" },
  79.     { TIFFTAG_STRIPOFFSETS,    -1,-1, TIFF_LONG,    FIELD_STRIPOFFSETS,
  80.       FALSE,    FALSE,    "StripOffsets" },
  81.     { TIFFTAG_STRIPOFFSETS,    -1,-1, TIFF_SHORT,    FIELD_STRIPOFFSETS,
  82.       FALSE,    FALSE,    "StripOffsets" },
  83.     { TIFFTAG_ORIENTATION,     1, 1, TIFF_SHORT,    FIELD_ORIENTATION,
  84.       FALSE,    FALSE,    "Orientation" },
  85.     { TIFFTAG_SAMPLESPERPIXEL,     1, 1, TIFF_SHORT,    FIELD_SAMPLESPERPIXEL,
  86.       FALSE,    FALSE,    "SamplesPerPixel" },
  87.     { TIFFTAG_ROWSPERSTRIP,     1, 1, TIFF_LONG,    FIELD_ROWSPERSTRIP,
  88.       FALSE,    FALSE,    "RowsPerStrip" },
  89.     { TIFFTAG_ROWSPERSTRIP,     1, 1, TIFF_SHORT,    FIELD_ROWSPERSTRIP,
  90.       FALSE,    FALSE,    "RowsPerStrip" },
  91.     { TIFFTAG_STRIPBYTECOUNTS,    -1,-1, TIFF_LONG,    FIELD_STRIPBYTECOUNTS,
  92.       FALSE,    FALSE,    "StripByteCounts" },
  93.     { TIFFTAG_STRIPBYTECOUNTS,    -1,-1, TIFF_SHORT,    FIELD_STRIPBYTECOUNTS,
  94.       FALSE,    FALSE,    "StripByteCounts" },
  95.     { TIFFTAG_MINSAMPLEVALUE,    -2,-1, TIFF_SHORT,    FIELD_MINSAMPLEVALUE,
  96.       TRUE,    FALSE,    "MinSampleValue" },
  97.     { TIFFTAG_MAXSAMPLEVALUE,    -2,-1, TIFF_SHORT,    FIELD_MAXSAMPLEVALUE,
  98.       TRUE,    FALSE,    "MaxSampleValue" },
  99.     { TIFFTAG_XRESOLUTION,     1, 1, TIFF_RATIONAL,    FIELD_RESOLUTION,
  100.       FALSE,    FALSE,    "XResolution" },
  101.     { TIFFTAG_YRESOLUTION,     1, 1, TIFF_RATIONAL,    FIELD_RESOLUTION,
  102.       FALSE,    FALSE,    "YResolution" },
  103.     { TIFFTAG_PLANARCONFIG,     1, 1, TIFF_SHORT,    FIELD_PLANARCONFIG,
  104.       FALSE,    FALSE,    "PlanarConfiguration" },
  105.     { TIFFTAG_PAGENAME,        -1,-1, TIFF_ASCII,    FIELD_PAGENAME,
  106.       TRUE,    FALSE,    "PageName" },
  107.     { TIFFTAG_XPOSITION,     1, 1, TIFF_RATIONAL,    FIELD_POSITION,
  108.       TRUE,    FALSE,    "XPosition" },
  109.     { TIFFTAG_YPOSITION,     1, 1, TIFF_RATIONAL,    FIELD_POSITION,
  110.       TRUE,    FALSE,    "YPosition" },
  111.     { TIFFTAG_FREEOFFSETS,    -1,-1, TIFF_LONG,    FIELD_IGNORE,
  112.       FALSE,    FALSE,    "FreeOffsets" },
  113.     { TIFFTAG_FREEBYTECOUNTS,    -1,-1, TIFF_LONG,    FIELD_IGNORE,
  114.       FALSE,    FALSE,    "FreeByteCounts" },
  115.     { TIFFTAG_GRAYRESPONSEUNIT,     1, 1, TIFF_SHORT,    FIELD_IGNORE,
  116.       TRUE,    FALSE,    "GrayResponseUnit" },
  117.     { TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT,    FIELD_IGNORE,
  118.       TRUE,    FALSE,    "GrayResponseCurve" },
  119.     { TIFFTAG_RESOLUTIONUNIT,     1, 1, TIFF_SHORT,    FIELD_RESOLUTIONUNIT,
  120.       FALSE,    FALSE,    "ResolutionUnit" },
  121.     { TIFFTAG_PAGENUMBER,     2, 2, TIFF_SHORT,    FIELD_PAGENUMBER,
  122.       TRUE,    FALSE,    "PageNumber" },
  123.     { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT,    FIELD_IGNORE,
  124.       TRUE,    FALSE,    "ColorResponseUnit" },
  125. #ifdef COLORIMETRY_SUPPORT
  126.     { TIFFTAG_TRANSFERFUNCTION,    -1,-1, TIFF_SHORT,    FIELD_TRANSFERFUNCTION,
  127.       TRUE,    FALSE,    "TransferFunction" },
  128. #endif
  129.     { TIFFTAG_SOFTWARE,        -1,-1, TIFF_ASCII,    FIELD_SOFTWARE,
  130.       TRUE,    FALSE,    "Software" },
  131.     { TIFFTAG_DATETIME,        20,20, TIFF_ASCII,    FIELD_DATETIME,
  132.       TRUE,    FALSE,    "DateTime" },
  133.     { TIFFTAG_ARTIST,        -1,-1, TIFF_ASCII,    FIELD_ARTIST,
  134.       TRUE,    FALSE,    "Artist" },
  135.     { TIFFTAG_HOSTCOMPUTER,    -1,-1, TIFF_ASCII,    FIELD_HOSTCOMPUTER,
  136.       TRUE,    FALSE,    "HostComputer" },
  137. #ifdef COLORIMETRY_SUPPORT
  138.     { TIFFTAG_WHITEPOINT,     2, 2, TIFF_RATIONAL,FIELD_WHITEPOINT,
  139.       TRUE,    FALSE,    "WhitePoint" },
  140.     { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,FIELD_PRIMARYCHROMAS,
  141.       TRUE,    FALSE,    "PrimaryChromaticities" },
  142. #endif
  143.     { TIFFTAG_COLORMAP,        -1,-1, TIFF_SHORT,    FIELD_COLORMAP,
  144.       TRUE,    FALSE,    "ColorMap" },
  145.     { TIFFTAG_HALFTONEHINTS,     2, 2, TIFF_SHORT,    FIELD_HALFTONEHINTS,
  146.       TRUE,    FALSE,    "HalftoneHints" },
  147.     { TIFFTAG_TILEWIDTH,     1, 1, TIFF_LONG,    FIELD_TILEDIMENSIONS,
  148.       FALSE,    FALSE,    "TileWidth" },
  149.     { TIFFTAG_TILEWIDTH,     1, 1, TIFF_SHORT,    FIELD_TILEDIMENSIONS,
  150.       FALSE,    FALSE,    "TileWidth" },
  151.     { TIFFTAG_TILELENGTH,     1, 1, TIFF_LONG,    FIELD_TILEDIMENSIONS,
  152.       FALSE,    FALSE,    "TileLength" },
  153.     { TIFFTAG_TILELENGTH,     1, 1, TIFF_SHORT,    FIELD_TILEDIMENSIONS,
  154.       FALSE,    FALSE,    "TileLength" },
  155.     { TIFFTAG_TILEOFFSETS,    -1, 1, TIFF_LONG,    FIELD_STRIPOFFSETS,
  156.       FALSE,    FALSE,    "TileOffsets" },
  157.     { TIFFTAG_TILEBYTECOUNTS,    -1, 1, TIFF_LONG,    FIELD_STRIPBYTECOUNTS,
  158.       FALSE,    FALSE,    "TileByteCounts" },
  159.     { TIFFTAG_TILEBYTECOUNTS,    -1, 1, TIFF_SHORT,    FIELD_STRIPBYTECOUNTS,
  160.       FALSE,    FALSE,    "TileByteCounts" },
  161. #ifdef TIFFTAG_SUBIFD
  162.     { TIFFTAG_SUBIFD,        -1,-1, TIFF_LONG,    FIELD_SUBIFD,
  163.       TRUE,    TRUE,    "SubIFD" },
  164. #endif
  165. #ifdef CMYK_SUPPORT        /* 6.0 CMYK tags */
  166.     { TIFFTAG_INKSET,         1, 1, TIFF_SHORT,    FIELD_INKSET,
  167.       FALSE,    FALSE,    "InkSet" },
  168.     { TIFFTAG_INKNAMES,        -1,-1, TIFF_ASCII,    FIELD_INKNAMES,
  169.       TRUE,    TRUE,    "InkNames" },
  170.     { TIFFTAG_NUMBEROFINKS,     1, 1, TIFF_SHORT,    FIELD_NUMBEROFINKS,
  171.       TRUE,    FALSE,    "NumberOfInks" },
  172.     { TIFFTAG_DOTRANGE,         2, 2, TIFF_SHORT,    FIELD_DOTRANGE,
  173.       FALSE,    FALSE,    "DotRange" },
  174.     { TIFFTAG_DOTRANGE,         2, 2, TIFF_BYTE,    FIELD_DOTRANGE,
  175.       FALSE,    FALSE,    "DotRange" },
  176.     { TIFFTAG_TARGETPRINTER,    -1,-1, TIFF_ASCII,    FIELD_TARGETPRINTER,
  177.       TRUE,    FALSE,    "TargetPrinter" },
  178. #endif
  179.     { TIFFTAG_EXTRASAMPLES,    -1,-1, TIFF_SHORT,    FIELD_EXTRASAMPLES,
  180.       FALSE,    FALSE,    "ExtraSamples" },
  181. /* XXX for bogus Adobe Photoshop v2.5 files */
  182.     { TIFFTAG_EXTRASAMPLES,    -1,-1, TIFF_BYTE,    FIELD_EXTRASAMPLES,
  183.       FALSE,    FALSE,    "ExtraSamples" },
  184.     { TIFFTAG_SAMPLEFORMAT,    -1,-1, TIFF_SHORT,    FIELD_SAMPLEFORMAT,
  185.       FALSE,    FALSE,    "SampleFormat" },
  186.     { TIFFTAG_SMINSAMPLEVALUE,    -2,-1, TIFF_ANY,    FIELD_SMINSAMPLEVALUE,
  187.       TRUE,    FALSE,    "SMinSampleValue" },
  188.     { TIFFTAG_SMAXSAMPLEVALUE,    -2,-1, TIFF_ANY,    FIELD_SMAXSAMPLEVALUE,
  189.       TRUE,    FALSE,    "SMaxSampleValue" },
  190. #ifdef YCBCR_SUPPORT        /* 6.0 YCbCr tags */
  191.     { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL,    FIELD_YCBCRCOEFFICIENTS,
  192.       FALSE,    FALSE,    "YCbCrCoefficients" },
  193.     { TIFFTAG_YCBCRSUBSAMPLING,     2, 2, TIFF_SHORT,    FIELD_YCBCRSUBSAMPLING,
  194.       FALSE,    FALSE,    "YCbCrSubsampling" },
  195.     { TIFFTAG_YCBCRPOSITIONING,     1, 1, TIFF_SHORT,    FIELD_YCBCRPOSITIONING,
  196.       FALSE,    FALSE,    "YCbCrPositioning" },
  197. #endif
  198. #ifdef COLORIMETRY_SUPPORT
  199.     { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL,    FIELD_REFBLACKWHITE,
  200.       TRUE,    FALSE,    "ReferenceBlackWhite" },
  201. /* XXX temporarily accept LONG for backwards compatibility */
  202.     { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG,    FIELD_REFBLACKWHITE,
  203.       TRUE,    FALSE,    "ReferenceBlackWhite" },
  204. #endif
  205. /* begin SGI tags */
  206.     { TIFFTAG_MATTEING,         1, 1, TIFF_SHORT,    FIELD_EXTRASAMPLES,
  207.       FALSE,    FALSE,    "Matteing" },
  208.     { TIFFTAG_DATATYPE,        -2,-1, TIFF_SHORT,    FIELD_SAMPLEFORMAT,
  209.       FALSE,    FALSE,    "DataType" },
  210.     { TIFFTAG_IMAGEDEPTH,     1, 1, TIFF_LONG,    FIELD_IMAGEDEPTH,
  211.       FALSE,    FALSE,    "ImageDepth" },
  212.     { TIFFTAG_IMAGEDEPTH,     1, 1, TIFF_SHORT,    FIELD_IMAGEDEPTH,
  213.       FALSE,    FALSE,    "ImageDepth" },
  214.     { TIFFTAG_TILEDEPTH,     1, 1, TIFF_LONG,    FIELD_TILEDEPTH,
  215.       FALSE,    FALSE,    "TileDepth" },
  216.     { TIFFTAG_TILEDEPTH,     1, 1, TIFF_SHORT,    FIELD_TILEDEPTH,
  217.       FALSE,    FALSE,    "TileDepth" },
  218. /* end SGI tags */
  219. #ifdef IPTC_SUPPORT
  220. #ifdef PHOTOSHOP_SUPPORT
  221.     { TIFFTAG_RICHTIFFIPTC, -1,-1, TIFF_LONG,   FIELD_RICHTIFFIPTC,
  222.       FALSE,    TRUE,   "RichTIFFIPTC" },
  223. #else
  224.     { TIFFTAG_RICHTIFFIPTC, -1,-3, TIFF_UNDEFINED, FIELD_RICHTIFFIPTC,
  225.       FALSE,    TRUE,   "RichTIFFIPTC" },
  226. #endif
  227. #endif
  228. #ifdef PHOTOSHOP_SUPPORT
  229.     { TIFFTAG_PHOTOSHOP,    -1,-3, TIFF_UNDEFINED, FIELD_PHOTOSHOP,
  230.       FALSE,    TRUE,   "Photoshop" },
  231.     { TIFFTAG_PHOTOSHOP,    -1,-1, TIFF_BYTE,   FIELD_PHOTOSHOP,
  232.       FALSE,    TRUE,   "Photoshop" },
  233. #endif
  234. #ifdef ICC_SUPPORT
  235.     { TIFFTAG_ICCPROFILE,    -1,-3, TIFF_UNDEFINED,    FIELD_ICCPROFILE,
  236.       FALSE,    TRUE,    "ICC Profile" },
  237. #endif
  238.     { TIFFTAG_STONITS,         1, 1, TIFF_DOUBLE,    FIELD_STONITS,
  239.       FALSE,    FALSE,    "StoNits" },
  240. };
  241. #define    N(a)    (sizeof (a) / sizeof (a[0]))
  242.  
  243. void
  244. _TIFFSetupFieldInfo(TIFF* tif)
  245. {
  246.     if (tif->tif_fieldinfo) {
  247.         _TIFFfree(tif->tif_fieldinfo);
  248.         tif->tif_nfields = 0;
  249.     }
  250.     _TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo));
  251. }
  252.  
  253. static int LINKAGEMODE
  254. tagCompare(const void* a, const void* b)
  255. {
  256.     const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
  257.     const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
  258.     /* NB: be careful of return values for 16-bit platforms */
  259.     if (ta->field_tag != tb->field_tag)
  260.         return (ta->field_tag < tb->field_tag ? -1 : 1);
  261.     else
  262.         return (tb->field_type < ta->field_type ? -1 : 1);
  263. }
  264.  
  265. void
  266. _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
  267. {
  268.     TIFFFieldInfo** tp;
  269.     int i;
  270.  
  271.     if (tif->tif_nfields > 0) {
  272.         tif->tif_fieldinfo = (TIFFFieldInfo**)
  273.             _TIFFrealloc(tif->tif_fieldinfo,
  274.             (tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
  275.     } else {
  276.         tif->tif_fieldinfo = (TIFFFieldInfo**)
  277.             _TIFFmalloc(n * sizeof (TIFFFieldInfo*));
  278.     }
  279.     tp = &tif->tif_fieldinfo[tif->tif_nfields];
  280.     for (i = 0; i < n; i++)
  281.         tp[i] = (TIFFFieldInfo*) &info[i];    /* XXX */
  282.     /*
  283.      * NB: the core tags are presumed sorted correctly.
  284.      */
  285.     if (tif->tif_nfields > 0)
  286.         qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
  287.             sizeof (TIFFFieldInfo*), tagCompare);
  288.     else
  289.         tif->tif_nfields += n;
  290. }
  291.  
  292. void
  293. _TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
  294. {
  295.     int i;
  296.  
  297.     fprintf(fd, "%s: \n", tif->tif_name);
  298.     for (i = 0; i < tif->tif_nfields; i++) {
  299.         const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
  300.         fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
  301.             , i
  302.             , (unsigned long) fip->field_tag
  303.             , fip->field_readcount, fip->field_writecount
  304.             , fip->field_type
  305.             , fip->field_bit
  306.             , fip->field_oktochange ? "TRUE" : "FALSE"
  307.             , fip->field_passcount ? "TRUE" : "FALSE"
  308.             , fip->field_name
  309.         );
  310.     }
  311. }
  312.  
  313. const int tiffDataWidth[] = {
  314.     1,    /* nothing */
  315.     1,    /* TIFF_BYTE */
  316.     1,    /* TIFF_ASCII */
  317.     2,    /* TIFF_SHORT */
  318.     4,    /* TIFF_LONG */
  319.     8,    /* TIFF_RATIONAL */
  320.     1,    /* TIFF_SBYTE */
  321.     1,    /* TIFF_UNDEFINED */
  322.     2,    /* TIFF_SSHORT */
  323.     4,    /* TIFF_SLONG */
  324.     8,    /* TIFF_SRATIONAL */
  325.     4,    /* TIFF_FLOAT */
  326.     8,    /* TIFF_DOUBLE */
  327. };
  328.  
  329. /*
  330.  * Return nearest TIFFDataType to the sample type of an image.
  331.  */
  332. TIFFDataType
  333. _TIFFSampleToTagType(TIFF* tif)
  334. {
  335.     int bps = (int) TIFFhowmany(tif->tif_dir.td_bitspersample, 8);
  336.  
  337.     switch (tif->tif_dir.td_sampleformat) {
  338.     case SAMPLEFORMAT_IEEEFP:
  339.         return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
  340.     case SAMPLEFORMAT_INT:
  341.         return (bps <= 1 ? TIFF_SBYTE :
  342.             bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
  343.     case SAMPLEFORMAT_UINT:
  344.         return (bps <= 1 ? TIFF_BYTE :
  345.             bps <= 2 ? TIFF_SHORT : TIFF_LONG);
  346.     case SAMPLEFORMAT_VOID:
  347.         return (TIFF_UNDEFINED);
  348.     }
  349.     /*NOTREACHED*/
  350.     return (TIFF_UNDEFINED);
  351. }
  352.  
  353. const TIFFFieldInfo*
  354. _TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
  355. {
  356.     static const TIFFFieldInfo *last = NULL;
  357.     int i, n;
  358.  
  359.     if (last && last->field_tag == tag &&
  360.         (dt == TIFF_ANY || dt == last->field_type))
  361.         return (last);
  362.     /* NB: if table gets big, use sorted search (e.g. binary search) */
  363.     for (i = 0, n = tif->tif_nfields; i < n; i++) {
  364.         const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
  365.         if (fip->field_tag == tag &&
  366.             (dt == TIFF_ANY || fip->field_type == dt))
  367.             return (last = fip);
  368.     }
  369.     return ((const TIFFFieldInfo *)0);
  370. }
  371.  
  372. #include <assert.h>
  373. #include <stdio.h>
  374.  
  375. const TIFFFieldInfo*
  376. _TIFFFieldWithTag(TIFF* tif, ttag_t tag)
  377. {
  378.     const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
  379.     if (!fip) {
  380.         TIFFError("TIFFFieldWithTag",
  381.             "Internal error, unknown tag 0x%x", (u_int) tag);
  382.         assert(fip != NULL);
  383.         /*NOTREACHED*/
  384.     }
  385.     return (fip);
  386. }
  387.