home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / graphics / libtiff_1 / c / tif_dirinfo < prev    next >
Text File  |  1995-10-12  |  14KB  |  361 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_dirinfo.c,v 1.36 1995/06/30 05:46:47 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988-1995 Sam Leffler
  5.  * Copyright (c) 1991-1995 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,    FALSE,    "InkNames" },
  170.     { TIFFTAG_DOTRANGE,         2, 2, TIFF_SHORT,    FIELD_DOTRANGE,
  171.       FALSE,    FALSE,    "DotRange" },
  172.     { TIFFTAG_DOTRANGE,         2, 2, TIFF_BYTE,    FIELD_DOTRANGE,
  173.       FALSE,    FALSE,    "DotRange" },
  174.     { TIFFTAG_TARGETPRINTER,    -1,-1, TIFF_ASCII,    FIELD_TARGETPRINTER,
  175.       TRUE,    FALSE,    "TargetPrinter" },
  176. #endif
  177.     { TIFFTAG_EXTRASAMPLES,    -1,-1, TIFF_SHORT,    FIELD_EXTRASAMPLES,
  178.       FALSE,    FALSE,    "ExtraSamples" },
  179. /* XXX for bogus Adobe Photoshop v2.5 files */
  180.     { TIFFTAG_EXTRASAMPLES,    -1,-1, TIFF_BYTE,    FIELD_EXTRASAMPLES,
  181.       FALSE,    FALSE,    "ExtraSamples" },
  182.     { TIFFTAG_SAMPLEFORMAT,    -1,-1, TIFF_SHORT,    FIELD_SAMPLEFORMAT,
  183.       FALSE,    FALSE,    "SampleFormat" },
  184.     { TIFFTAG_SMINSAMPLEVALUE,    -2,-1, TIFF_ANY,    FIELD_SMINSAMPLEVALUE,
  185.       TRUE,    FALSE,    "SMinSampleValue" },
  186.     { TIFFTAG_SMAXSAMPLEVALUE,    -2,-1, TIFF_ANY,    FIELD_SMAXSAMPLEVALUE,
  187.       TRUE,    FALSE,    "SMaxSampleValue" },
  188. #ifdef YCBCR_SUPPORT        /* 6.0 YCbCr tags */
  189.     { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL,    FIELD_YCBCRCOEFFICIENTS,
  190.       FALSE,    FALSE,    "YCbCrCoefficients" },
  191.     { TIFFTAG_YCBCRSUBSAMPLING,     2, 2, TIFF_SHORT,    FIELD_YCBCRSUBSAMPLING,
  192.       FALSE,    FALSE,    "YCbCrSubsampling" },
  193.     { TIFFTAG_YCBCRPOSITIONING,     1, 1, TIFF_SHORT,    FIELD_YCBCRPOSITIONING,
  194.       FALSE,    FALSE,    "YCbCrPositioning" },
  195. #endif
  196. #ifdef COLORIMETRY_SUPPORT
  197.     { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL,    FIELD_REFBLACKWHITE,
  198.       TRUE,    FALSE,    "ReferenceBlackWhite" },
  199. /* XXX temporarily accept LONG for backwards compatibility */
  200.     { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG,    FIELD_REFBLACKWHITE,
  201.       TRUE,    FALSE,    "ReferenceBlackWhite" },
  202. #endif
  203. /* begin SGI tags */
  204.     { TIFFTAG_MATTEING,         1, 1, TIFF_SHORT,    FIELD_EXTRASAMPLES,
  205.       FALSE,    FALSE,    "Matteing" },
  206.     { TIFFTAG_DATATYPE,        -2,-1, TIFF_SHORT,    FIELD_SAMPLEFORMAT,
  207.       FALSE,    FALSE,    "DataType" },
  208.     { TIFFTAG_IMAGEDEPTH,     1, 1, TIFF_LONG,    FIELD_IMAGEDEPTH,
  209.       FALSE,    FALSE,    "ImageDepth" },
  210.     { TIFFTAG_IMAGEDEPTH,     1, 1, TIFF_SHORT,    FIELD_IMAGEDEPTH,
  211.       FALSE,    FALSE,    "ImageDepth" },
  212.     { TIFFTAG_TILEDEPTH,     1, 1, TIFF_LONG,    FIELD_TILEDEPTH,
  213.       FALSE,    FALSE,    "TileDepth" },
  214.     { TIFFTAG_TILEDEPTH,     1, 1, TIFF_SHORT,    FIELD_TILEDEPTH,
  215.       FALSE,    FALSE,    "TileDepth" },
  216. /* end SGI tags */
  217. };
  218. #define    N(a)    (sizeof (a) / sizeof (a[0]))
  219.  
  220. void
  221. _TIFFSetupFieldInfo(TIFF* tif)
  222. {
  223.     if (tif->tif_fieldinfo) {
  224.         _TIFFfree(tif->tif_fieldinfo);
  225.         tif->tif_nfields = 0;
  226.     }
  227.     _TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo));
  228. }
  229.  
  230. static int
  231. tagCompare(const void* a, const void* b)
  232. {
  233.     const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
  234.     const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
  235.      int c = ta->field_tag - tb->field_tag;
  236.     return (c != 0 ? c : tb->field_type - ta->field_type);
  237. }
  238.  
  239. void
  240. _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
  241. {
  242.     TIFFFieldInfo** tp;
  243.     int i;
  244.  
  245.     if (tif->tif_nfields > 0) {
  246.         tif->tif_fieldinfo = (TIFFFieldInfo**)
  247.             _TIFFrealloc(tif->tif_fieldinfo,
  248.             (tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
  249.     } else {
  250.         tif->tif_fieldinfo = (TIFFFieldInfo**)
  251.             _TIFFmalloc(n * sizeof (TIFFFieldInfo*));
  252.     }
  253.     tp = &tif->tif_fieldinfo[tif->tif_nfields];
  254.     for (i = 0; i < n; i++)
  255.         tp[i] = (TIFFFieldInfo*) &info[i];    /* XXX */
  256.     /*
  257.      * NB: the core tags are presumed sorted correctly.
  258.      */
  259.     if (tif->tif_nfields > 0)
  260.         qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
  261.             sizeof (TIFFFieldInfo*), tagCompare);
  262.     else
  263.         tif->tif_nfields += n;
  264. }
  265.  
  266. void
  267. _TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
  268. {
  269.     int i;
  270.  
  271.     fprintf(fd, "%s: \n", tif->tif_name);
  272.     for (i = 0; i < tif->tif_nfields; i++) {
  273.         const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
  274.         fprintf(fd, "field[%2d] %5u, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
  275.             , i
  276.             , fip->field_tag
  277.             , fip->field_readcount, fip->field_writecount
  278.             , fip->field_type
  279.             , fip->field_bit
  280.             , fip->field_oktochange ? "TRUE" : "FALSE"
  281.             , fip->field_passcount ? "TRUE" : "FALSE"
  282.             , fip->field_name
  283.         );
  284.     }
  285. }
  286.  
  287. const int tiffDataWidth[] = {
  288.     1,    /* nothing */
  289.     1,    /* TIFF_BYTE */
  290.     1,    /* TIFF_ASCII */
  291.     2,    /* TIFF_SHORT */
  292.     4,    /* TIFF_LONG */
  293.     8,    /* TIFF_RATIONAL */
  294.     1,    /* TIFF_SBYTE */
  295.     1,    /* TIFF_UNDEFINED */
  296.     2,    /* TIFF_SSHORT */
  297.     4,    /* TIFF_SLONG */
  298.     8,    /* TIFF_SRATIONAL */
  299.     4,    /* TIFF_FLOAT */
  300.     8,    /* TIFF_DOUBLE */
  301. };
  302.  
  303. /*
  304.  * Return nearest TIFFDataType to the sample type of an image.
  305.  */
  306. TIFFDataType
  307. _TIFFSampleToTagType(TIFF* tif)
  308. {
  309.     int bps = (int) TIFFhowmany(tif->tif_dir.td_bitspersample, 8);
  310.  
  311.     switch (tif->tif_dir.td_sampleformat) {
  312.     case SAMPLEFORMAT_IEEEFP:
  313.         return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
  314.     case SAMPLEFORMAT_INT:
  315.         return (bps <= 1 ? TIFF_SBYTE :
  316.             bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
  317.     case SAMPLEFORMAT_UINT:
  318.         return (bps <= 1 ? TIFF_BYTE :
  319.             bps <= 2 ? TIFF_SHORT : TIFF_LONG);
  320.     case SAMPLEFORMAT_VOID:
  321.         return (TIFF_UNDEFINED);
  322.     }
  323.     /*NOTREACHED*/
  324.     return (TIFF_UNDEFINED);
  325. }
  326.  
  327. const TIFFFieldInfo*
  328. _TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
  329. {
  330.     static const TIFFFieldInfo *last = NULL;
  331.     int i, n;
  332.  
  333.     if (last && last->field_tag == tag &&
  334.         (dt == TIFF_ANY || dt == last->field_type))
  335.         return (last);
  336.     /* NB: if table gets big, use sorted search (e.g. binary search) */
  337.     for (i = 0, n = tif->tif_nfields; i < n; i++) {
  338.         const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
  339.         if (fip->field_tag == tag &&
  340.             (dt == TIFF_ANY || fip->field_type == dt))
  341.             return (last = fip);
  342.     }
  343.     return ((const TIFFFieldInfo *)0);
  344. }
  345.  
  346. #include <assert.h>
  347. #include <stdio.h>
  348.  
  349. const TIFFFieldInfo*
  350. _TIFFFieldWithTag(TIFF* tif, ttag_t tag)
  351. {
  352.     const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
  353.     if (!fip) {
  354.         TIFFError("TIFFFieldWithTag",
  355.             "Internal error, unknown tag 0x%x", (u_int) tag);
  356.         assert(fip != NULL);
  357.         /*NOTREACHED*/
  358.     }
  359.     return (fip);
  360. }
  361.