Logo Search packages:      
Sourcecode: qt4-x11 version File versions  Download package

tif_dirinfo.c

/* $Id: tif_dirinfo.c,v 1.62 2006/02/07 10:45:38 dron Exp $ */

/*
 * Copyright (c) 1988-1997 Sam Leffler
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and 
 * its documentation for any purpose is hereby granted without fee, provided
 * that (i) the above copyright notices and this permission notice appear in
 * all copies of the software and related documentation, and (ii) the names of
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 * publicity relating to the software without the specific, prior written
 * permission of Sam Leffler and Silicon Graphics.
 * 
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
 * 
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
 * OF THIS SOFTWARE.
 */

/*
 * TIFF Library.
 *
 * Core Directory Tag Support.
 */
#include "tiffiop.h"
#include <stdlib.h>

/*
 * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
 *       If a tag can have both LONG and SHORT types then the LONG must be
 *       placed before the SHORT for writing to work properly.
 *
 * NOTE: The second field (field_readcount) and third field (field_writecount)
 *       sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
 *       and TIFFTAG_SPP (-2). The macros should be used but would throw off 
 *       the formatting of the code, so please interprete the -1, -2 and -3 
 *       values accordingly.
 */
static const TIFFFieldInfo
tiffFieldInfo[] = {
    { TIFFTAG_SUBFILETYPE,     1, 1,      TIFF_LONG,  FIELD_SUBFILETYPE,
      1,    0,    "SubfileType" },
/* XXX SHORT for compatibility w/ old versions of the library */
    { TIFFTAG_SUBFILETYPE,     1, 1,      TIFF_SHORT, FIELD_SUBFILETYPE,
      1,    0,    "SubfileType" },
    { TIFFTAG_OSUBFILETYPE,    1, 1,      TIFF_SHORT, FIELD_SUBFILETYPE,
      1,    0,    "OldSubfileType" },
    { TIFFTAG_IMAGEWIDTH,      1, 1,      TIFF_LONG,  FIELD_IMAGEDIMENSIONS,
      0,    0,    "ImageWidth" },
    { TIFFTAG_IMAGEWIDTH,      1, 1,      TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
      0,    0,    "ImageWidth" },
    { TIFFTAG_IMAGELENGTH,     1, 1,      TIFF_LONG,  FIELD_IMAGEDIMENSIONS,
      1,    0,    "ImageLength" },
    { TIFFTAG_IMAGELENGTH,     1, 1,      TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
      1,    0,    "ImageLength" },
    { TIFFTAG_BITSPERSAMPLE,  -1,-1,      TIFF_SHORT, FIELD_BITSPERSAMPLE,
      0,    0,    "BitsPerSample" },
/* XXX LONG for compatibility with some broken TIFF writers */
    { TIFFTAG_BITSPERSAMPLE,  -1,-1,      TIFF_LONG,  FIELD_BITSPERSAMPLE,
      0,    0,    "BitsPerSample" },
    { TIFFTAG_COMPRESSION,    -1, 1,      TIFF_SHORT, FIELD_COMPRESSION,
      0,    0,    "Compression" },
/* XXX LONG for compatibility with some broken TIFF writers */
    { TIFFTAG_COMPRESSION,    -1, 1,      TIFF_LONG,  FIELD_COMPRESSION,
      0,    0,    "Compression" },
    { TIFFTAG_PHOTOMETRIC,     1, 1,      TIFF_SHORT, FIELD_PHOTOMETRIC,
      0,    0,    "PhotometricInterpretation" },
/* XXX LONG for compatibility with some broken TIFF writers */
    { TIFFTAG_PHOTOMETRIC,     1, 1,      TIFF_LONG,  FIELD_PHOTOMETRIC,
      0,    0,    "PhotometricInterpretation" },
    { TIFFTAG_THRESHHOLDING,   1, 1,      TIFF_SHORT, FIELD_THRESHHOLDING,
      1,    0,    "Threshholding" },
    { TIFFTAG_CELLWIDTH,       1, 1,      TIFF_SHORT, FIELD_IGNORE,
      1,    0,    "CellWidth" },
    { TIFFTAG_CELLLENGTH,      1, 1,      TIFF_SHORT, FIELD_IGNORE,
      1,    0,    "CellLength" },
    { TIFFTAG_FILLORDER,       1, 1,      TIFF_SHORT, FIELD_FILLORDER,
      0,    0,    "FillOrder" },
    { TIFFTAG_DOCUMENTNAME,   -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "DocumentName" },
    { TIFFTAG_IMAGEDESCRIPTION,     -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "ImageDescription" },
    { TIFFTAG_MAKE,           -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "Make" },
    { TIFFTAG_MODEL,          -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "Model" },
    { TIFFTAG_STRIPOFFSETS,   -1,-1,      TIFF_LONG,  FIELD_STRIPOFFSETS,
      0,    0,    "StripOffsets" },
    { TIFFTAG_STRIPOFFSETS,   -1,-1,      TIFF_SHORT, FIELD_STRIPOFFSETS,
      0,    0,    "StripOffsets" },
    { TIFFTAG_ORIENTATION,     1, 1,      TIFF_SHORT, FIELD_ORIENTATION,
      0,    0,    "Orientation" },
    { TIFFTAG_SAMPLESPERPIXEL,       1, 1,      TIFF_SHORT, FIELD_SAMPLESPERPIXEL,
      0,    0,    "SamplesPerPixel" },
    { TIFFTAG_ROWSPERSTRIP,    1, 1,      TIFF_LONG,  FIELD_ROWSPERSTRIP,
      0,    0,    "RowsPerStrip" },
    { TIFFTAG_ROWSPERSTRIP,    1, 1,      TIFF_SHORT, FIELD_ROWSPERSTRIP,
      0,    0,    "RowsPerStrip" },
    { TIFFTAG_STRIPBYTECOUNTS,      -1,-1,      TIFF_LONG,  FIELD_STRIPBYTECOUNTS,
      0,    0,    "StripByteCounts" },
    { TIFFTAG_STRIPBYTECOUNTS,      -1,-1,      TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
      0,    0,    "StripByteCounts" },
    { TIFFTAG_MINSAMPLEVALUE, -2,-1,      TIFF_SHORT, FIELD_MINSAMPLEVALUE,
      1,    0,    "MinSampleValue" },
    { TIFFTAG_MAXSAMPLEVALUE, -2,-1,      TIFF_SHORT, FIELD_MAXSAMPLEVALUE,
      1,    0,    "MaxSampleValue" },
    { TIFFTAG_XRESOLUTION,     1, 1,      TIFF_RATIONAL,    FIELD_RESOLUTION,
      1,    0,    "XResolution" },
    { TIFFTAG_YRESOLUTION,     1, 1,      TIFF_RATIONAL,    FIELD_RESOLUTION,
      1,    0,    "YResolution" },
    { TIFFTAG_PLANARCONFIG,    1, 1,      TIFF_SHORT, FIELD_PLANARCONFIG,
      0,    0,    "PlanarConfiguration" },
    { TIFFTAG_PAGENAME,       -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "PageName" },
    { TIFFTAG_XPOSITION,       1, 1,      TIFF_RATIONAL,    FIELD_POSITION,
      1,    0,    "XPosition" },
    { TIFFTAG_YPOSITION,       1, 1,      TIFF_RATIONAL,    FIELD_POSITION,
      1,    0,    "YPosition" },
    { TIFFTAG_FREEOFFSETS,    -1,-1,      TIFF_LONG,  FIELD_IGNORE,
      0,    0,    "FreeOffsets" },
    { TIFFTAG_FREEBYTECOUNTS, -1,-1,      TIFF_LONG,  FIELD_IGNORE,
      0,    0,    "FreeByteCounts" },
    { TIFFTAG_GRAYRESPONSEUNIT,      1, 1,      TIFF_SHORT, FIELD_IGNORE,
      1,    0,    "GrayResponseUnit" },
    { TIFFTAG_GRAYRESPONSECURVE,-1,-1,    TIFF_SHORT, FIELD_IGNORE,
      1,    0,    "GrayResponseCurve" },
    { TIFFTAG_RESOLUTIONUNIT,  1, 1,      TIFF_SHORT, FIELD_RESOLUTIONUNIT,
      1,    0,    "ResolutionUnit" },
    { TIFFTAG_PAGENUMBER,      2, 2,      TIFF_SHORT, FIELD_PAGENUMBER,
      1,    0,    "PageNumber" },
    { TIFFTAG_COLORRESPONSEUNIT, 1, 1,    TIFF_SHORT, FIELD_IGNORE,
      1,    0,    "ColorResponseUnit" },
    { TIFFTAG_TRANSFERFUNCTION,     -1,-1,      TIFF_SHORT, FIELD_TRANSFERFUNCTION,
      1,    0,    "TransferFunction" },
    { TIFFTAG_SOFTWARE,       -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "Software" },
    { TIFFTAG_DATETIME,       20,20,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "DateTime" },
    { TIFFTAG_ARTIST,         -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "Artist" },
    { TIFFTAG_HOSTCOMPUTER,   -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "HostComputer" },
    { TIFFTAG_WHITEPOINT,      2, 2,      TIFF_RATIONAL,    FIELD_CUSTOM,
      1,    0,    "WhitePoint" },
    { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,      FIELD_CUSTOM,
      1,    0,    "PrimaryChromaticities" },
    { TIFFTAG_COLORMAP,       -1,-1,      TIFF_SHORT, FIELD_COLORMAP,
      1,    0,    "ColorMap" },
    { TIFFTAG_HALFTONEHINTS,   2, 2,      TIFF_SHORT, FIELD_HALFTONEHINTS,
      1,    0,    "HalftoneHints" },
    { TIFFTAG_TILEWIDTH,       1, 1,      TIFF_LONG,  FIELD_TILEDIMENSIONS,
      0,    0,    "TileWidth" },
    { TIFFTAG_TILEWIDTH,       1, 1,      TIFF_SHORT, FIELD_TILEDIMENSIONS,
      0,    0,    "TileWidth" },
    { TIFFTAG_TILELENGTH,      1, 1,      TIFF_LONG,  FIELD_TILEDIMENSIONS,
      0,    0,    "TileLength" },
    { TIFFTAG_TILELENGTH,      1, 1,      TIFF_SHORT, FIELD_TILEDIMENSIONS,
      0,    0,    "TileLength" },
    { TIFFTAG_TILEOFFSETS,    -1, 1,      TIFF_LONG,  FIELD_STRIPOFFSETS,
      0,    0,    "TileOffsets" },
    { TIFFTAG_TILEBYTECOUNTS, -1, 1,      TIFF_LONG,  FIELD_STRIPBYTECOUNTS,
      0,    0,    "TileByteCounts" },
    { TIFFTAG_TILEBYTECOUNTS, -1, 1,      TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
      0,    0,    "TileByteCounts" },
    { TIFFTAG_SUBIFD,         -1,-1,      TIFF_IFD,   FIELD_SUBIFD,
      1,    1,    "SubIFD" },
    { TIFFTAG_SUBIFD,         -1,-1,      TIFF_LONG,  FIELD_SUBIFD,
      1,    1,    "SubIFD" },
    { TIFFTAG_INKSET,          1, 1,      TIFF_SHORT, FIELD_CUSTOM,
      0,    0,    "InkSet" },
    { TIFFTAG_INKNAMES,       -1,-1,      TIFF_ASCII, FIELD_INKNAMES,
      1,    1,    "InkNames" },
    { TIFFTAG_NUMBEROFINKS,    1, 1,      TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "NumberOfInks" },
    { TIFFTAG_DOTRANGE,        2, 2,      TIFF_SHORT, FIELD_CUSTOM,
      0,    0,    "DotRange" },
    { TIFFTAG_DOTRANGE,        2, 2,      TIFF_BYTE,  FIELD_CUSTOM,
      0,    0,    "DotRange" },
    { TIFFTAG_TARGETPRINTER,  -1,-1,      TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "TargetPrinter" },
    { TIFFTAG_EXTRASAMPLES,   -1,-1,      TIFF_SHORT, FIELD_EXTRASAMPLES,
      0,    1,    "ExtraSamples" },
/* XXX for bogus Adobe Photoshop v2.5 files */
    { TIFFTAG_EXTRASAMPLES,   -1,-1,      TIFF_BYTE,  FIELD_EXTRASAMPLES,
      0,    1,    "ExtraSamples" },
    { TIFFTAG_SAMPLEFORMAT,   -1,-1,      TIFF_SHORT, FIELD_SAMPLEFORMAT,
      0,    0,    "SampleFormat" },
    { TIFFTAG_SMINSAMPLEVALUE,      -2,-1,      TIFF_ANY,   FIELD_SMINSAMPLEVALUE,
      1,    0,    "SMinSampleValue" },
    { TIFFTAG_SMAXSAMPLEVALUE,      -2,-1,      TIFF_ANY,   FIELD_SMAXSAMPLEVALUE,
      1,    0,    "SMaxSampleValue" },
    { TIFFTAG_CLIPPATH,       -1, -3, TIFF_BYTE,      FIELD_CUSTOM,
      0,    1,    "ClipPath" },
    { TIFFTAG_XCLIPPATHUNITS,  1, 1,      TIFF_SLONG, FIELD_CUSTOM,
      0,    0,    "XClipPathUnits" },
    { TIFFTAG_XCLIPPATHUNITS,  1, 1,      TIFF_SSHORT,      FIELD_CUSTOM,
      0,    0,    "XClipPathUnits" },
    { TIFFTAG_XCLIPPATHUNITS,  1, 1,      TIFF_SBYTE, FIELD_CUSTOM,
      0,    0,    "XClipPathUnits" },
    { TIFFTAG_YCLIPPATHUNITS,  1, 1,      TIFF_SLONG, FIELD_CUSTOM,
      0,    0,    "YClipPathUnits" },
    { TIFFTAG_YCLIPPATHUNITS,  1, 1,      TIFF_SSHORT,      FIELD_CUSTOM,
      0,    0,    "YClipPathUnits" },
    { TIFFTAG_YCLIPPATHUNITS,  1, 1,      TIFF_SBYTE, FIELD_CUSTOM,
      0,    0,    "YClipPathUnits" },
    { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3,    TIFF_RATIONAL,    FIELD_CUSTOM,
      0,    0,    "YCbCrCoefficients" },
    { TIFFTAG_YCBCRSUBSAMPLING,      2, 2,      TIFF_SHORT, FIELD_YCBCRSUBSAMPLING,
      0,    0,    "YCbCrSubsampling" },
    { TIFFTAG_YCBCRPOSITIONING,      1, 1,      TIFF_SHORT, FIELD_YCBCRPOSITIONING,
      0,    0,    "YCbCrPositioning" },
    { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_RATIONAL,     FIELD_CUSTOM,
      1,    0,    "ReferenceBlackWhite" },
/* XXX temporarily accept LONG for backwards compatibility */
    { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_LONG,   FIELD_CUSTOM,
      1,    0,    "ReferenceBlackWhite" },
    { TIFFTAG_XMLPACKET,      -3,-3,      TIFF_BYTE,  FIELD_CUSTOM,
      0,    1,    "XMLPacket" },
/* begin SGI tags */
    { TIFFTAG_MATTEING,        1, 1,      TIFF_SHORT, FIELD_EXTRASAMPLES,
      0,    0,    "Matteing" },
    { TIFFTAG_DATATYPE,       -2,-1,      TIFF_SHORT, FIELD_SAMPLEFORMAT,
      0,    0,    "DataType" },
    { TIFFTAG_IMAGEDEPTH,      1, 1,      TIFF_LONG,  FIELD_IMAGEDEPTH,
      0,    0,    "ImageDepth" },
    { TIFFTAG_IMAGEDEPTH,      1, 1,      TIFF_SHORT, FIELD_IMAGEDEPTH,
      0,    0,    "ImageDepth" },
    { TIFFTAG_TILEDEPTH,       1, 1,      TIFF_LONG,  FIELD_TILEDEPTH,
      0,    0,    "TileDepth" },
    { TIFFTAG_TILEDEPTH,       1, 1,      TIFF_SHORT, FIELD_TILEDEPTH,
      0,    0,    "TileDepth" },
/* end SGI tags */
/* begin Pixar tags */
    { TIFFTAG_PIXAR_IMAGEFULLWIDTH,  1, 1, TIFF_LONG, FIELD_CUSTOM,
      1,    0,    "ImageFullWidth" },
    { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_CUSTOM,
      1,    0,    "ImageFullLength" },
    { TIFFTAG_PIXAR_TEXTUREFORMAT,  -1, -1, TIFF_ASCII,     FIELD_CUSTOM,
      1,    0,    "TextureFormat" },
    { TIFFTAG_PIXAR_WRAPMODES,          -1, -1, TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "TextureWrapModes" },
    { TIFFTAG_PIXAR_FOVCOT,        1, 1, TIFF_FLOAT,  FIELD_CUSTOM,
      1,    0,    "FieldOfViewCotangent" },
    { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16,      TIFF_FLOAT,
      FIELD_CUSTOM,     1,    0,    "MatrixWorldToScreen" },
    { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16,      TIFF_FLOAT,
       FIELD_CUSTOM,    1,    0,    "MatrixWorldToCamera" },
    { TIFFTAG_COPYRIGHT,      -1, -1,     TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "Copyright" },
/* end Pixar tags */
    { TIFFTAG_RICHTIFFIPTC, -3, -3, TIFF_LONG,  FIELD_CUSTOM, 
      0,    1,   "RichTIFFIPTC" },
    { TIFFTAG_PHOTOSHOP,    -3, -3, TIFF_BYTE,  FIELD_CUSTOM, 
      0,    1,   "Photoshop" },
    { TIFFTAG_EXIFIFD,        1, 1, TIFF_LONG,  FIELD_CUSTOM,
      0,    0,    "EXIFIFDOffset" },
    { TIFFTAG_ICCPROFILE,     -3, -3,     TIFF_UNDEFINED,   FIELD_CUSTOM,
      0,    1,    "ICC Profile" },
    { TIFFTAG_GPSIFD,         1, 1, TIFF_LONG,  FIELD_CUSTOM,
      0,    0,    "GPSIFDOffset" },
    { TIFFTAG_STONITS,         1, 1,      TIFF_DOUBLE,      FIELD_CUSTOM,
      0,    0,    "StoNits" },
    { TIFFTAG_INTEROPERABILITYIFD, 1, 1, TIFF_LONG,   FIELD_CUSTOM,
      0,    0,    "InteroperabilityIFDOffset" },
/* begin DNG tags */
    { TIFFTAG_DNGVERSION,     4, 4, TIFF_BYTE,  FIELD_CUSTOM, 
      0,    0,    "DNGVersion" },
    { TIFFTAG_DNGBACKWARDVERSION, 4, 4,   TIFF_BYTE,  FIELD_CUSTOM, 
      0,    0,    "DNGBackwardVersion" },
    { TIFFTAG_UNIQUECAMERAMODEL,    -1, -1, TIFF_ASCII,     FIELD_CUSTOM,
      1,    0,    "UniqueCameraModel" },
    { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_ASCII,     FIELD_CUSTOM,
      1,    0,    "LocalizedCameraModel" },
    { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_BYTE,      FIELD_CUSTOM,
      1,    1,    "LocalizedCameraModel" },
    { TIFFTAG_CFAPLANECOLOR,  -1, -1,     TIFF_BYTE,  FIELD_CUSTOM, 
      0,    1,    "CFAPlaneColor" },
    { TIFFTAG_CFALAYOUT,      1, 1, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "CFALayout" },
    { TIFFTAG_LINEARIZATIONTABLE, -1, -1, TIFF_SHORT, FIELD_CUSTOM, 
      0,    1,    "LinearizationTable" },
    { TIFFTAG_BLACKLEVELREPEATDIM, 2, 2, TIFF_SHORT,  FIELD_CUSTOM, 
      0,    0,    "BlackLevelRepeatDim" },
    { TIFFTAG_BLACKLEVEL,     -1, -1,     TIFF_LONG,  FIELD_CUSTOM, 
      0,    1,    "BlackLevel" },
    { TIFFTAG_BLACKLEVEL,     -1, -1,     TIFF_SHORT, FIELD_CUSTOM, 
      0,    1,    "BlackLevel" },
    { TIFFTAG_BLACKLEVEL,     -1, -1,     TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    1,    "BlackLevel" },
    { TIFFTAG_BLACKLEVELDELTAH,     -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "BlackLevelDeltaH" },
    { TIFFTAG_BLACKLEVELDELTAV,     -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "BlackLevelDeltaV" },
    { TIFFTAG_WHITELEVEL,     -2, -2,     TIFF_LONG,  FIELD_CUSTOM, 
      0,    0,    "WhiteLevel" },
    { TIFFTAG_WHITELEVEL,     -2, -2,     TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "WhiteLevel" },
    { TIFFTAG_DEFAULTSCALE,   2, 2, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "DefaultScale" },
    { TIFFTAG_BESTQUALITYSCALE,     1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "BestQualityScale" },
    { TIFFTAG_DEFAULTCROPORIGIN,    2, 2, TIFF_LONG,  FIELD_CUSTOM, 
      0,    0,    "DefaultCropOrigin" },
    { TIFFTAG_DEFAULTCROPORIGIN,    2, 2, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "DefaultCropOrigin" },
    { TIFFTAG_DEFAULTCROPORIGIN,    2, 2, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "DefaultCropOrigin" },
    { TIFFTAG_DEFAULTCROPSIZE,      2, 2, TIFF_LONG,  FIELD_CUSTOM, 
      0,    0,    "DefaultCropSize" },
    { TIFFTAG_DEFAULTCROPSIZE,      2, 2, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "DefaultCropSize" },
    { TIFFTAG_DEFAULTCROPSIZE,      2, 2, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "DefaultCropSize" },
    { TIFFTAG_COLORMATRIX1,   -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "ColorMatrix1" },
    { TIFFTAG_COLORMATRIX2,   -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "ColorMatrix2" },
    { TIFFTAG_CAMERACALIBRATION1,   -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "CameraCalibration1" },
    { TIFFTAG_CAMERACALIBRATION2,   -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "CameraCalibration2" },
    { TIFFTAG_REDUCTIONMATRIX1,     -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "ReductionMatrix1" },
    { TIFFTAG_REDUCTIONMATRIX2,     -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "ReductionMatrix2" },
    { TIFFTAG_ANALOGBALANCE,  -1, -1,     TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    1,    "AnalogBalance" },
    { TIFFTAG_ASSHOTNEUTRAL,  -1, -1,     TIFF_SHORT, FIELD_CUSTOM, 
      0,    1,    "AsShotNeutral" },
    { TIFFTAG_ASSHOTNEUTRAL,  -1, -1,     TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    1,    "AsShotNeutral" },
    { TIFFTAG_ASSHOTWHITEXY,  2, 2, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "AsShotWhiteXY" },
    { TIFFTAG_BASELINEEXPOSURE,     1, 1, TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    0,    "BaselineExposure" },
    { TIFFTAG_BASELINENOISE,  1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "BaselineNoise" },
    { TIFFTAG_BASELINESHARPNESS,    1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "BaselineSharpness" },
    { TIFFTAG_BAYERGREENSPLIT,      1, 1, TIFF_LONG,  FIELD_CUSTOM, 
      0,    0,    "BayerGreenSplit" },
    { TIFFTAG_LINEARRESPONSELIMIT,  1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "LinearResponseLimit" },
    { TIFFTAG_CAMERASERIALNUMBER,    -1, -1, TIFF_ASCII,    FIELD_CUSTOM,
      1,    0,    "CameraSerialNumber" },
    { TIFFTAG_LENSINFO, 4, 4, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "LensInfo" },
    { TIFFTAG_CHROMABLURRADIUS,     1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "ChromaBlurRadius" },
    { TIFFTAG_ANTIALIASSTRENGTH,    1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "AntiAliasStrength" },
    { TIFFTAG_SHADOWSCALE,    1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      0,    0,    "ShadowScale" },
    { TIFFTAG_DNGPRIVATEDATA,    -1, -1, TIFF_BYTE,   FIELD_CUSTOM,
      0,    1,    "DNGPrivateData" },
    { TIFFTAG_MAKERNOTESAFETY,      1, 1, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "MakerNoteSafety" },
    { TIFFTAG_CALIBRATIONILLUMINANT1,     1, 1, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "CalibrationIlluminant1" },
    { TIFFTAG_CALIBRATIONILLUMINANT2,     1, 1, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "CalibrationIlluminant2" },
    { TIFFTAG_RAWDATAUNIQUEID,      16, 16,     TIFF_BYTE,  FIELD_CUSTOM, 
      0,    0,    "RawDataUniqueID" },
    { TIFFTAG_ORIGINALRAWFILENAME,    -1, -1, TIFF_ASCII,   FIELD_CUSTOM,
      1,    0,    "OriginalRawFileName" },
    { TIFFTAG_ORIGINALRAWFILENAME,    -1, -1, TIFF_BYTE,    FIELD_CUSTOM,
      1,    1,    "OriginalRawFileName" },
    { TIFFTAG_ORIGINALRAWFILEDATA,    -1, -1, TIFF_UNDEFINED,     FIELD_CUSTOM,
      0,    1,    "OriginalRawFileData" },
    { TIFFTAG_ACTIVEAREA,     4, 4, TIFF_LONG,  FIELD_CUSTOM, 
      0,    0,    "ActiveArea" },
    { TIFFTAG_ACTIVEAREA,     4, 4, TIFF_SHORT, FIELD_CUSTOM, 
      0,    0,    "ActiveArea" },
    { TIFFTAG_MASKEDAREAS,    -1, -1,     TIFF_LONG,  FIELD_CUSTOM, 
      0,    1,    "MaskedAreas" },
    { TIFFTAG_ASSHOTICCPROFILE,    -1, -1, TIFF_UNDEFINED,  FIELD_CUSTOM,
      0,    1,    "AsShotICCProfile" },
    { TIFFTAG_ASSHOTPREPROFILEMATRIX,     -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "AsShotPreProfileMatrix" },
    { TIFFTAG_CURRENTICCPROFILE,    -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
      0,    1,    "CurrentICCProfile" },
    { TIFFTAG_CURRENTPREPROFILEMATRIX,    -1, -1,     TIFF_SRATIONAL,   FIELD_CUSTOM, 
      0,    1,    "CurrentPreProfileMatrix" },
/* end DNG tags */
};

static const TIFFFieldInfo
exifFieldInfo[] = {
    { EXIFTAG_EXPOSURETIME,   1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "ExposureTime" },
    { EXIFTAG_FNUMBER,        1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "FNumber" },
    { EXIFTAG_EXPOSUREPROGRAM,      1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "ExposureProgram" },
    { EXIFTAG_SPECTRALSENSITIVITY,    -1, -1,   TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "SpectralSensitivity" },
    { EXIFTAG_ISOSPEEDRATINGS,  -1, -1,         TIFF_SHORT, FIELD_CUSTOM,
      1,    1,    "ISOSpeedRatings" },
    { EXIFTAG_OECF,     -1, -1,                 TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    1,    "OptoelectricConversionFactor" },
    { EXIFTAG_EXIFVERSION,    4, 4,       TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    0,    "ExifVersion" },
    { EXIFTAG_DATETIMEORIGINAL,     20, 20,           TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "DateTimeOriginal" },
    { EXIFTAG_DATETIMEDIGITIZED, 20, 20,  TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "DateTimeDigitized" },
    { EXIFTAG_COMPONENTSCONFIGURATION,     4, 4,      TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    0,    "ComponentsConfiguration" },
    { EXIFTAG_COMPRESSEDBITSPERPIXEL,      1, 1,      TIFF_RATIONAL,    FIELD_CUSTOM,
      1,    0,    "CompressedBitsPerPixel" },
    { EXIFTAG_SHUTTERSPEEDVALUE,    1, 1, TIFF_SRATIONAL,   FIELD_CUSTOM, 
      1,    0,    "ShutterSpeedValue" },
    { EXIFTAG_APERTUREVALUE,  1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "ApertureValue" },
    { EXIFTAG_BRIGHTNESSVALUE,      1, 1,       TIFF_SRATIONAL,   FIELD_CUSTOM, 
      1,    0,    "BrightnessValue" },
    { EXIFTAG_EXPOSUREBIASVALUE,    1, 1, TIFF_SRATIONAL,   FIELD_CUSTOM, 
      1,    0,    "ExposureBiasValue" },
    { EXIFTAG_MAXAPERTUREVALUE,     1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "MaxApertureValue" },
    { EXIFTAG_SUBJECTDISTANCE,      1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "SubjectDistance" },
    { EXIFTAG_METERINGMODE,   1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "MeteringMode" },
    { EXIFTAG_LIGHTSOURCE,    1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "LightSource" },
    { EXIFTAG_FLASH,    1, 1,             TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "Flash" },
    { EXIFTAG_FOCALLENGTH,    1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "FocalLength" },
    { EXIFTAG_SUBJECTAREA,    -1, -1,           TIFF_SHORT, FIELD_CUSTOM,
      1,    1,    "SubjectArea" },
    { EXIFTAG_MAKERNOTE,      -1, -1,           TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    1,    "MakerNote" },
    { EXIFTAG_USERCOMMENT,    -1, -1,           TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    1,    "UserComment" },
    { EXIFTAG_SUBSECTIME,    -1, -1,            TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "SubSecTime" },
    { EXIFTAG_SUBSECTIMEORIGINAL, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "SubSecTimeOriginal" },
    { EXIFTAG_SUBSECTIMEDIGITIZED,-1, -1, TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "SubSecTimeDigitized" },
    { EXIFTAG_FLASHPIXVERSION,      4, 4,       TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    0,    "FlashpixVersion" },
    { EXIFTAG_PIXELXDIMENSION,      1, 1,       TIFF_LONG,  FIELD_CUSTOM,
      1,    0,    "PixelXDimension" },
    { EXIFTAG_PIXELXDIMENSION,      1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "PixelXDimension" },
    { EXIFTAG_PIXELYDIMENSION,      1, 1,       TIFF_LONG,  FIELD_CUSTOM,
      1,    0,    "PixelYDimension" },
    { EXIFTAG_PIXELYDIMENSION,      1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "PixelYDimension" },
    { EXIFTAG_RELATEDSOUNDFILE,     13, 13,           TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "RelatedSoundFile" },
    { EXIFTAG_FLASHENERGY,    1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "FlashEnergy" },
    { EXIFTAG_SPATIALFREQUENCYRESPONSE,   -1, -1,     TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    1,    "SpatialFrequencyResponse" },
    { EXIFTAG_FOCALPLANEXRESOLUTION,      1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "FocalPlaneXResolution" },
    { EXIFTAG_FOCALPLANEYRESOLUTION,      1, 1, TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "FocalPlaneYResolution" },
    { EXIFTAG_FOCALPLANERESOLUTIONUNIT,   1, 1, TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "FocalPlaneResolutionUnit" },
    { EXIFTAG_SUBJECTLOCATION,      2, 2,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "SubjectLocation" },
    { EXIFTAG_EXPOSUREINDEX,  1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "ExposureIndex" },
    { EXIFTAG_SENSINGMETHOD,  1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "SensingMethod" },
    { EXIFTAG_FILESOURCE,     1, 1,       TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    0,    "FileSource" },
    { EXIFTAG_SCENETYPE,      1, 1,       TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    0,    "SceneType" },
    { EXIFTAG_CFAPATTERN,     -1, -1,           TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    1,    "CFAPattern" },
    { EXIFTAG_CUSTOMRENDERED, 1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "CustomRendered" },
    { EXIFTAG_EXPOSUREMODE,   1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "ExposureMode" },
    { EXIFTAG_WHITEBALANCE,   1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "WhiteBalance" },
    { EXIFTAG_DIGITALZOOMRATIO,     1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "DigitalZoomRatio" },
    { EXIFTAG_FOCALLENGTHIN35MMFILM, 1, 1,      TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "FocalLengthIn35mmFilm" },
    { EXIFTAG_SCENECAPTURETYPE,     1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "SceneCaptureType" },
    { EXIFTAG_GAINCONTROL,    1, 1,       TIFF_RATIONAL,    FIELD_CUSTOM, 
      1,    0,    "GainControl" },
    { EXIFTAG_CONTRAST,       1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "Contrast" },
    { EXIFTAG_SATURATION,     1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "Saturation" },
    { EXIFTAG_SHARPNESS,      1, 1,       TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "Sharpness" },
    { EXIFTAG_DEVICESETTINGDESCRIPTION,   -1, -1,     TIFF_UNDEFINED,   FIELD_CUSTOM,
      1,    1,    "DeviceSettingDescription" },
    { EXIFTAG_SUBJECTDISTANCERANGE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
      1,    0,    "SubjectDistanceRange" },
    { EXIFTAG_IMAGEUNIQUEID,  33, 33,           TIFF_ASCII, FIELD_CUSTOM,
      1,    0,    "ImageUniqueID" }
};

const TIFFFieldInfo *
_TIFFGetFieldInfo(size_t *size)
{
      *size = TIFFArrayCount(tiffFieldInfo);
      return tiffFieldInfo;
}

const TIFFFieldInfo *
_TIFFGetExifFieldInfo(size_t *size)
{
      *size = TIFFArrayCount(exifFieldInfo);
      return exifFieldInfo;
}

void
_TIFFSetupFieldInfo(TIFF* tif, const TIFFFieldInfo info[], size_t n)
{
      if (tif->tif_fieldinfo) {
            size_t  i;

            for (i = 0; i < tif->tif_nfields; i++) 
            {
                  TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
                  if (fld->field_bit == FIELD_CUSTOM && 
                        strncmp("Tag ", fld->field_name, 4) == 0) {
                              _TIFFfree(fld->field_name);
                              _TIFFfree(fld);
                        }
            }   
      
            _TIFFfree(tif->tif_fieldinfo);
            tif->tif_nfields = 0;
      }
      _TIFFMergeFieldInfo(tif, info, n);
}

static int
tagCompare(const void* a, const void* b)
{
      const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
      const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
      /* NB: be careful of return values for 16-bit platforms */
      if (ta->field_tag != tb->field_tag)
            return (ta->field_tag < tb->field_tag ? -1 : 1);
      else
            return ((int)tb->field_type - (int)ta->field_type);
}

static int
tagNameCompare(const void* a, const void* b)
{
      const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
      const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;

        return strcmp(ta->field_name, tb->field_name);
}

void
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
      TIFFFieldInfo** tp;
      int i;

        tif->tif_foundfield = NULL;

      if (tif->tif_nfields > 0) {
            tif->tif_fieldinfo = (TIFFFieldInfo**)
                _TIFFrealloc(tif->tif_fieldinfo,
                  (tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
      } else {
            tif->tif_fieldinfo = (TIFFFieldInfo**)
                _TIFFmalloc(n * sizeof (TIFFFieldInfo*));
      }
      assert(tif->tif_fieldinfo != NULL);
      tp = tif->tif_fieldinfo + tif->tif_nfields;
      for (i = 0; i < n; i++)
            *tp++ = (TIFFFieldInfo*) (info + i);      /* XXX */

        /* Sort the field info by tag number */
        qsort(tif->tif_fieldinfo, tif->tif_nfields += n,
            sizeof (TIFFFieldInfo*), tagCompare);
}

void
_TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
{
      size_t i;

      fprintf(fd, "%s: \n", tif->tif_name);
      for (i = 0; i < tif->tif_nfields; i++) {
            const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
            fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
                  , (int)i
                  , (unsigned long) fip->field_tag
                  , fip->field_readcount, fip->field_writecount
                  , fip->field_type
                  , fip->field_bit
                  , fip->field_oktochange ? "TRUE" : "FALSE"
                  , fip->field_passcount ? "TRUE" : "FALSE"
                  , fip->field_name
            );
      }
}

/*
 * Return size of TIFFDataType in bytes
 */
int
TIFFDataWidth(TIFFDataType type)
{
      switch(type)
      {
      case 0:  /* nothing */
      case 1:  /* TIFF_BYTE */
      case 2:  /* TIFF_ASCII */
      case 6:  /* TIFF_SBYTE */
      case 7:  /* TIFF_UNDEFINED */
            return 1;
      case 3:  /* TIFF_SHORT */
      case 8:  /* TIFF_SSHORT */
            return 2;
      case 4:  /* TIFF_LONG */
      case 9:  /* TIFF_SLONG */
      case 11: /* TIFF_FLOAT */
        case 13: /* TIFF_IFD */
            return 4;
      case 5:  /* TIFF_RATIONAL */
      case 10: /* TIFF_SRATIONAL */
      case 12: /* TIFF_DOUBLE */
            return 8;
      default:
            return 0; /* will return 0 for unknown types */
      }
}

/*
 * Return size of TIFFDataType in bytes.
 *
 * XXX: We need a separate function to determine the space needed
 * to store the value. For TIFF_RATIONAL values TIFFDataWidth() returns 8,
 * but we use 4-byte float to represent rationals.
 */
int
_TIFFDataSize(TIFFDataType type)
{
      switch (type) {
            case TIFF_BYTE:
            case TIFF_SBYTE:
            case TIFF_ASCII:
            case TIFF_UNDEFINED:
                return 1;
            case TIFF_SHORT:
            case TIFF_SSHORT:
                return 2;
            case TIFF_LONG:
            case TIFF_SLONG:
            case TIFF_FLOAT:
            case TIFF_IFD:
            case TIFF_RATIONAL:
            case TIFF_SRATIONAL:
                return 4;
            case TIFF_DOUBLE:
                return 8;
            default:
                return 0;
      }
}

/*
 * Return nearest TIFFDataType to the sample type of an image.
 */
TIFFDataType
_TIFFSampleToTagType(TIFF* tif)
{
      uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample);

      switch (tif->tif_dir.td_sampleformat) {
      case SAMPLEFORMAT_IEEEFP:
            return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
      case SAMPLEFORMAT_INT:
            return (bps <= 1 ? TIFF_SBYTE :
                bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
      case SAMPLEFORMAT_UINT:
            return (bps <= 1 ? TIFF_BYTE :
                bps <= 2 ? TIFF_SHORT : TIFF_LONG);
      case SAMPLEFORMAT_VOID:
            return (TIFF_UNDEFINED);
      }
      /*NOTREACHED*/
      return (TIFF_UNDEFINED);
}

const TIFFFieldInfo*
_TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
{
      int i, n;

      if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
          (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
            return (tif->tif_foundfield);
      /* NB: use sorted search (e.g. binary search) */
      if(dt != TIFF_ANY) {
            TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
          TIFFFieldInfo* pkey = &key;
          const TIFFFieldInfo **ret;

          key.field_tag = tag;
            key.field_type = dt;

          ret = (const TIFFFieldInfo **) bsearch(&pkey,
                                       tif->tif_fieldinfo, 
                                       tif->tif_nfields,
                                       sizeof(TIFFFieldInfo *), 
                                       tagCompare);
          return (ret) ? (*ret) : NULL;
        } else for (i = 0, n = tif->tif_nfields; i < n; i++) {
            const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
            if (fip->field_tag == tag &&
                (dt == TIFF_ANY || fip->field_type == dt))
                  return (tif->tif_foundfield = fip);
      }
      return ((const TIFFFieldInfo *)0);
}

const TIFFFieldInfo*
_TIFFFindFieldInfoByName(TIFF* tif, const char *field_name, TIFFDataType dt)
{
      int i, n;

      if (tif->tif_foundfield
          && streq(tif->tif_foundfield->field_name, field_name)
          && (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
            return (tif->tif_foundfield);
      /* NB: use sorted search (e.g. binary search) */
      if(dt != TIFF_ANY) {
            TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
          TIFFFieldInfo* pkey = &key;
          const TIFFFieldInfo **ret;

            key.field_name = (char *)field_name;
            key.field_type = dt;

            ret = (const TIFFFieldInfo **) lfind(&pkey,
                                     tif->tif_fieldinfo, 
                                     &tif->tif_nfields,
                                     sizeof(TIFFFieldInfo *),
                                     tagNameCompare);
          return (ret) ? (*ret) : NULL;
        } else
            for (i = 0, n = tif->tif_nfields; i < n; i++) {
                  const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
                  if (streq(fip->field_name, field_name) &&
                      (dt == TIFF_ANY || fip->field_type == dt))
                        return (tif->tif_foundfield = fip);
            }
      return ((const TIFFFieldInfo *)0);
}

const TIFFFieldInfo*
_TIFFFieldWithTag(TIFF* tif, ttag_t tag)
{
      const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
      if (!fip) {
            TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",
                    "Internal error, unknown tag 0x%x",
                          (unsigned int) tag);
            assert(fip != NULL);
            /*NOTREACHED*/
      }
      return (fip);
}

const TIFFFieldInfo*
_TIFFFieldWithName(TIFF* tif, const char *field_name)
{
      const TIFFFieldInfo* fip =
            _TIFFFindFieldInfoByName(tif, field_name, TIFF_ANY);
      if (!fip) {
            TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",
                    "Internal error, unknown tag %s", field_name);
            assert(fip != NULL);
            /*NOTREACHED*/
      }
      return (fip);
}

const TIFFFieldInfo*
_TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )

{
    const TIFFFieldInfo *fld;

    fld = _TIFFFindFieldInfo( tif, tag, dt );
    if( fld == NULL )
    {
        fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
        _TIFFMergeFieldInfo( tif, fld, 1 );
    }

    return fld;
}

TIFFFieldInfo*
_TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
{
      TIFFFieldInfo *fld;
      (void) tif;

      fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo));
      if (fld == NULL)
          return NULL;
      _TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );

      fld->field_tag = tag;
      fld->field_readcount = TIFF_VARIABLE;
      fld->field_writecount = TIFF_VARIABLE;
      fld->field_type = field_type;
      fld->field_bit = FIELD_CUSTOM;
      fld->field_oktochange = TRUE;
      fld->field_passcount = TRUE;
      fld->field_name = (char *) _TIFFmalloc(32);
      if (fld->field_name == NULL) {
          _TIFFfree(fld);
          return NULL;
      }

      /* note that this name is a special sign to TIFFClose() and
       * _TIFFSetupFieldInfo() to free the field
       */
      sprintf(fld->field_name, "Tag %d", (int) tag);

      return fld;    
}

/* vim: set ts=8 sts=8 sw=8 noet: */

Generated by  Doxygen 1.6.0   Back to index