ReactOS Development > Doxygen

tif_dirinfo.c

00001 /* $Id: tif_dirinfo.c,v 1.65.2.9 2010-06-09 21:15:27 bfriesen Exp $ */
00002 
00003 /*
00004  * Copyright (c) 1988-1997 Sam Leffler
00005  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
00006  *
00007  * Permission to use, copy, modify, distribute, and sell this software and 
00008  * its documentation for any purpose is hereby granted without fee, provided
00009  * that (i) the above copyright notices and this permission notice appear in
00010  * all copies of the software and related documentation, and (ii) the names of
00011  * Sam Leffler and Silicon Graphics may not be used in any advertising or
00012  * publicity relating to the software without the specific, prior written
00013  * permission of Sam Leffler and Silicon Graphics.
00014  * 
00015  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
00016  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
00017  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
00018  * 
00019  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
00020  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
00021  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
00022  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
00023  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
00024  * OF THIS SOFTWARE.
00025  */
00026 
00027 /*
00028  * TIFF Library.
00029  *
00030  * Core Directory Tag Support.
00031  */
00032 #include "tiffiop.h"
00033 #include <stdlib.h>
00034 #include <string.h>
00035 
00036 /*
00037  * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
00038  *       If a tag can have both LONG and SHORT types then the LONG must be
00039  *       placed before the SHORT for writing to work properly.
00040  *
00041  * NOTE: The second field (field_readcount) and third field (field_writecount)
00042  *       sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
00043  *       and TIFFTAG_SPP (-2). The macros should be used but would throw off 
00044  *       the formatting of the code, so please interprete the -1, -2 and -3 
00045  *       values accordingly.
00046  */
00047 static const TIFFFieldInfo
00048 tiffFieldInfo[] = {
00049     { TIFFTAG_SUBFILETYPE,   1, 1,  TIFF_LONG,  FIELD_SUBFILETYPE,
00050       1,    0,  "SubfileType" },
00051 /* XXX SHORT for compatibility w/ old versions of the library */
00052     { TIFFTAG_SUBFILETYPE,   1, 1,  TIFF_SHORT, FIELD_SUBFILETYPE,
00053       1,    0,  "SubfileType" },
00054     { TIFFTAG_OSUBFILETYPE,  1, 1,  TIFF_SHORT, FIELD_SUBFILETYPE,
00055       1,    0,  "OldSubfileType" },
00056     { TIFFTAG_IMAGEWIDTH,    1, 1,  TIFF_LONG,  FIELD_IMAGEDIMENSIONS,
00057       0,    0,  "ImageWidth" },
00058     { TIFFTAG_IMAGEWIDTH,    1, 1,  TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
00059       0,    0,  "ImageWidth" },
00060     { TIFFTAG_IMAGELENGTH,   1, 1,  TIFF_LONG,  FIELD_IMAGEDIMENSIONS,
00061       1,    0,  "ImageLength" },
00062     { TIFFTAG_IMAGELENGTH,   1, 1,  TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
00063       1,    0,  "ImageLength" },
00064     { TIFFTAG_BITSPERSAMPLE,    -1,-1,  TIFF_SHORT, FIELD_BITSPERSAMPLE,
00065       0,    0,  "BitsPerSample" },
00066 /* XXX LONG for compatibility with some broken TIFF writers */
00067     { TIFFTAG_BITSPERSAMPLE,    -1,-1,  TIFF_LONG,  FIELD_BITSPERSAMPLE,
00068       0,    0,  "BitsPerSample" },
00069     { TIFFTAG_COMPRESSION,  -1, 1,  TIFF_SHORT, FIELD_COMPRESSION,
00070       0,    0,  "Compression" },
00071 /* XXX LONG for compatibility with some broken TIFF writers */
00072     { TIFFTAG_COMPRESSION,  -1, 1,  TIFF_LONG,  FIELD_COMPRESSION,
00073       0,    0,  "Compression" },
00074     { TIFFTAG_PHOTOMETRIC,   1, 1,  TIFF_SHORT, FIELD_PHOTOMETRIC,
00075       0,    0,  "PhotometricInterpretation" },
00076 /* XXX LONG for compatibility with some broken TIFF writers */
00077     { TIFFTAG_PHOTOMETRIC,   1, 1,  TIFF_LONG,  FIELD_PHOTOMETRIC,
00078       0,    0,  "PhotometricInterpretation" },
00079     { TIFFTAG_THRESHHOLDING,     1, 1,  TIFF_SHORT, FIELD_THRESHHOLDING,
00080       1,    0,  "Threshholding" },
00081     { TIFFTAG_CELLWIDTH,     1, 1,  TIFF_SHORT, FIELD_IGNORE,
00082       1,    0,  "CellWidth" },
00083     { TIFFTAG_CELLLENGTH,    1, 1,  TIFF_SHORT, FIELD_IGNORE,
00084       1,    0,  "CellLength" },
00085     { TIFFTAG_FILLORDER,     1, 1,  TIFF_SHORT, FIELD_FILLORDER,
00086       0,    0,  "FillOrder" },
00087     { TIFFTAG_DOCUMENTNAME, -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00088       1,    0,  "DocumentName" },
00089     { TIFFTAG_IMAGEDESCRIPTION, -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00090       1,    0,  "ImageDescription" },
00091     { TIFFTAG_MAKE,     -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00092       1,    0,  "Make" },
00093     { TIFFTAG_MODEL,        -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00094       1,    0,  "Model" },
00095     { TIFFTAG_STRIPOFFSETS, -1,-1,  TIFF_LONG,  FIELD_STRIPOFFSETS,
00096       0,    0,  "StripOffsets" },
00097     { TIFFTAG_STRIPOFFSETS, -1,-1,  TIFF_SHORT, FIELD_STRIPOFFSETS,
00098       0,    0,  "StripOffsets" },
00099     { TIFFTAG_ORIENTATION,   1, 1,  TIFF_SHORT, FIELD_ORIENTATION,
00100       0,    0,  "Orientation" },
00101     { TIFFTAG_SAMPLESPERPIXEL,   1, 1,  TIFF_SHORT, FIELD_SAMPLESPERPIXEL,
00102       0,    0,  "SamplesPerPixel" },
00103     { TIFFTAG_ROWSPERSTRIP,  1, 1,  TIFF_LONG,  FIELD_ROWSPERSTRIP,
00104       0,    0,  "RowsPerStrip" },
00105     { TIFFTAG_ROWSPERSTRIP,  1, 1,  TIFF_SHORT, FIELD_ROWSPERSTRIP,
00106       0,    0,  "RowsPerStrip" },
00107     { TIFFTAG_STRIPBYTECOUNTS,  -1,-1,  TIFF_LONG,  FIELD_STRIPBYTECOUNTS,
00108       0,    0,  "StripByteCounts" },
00109     { TIFFTAG_STRIPBYTECOUNTS,  -1,-1,  TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
00110       0,    0,  "StripByteCounts" },
00111     { TIFFTAG_MINSAMPLEVALUE,   -2,-1,  TIFF_SHORT, FIELD_MINSAMPLEVALUE,
00112       1,    0,  "MinSampleValue" },
00113     { TIFFTAG_MAXSAMPLEVALUE,   -2,-1,  TIFF_SHORT, FIELD_MAXSAMPLEVALUE,
00114       1,    0,  "MaxSampleValue" },
00115     { TIFFTAG_XRESOLUTION,   1, 1,  TIFF_RATIONAL,  FIELD_RESOLUTION,
00116       1,    0,  "XResolution" },
00117     { TIFFTAG_YRESOLUTION,   1, 1,  TIFF_RATIONAL,  FIELD_RESOLUTION,
00118       1,    0,  "YResolution" },
00119     { TIFFTAG_PLANARCONFIG,  1, 1,  TIFF_SHORT, FIELD_PLANARCONFIG,
00120       0,    0,  "PlanarConfiguration" },
00121     { TIFFTAG_PAGENAME,     -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00122       1,    0,  "PageName" },
00123     { TIFFTAG_XPOSITION,     1, 1,  TIFF_RATIONAL,  FIELD_POSITION,
00124       1,    0,  "XPosition" },
00125     { TIFFTAG_YPOSITION,     1, 1,  TIFF_RATIONAL,  FIELD_POSITION,
00126       1,    0,  "YPosition" },
00127     { TIFFTAG_FREEOFFSETS,  -1,-1,  TIFF_LONG,  FIELD_IGNORE,
00128       0,    0,  "FreeOffsets" },
00129     { TIFFTAG_FREEBYTECOUNTS,   -1,-1,  TIFF_LONG,  FIELD_IGNORE,
00130       0,    0,  "FreeByteCounts" },
00131     { TIFFTAG_GRAYRESPONSEUNIT,  1, 1,  TIFF_SHORT, FIELD_IGNORE,
00132       1,    0,  "GrayResponseUnit" },
00133     { TIFFTAG_GRAYRESPONSECURVE,-1,-1,  TIFF_SHORT, FIELD_IGNORE,
00134       1,    0,  "GrayResponseCurve" },
00135     { TIFFTAG_RESOLUTIONUNIT,    1, 1,  TIFF_SHORT, FIELD_RESOLUTIONUNIT,
00136       1,    0,  "ResolutionUnit" },
00137     { TIFFTAG_PAGENUMBER,    2, 2,  TIFF_SHORT, FIELD_PAGENUMBER,
00138       1,    0,  "PageNumber" },
00139     { TIFFTAG_COLORRESPONSEUNIT, 1, 1,  TIFF_SHORT, FIELD_IGNORE,
00140       1,    0,  "ColorResponseUnit" },
00141     { TIFFTAG_TRANSFERFUNCTION, -1,-1,  TIFF_SHORT, FIELD_TRANSFERFUNCTION,
00142       1,    0,  "TransferFunction" },
00143     { TIFFTAG_SOFTWARE,     -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00144       1,    0,  "Software" },
00145     { TIFFTAG_DATETIME,     20,20,  TIFF_ASCII, FIELD_CUSTOM,
00146       1,    0,  "DateTime" },
00147     { TIFFTAG_ARTIST,       -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00148       1,    0,  "Artist" },
00149     { TIFFTAG_HOSTCOMPUTER, -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00150       1,    0,  "HostComputer" },
00151     { TIFFTAG_WHITEPOINT,    2, 2,  TIFF_RATIONAL,  FIELD_CUSTOM,
00152       1,    0,  "WhitePoint" },
00153     { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,  FIELD_CUSTOM,
00154       1,    0,  "PrimaryChromaticities" },
00155     { TIFFTAG_COLORMAP,     -1,-1,  TIFF_SHORT, FIELD_COLORMAP,
00156       1,    0,  "ColorMap" },
00157     { TIFFTAG_HALFTONEHINTS,     2, 2,  TIFF_SHORT, FIELD_HALFTONEHINTS,
00158       1,    0,  "HalftoneHints" },
00159     { TIFFTAG_TILEWIDTH,     1, 1,  TIFF_LONG,  FIELD_TILEDIMENSIONS,
00160       0,    0,  "TileWidth" },
00161     { TIFFTAG_TILEWIDTH,     1, 1,  TIFF_SHORT, FIELD_TILEDIMENSIONS,
00162       0,    0,  "TileWidth" },
00163     { TIFFTAG_TILELENGTH,    1, 1,  TIFF_LONG,  FIELD_TILEDIMENSIONS,
00164       0,    0,  "TileLength" },
00165     { TIFFTAG_TILELENGTH,    1, 1,  TIFF_SHORT, FIELD_TILEDIMENSIONS,
00166       0,    0,  "TileLength" },
00167     { TIFFTAG_TILEOFFSETS,  -1, 1,  TIFF_LONG,  FIELD_STRIPOFFSETS,
00168       0,    0,  "TileOffsets" },
00169     { TIFFTAG_TILEBYTECOUNTS,   -1, 1,  TIFF_LONG,  FIELD_STRIPBYTECOUNTS,
00170       0,    0,  "TileByteCounts" },
00171     { TIFFTAG_TILEBYTECOUNTS,   -1, 1,  TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
00172       0,    0,  "TileByteCounts" },
00173     { TIFFTAG_SUBIFD,       -1,-1,  TIFF_IFD,   FIELD_SUBIFD,
00174       1,    1,  "SubIFD" },
00175     { TIFFTAG_SUBIFD,       -1,-1,  TIFF_LONG,  FIELD_SUBIFD,
00176       1,    1,  "SubIFD" },
00177     { TIFFTAG_INKSET,        1, 1,  TIFF_SHORT, FIELD_CUSTOM,
00178       0,    0,  "InkSet" },
00179     { TIFFTAG_INKNAMES,     -1,-1,  TIFF_ASCII, FIELD_INKNAMES,
00180       1,    1,  "InkNames" },
00181     { TIFFTAG_NUMBEROFINKS,  1, 1,  TIFF_SHORT, FIELD_CUSTOM,
00182       1,    0,  "NumberOfInks" },
00183     { TIFFTAG_DOTRANGE,      2, 2,  TIFF_SHORT, FIELD_CUSTOM,
00184       0,    0,  "DotRange" },
00185     { TIFFTAG_DOTRANGE,      2, 2,  TIFF_BYTE,  FIELD_CUSTOM,
00186       0,    0,  "DotRange" },
00187     { TIFFTAG_TARGETPRINTER,    -1,-1,  TIFF_ASCII, FIELD_CUSTOM,
00188       1,    0,  "TargetPrinter" },
00189     { TIFFTAG_EXTRASAMPLES, -1,-1,  TIFF_SHORT, FIELD_EXTRASAMPLES,
00190       0,    1,  "ExtraSamples" },
00191 /* XXX for bogus Adobe Photoshop v2.5 files */
00192     { TIFFTAG_EXTRASAMPLES, -1,-1,  TIFF_BYTE,  FIELD_EXTRASAMPLES,
00193       0,    1,  "ExtraSamples" },
00194     { TIFFTAG_SAMPLEFORMAT, -1,-1,  TIFF_SHORT, FIELD_SAMPLEFORMAT,
00195       0,    0,  "SampleFormat" },
00196     { TIFFTAG_SMINSAMPLEVALUE,  -2,-1,  TIFF_ANY,   FIELD_SMINSAMPLEVALUE,
00197       1,    0,  "SMinSampleValue" },
00198     { TIFFTAG_SMAXSAMPLEVALUE,  -2,-1,  TIFF_ANY,   FIELD_SMAXSAMPLEVALUE,
00199       1,    0,  "SMaxSampleValue" },
00200     { TIFFTAG_CLIPPATH,     -1, -3, TIFF_BYTE,  FIELD_CUSTOM,
00201       0,    1,  "ClipPath" },
00202     { TIFFTAG_XCLIPPATHUNITS,    1, 1,  TIFF_SLONG, FIELD_CUSTOM,
00203       0,    0,  "XClipPathUnits" },
00204     { TIFFTAG_XCLIPPATHUNITS,    1, 1,  TIFF_SSHORT,    FIELD_CUSTOM,
00205       0,    0,  "XClipPathUnits" },
00206     { TIFFTAG_XCLIPPATHUNITS,    1, 1,  TIFF_SBYTE, FIELD_CUSTOM,
00207       0,    0,  "XClipPathUnits" },
00208     { TIFFTAG_YCLIPPATHUNITS,    1, 1,  TIFF_SLONG, FIELD_CUSTOM,
00209       0,    0,  "YClipPathUnits" },
00210     { TIFFTAG_YCLIPPATHUNITS,    1, 1,  TIFF_SSHORT,    FIELD_CUSTOM,
00211       0,    0,  "YClipPathUnits" },
00212     { TIFFTAG_YCLIPPATHUNITS,    1, 1,  TIFF_SBYTE, FIELD_CUSTOM,
00213       0,    0,  "YClipPathUnits" },
00214     { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3,  TIFF_RATIONAL,  FIELD_CUSTOM,
00215       0,    0,  "YCbCrCoefficients" },
00216     { TIFFTAG_YCBCRSUBSAMPLING,  2, 2,  TIFF_SHORT, FIELD_YCBCRSUBSAMPLING,
00217       0,    0,  "YCbCrSubsampling" },
00218     { TIFFTAG_YCBCRPOSITIONING,  1, 1,  TIFF_SHORT, FIELD_YCBCRPOSITIONING,
00219       0,    0,  "YCbCrPositioning" },
00220     { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_RATIONAL, FIELD_REFBLACKWHITE,
00221       1,    0,  "ReferenceBlackWhite" },
00222 /* XXX temporarily accept LONG for backwards compatibility */
00223     { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_LONG, FIELD_REFBLACKWHITE,
00224       1,    0,  "ReferenceBlackWhite" },
00225     { TIFFTAG_XMLPACKET,    -3,-3,  TIFF_BYTE,  FIELD_CUSTOM,
00226       0,    1,  "XMLPacket" },
00227 /* begin SGI tags */
00228     { TIFFTAG_MATTEING,      1, 1,  TIFF_SHORT, FIELD_EXTRASAMPLES,
00229       0,    0,  "Matteing" },
00230     { TIFFTAG_DATATYPE,     -2,-1,  TIFF_SHORT, FIELD_SAMPLEFORMAT,
00231       0,    0,  "DataType" },
00232     { TIFFTAG_IMAGEDEPTH,    1, 1,  TIFF_LONG,  FIELD_IMAGEDEPTH,
00233       0,    0,  "ImageDepth" },
00234     { TIFFTAG_IMAGEDEPTH,    1, 1,  TIFF_SHORT, FIELD_IMAGEDEPTH,
00235       0,    0,  "ImageDepth" },
00236     { TIFFTAG_TILEDEPTH,     1, 1,  TIFF_LONG,  FIELD_TILEDEPTH,
00237       0,    0,  "TileDepth" },
00238     { TIFFTAG_TILEDEPTH,     1, 1,  TIFF_SHORT, FIELD_TILEDEPTH,
00239       0,    0,  "TileDepth" },
00240 /* end SGI tags */
00241 /* begin Pixar tags */
00242     { TIFFTAG_PIXAR_IMAGEFULLWIDTH,  1, 1, TIFF_LONG,   FIELD_CUSTOM,
00243       1,    0,  "ImageFullWidth" },
00244     { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG,   FIELD_CUSTOM,
00245       1,    0,  "ImageFullLength" },
00246     { TIFFTAG_PIXAR_TEXTUREFORMAT,  -1, -1, TIFF_ASCII, FIELD_CUSTOM,
00247       1,    0,  "TextureFormat" },
00248     { TIFFTAG_PIXAR_WRAPMODES,      -1, -1, TIFF_ASCII, FIELD_CUSTOM,
00249       1,    0,  "TextureWrapModes" },
00250     { TIFFTAG_PIXAR_FOVCOT,      1, 1, TIFF_FLOAT,  FIELD_CUSTOM,
00251       1,    0,  "FieldOfViewCotangent" },
00252     { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN,   16,16,  TIFF_FLOAT,
00253       FIELD_CUSTOM, 1,  0,  "MatrixWorldToScreen" },
00254     { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA,   16,16,  TIFF_FLOAT,
00255        FIELD_CUSTOM,    1,  0,  "MatrixWorldToCamera" },
00256     { TIFFTAG_COPYRIGHT,    -1, -1, TIFF_ASCII, FIELD_CUSTOM,
00257       1,    0,  "Copyright" },
00258 /* end Pixar tags */
00259     { TIFFTAG_RICHTIFFIPTC, -3, -3, TIFF_LONG,  FIELD_CUSTOM, 
00260       0,    1,   "RichTIFFIPTC" },
00261     { TIFFTAG_PHOTOSHOP,    -3, -3, TIFF_BYTE,  FIELD_CUSTOM, 
00262       0,    1,   "Photoshop" },
00263     { TIFFTAG_EXIFIFD,      1, 1,   TIFF_LONG,  FIELD_CUSTOM,
00264       0,    0,  "EXIFIFDOffset" },
00265     { TIFFTAG_ICCPROFILE,   -3, -3, TIFF_UNDEFINED, FIELD_CUSTOM,
00266       0,    1,  "ICC Profile" },
00267     { TIFFTAG_GPSIFD,       1, 1,   TIFF_LONG,  FIELD_CUSTOM,
00268       0,    0,  "GPSIFDOffset" },
00269     { TIFFTAG_STONITS,       1, 1,  TIFF_DOUBLE,    FIELD_CUSTOM,
00270       0,    0,  "StoNits" },
00271     { TIFFTAG_INTEROPERABILITYIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM,
00272       0,    0,  "InteroperabilityIFDOffset" },
00273 /* begin DNG tags */
00274     { TIFFTAG_DNGVERSION,   4, 4,   TIFF_BYTE,  FIELD_CUSTOM, 
00275       0,    0,  "DNGVersion" },
00276     { TIFFTAG_DNGBACKWARDVERSION, 4, 4, TIFF_BYTE,  FIELD_CUSTOM, 
00277       0,    0,  "DNGBackwardVersion" },
00278     { TIFFTAG_UNIQUECAMERAMODEL,    -1, -1, TIFF_ASCII, FIELD_CUSTOM,
00279       1,    0,  "UniqueCameraModel" },
00280     { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
00281       1,    0,  "LocalizedCameraModel" },
00282     { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_BYTE,  FIELD_CUSTOM,
00283       1,    1,  "LocalizedCameraModel" },
00284     { TIFFTAG_CFAPLANECOLOR,    -1, -1, TIFF_BYTE,  FIELD_CUSTOM, 
00285       0,    1,  "CFAPlaneColor" },
00286     { TIFFTAG_CFALAYOUT,    1, 1,   TIFF_SHORT, FIELD_CUSTOM, 
00287       0,    0,  "CFALayout" },
00288     { TIFFTAG_LINEARIZATIONTABLE, -1, -1, TIFF_SHORT,   FIELD_CUSTOM, 
00289       0,    1,  "LinearizationTable" },
00290     { TIFFTAG_BLACKLEVELREPEATDIM, 2, 2, TIFF_SHORT,    FIELD_CUSTOM, 
00291       0,    0,  "BlackLevelRepeatDim" },
00292     { TIFFTAG_BLACKLEVEL,   -1, -1, TIFF_LONG,  FIELD_CUSTOM, 
00293       0,    1,  "BlackLevel" },
00294     { TIFFTAG_BLACKLEVEL,   -1, -1, TIFF_SHORT, FIELD_CUSTOM, 
00295       0,    1,  "BlackLevel" },
00296     { TIFFTAG_BLACKLEVEL,   -1, -1, TIFF_RATIONAL,  FIELD_CUSTOM, 
00297       0,    1,  "BlackLevel" },
00298     { TIFFTAG_BLACKLEVELDELTAH, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00299       0,    1,  "BlackLevelDeltaH" },
00300     { TIFFTAG_BLACKLEVELDELTAV, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00301       0,    1,  "BlackLevelDeltaV" },
00302     { TIFFTAG_WHITELEVEL,   -2, -2, TIFF_LONG,  FIELD_CUSTOM, 
00303       0,    0,  "WhiteLevel" },
00304     { TIFFTAG_WHITELEVEL,   -2, -2, TIFF_SHORT, FIELD_CUSTOM, 
00305       0,    0,  "WhiteLevel" },
00306     { TIFFTAG_DEFAULTSCALE, 2, 2,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00307       0,    0,  "DefaultScale" },
00308     { TIFFTAG_BESTQUALITYSCALE, 1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00309       0,    0,  "BestQualityScale" },
00310     { TIFFTAG_DEFAULTCROPORIGIN,    2, 2,   TIFF_LONG,  FIELD_CUSTOM, 
00311       0,    0,  "DefaultCropOrigin" },
00312     { TIFFTAG_DEFAULTCROPORIGIN,    2, 2,   TIFF_SHORT, FIELD_CUSTOM, 
00313       0,    0,  "DefaultCropOrigin" },
00314     { TIFFTAG_DEFAULTCROPORIGIN,    2, 2,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00315       0,    0,  "DefaultCropOrigin" },
00316     { TIFFTAG_DEFAULTCROPSIZE,  2, 2,   TIFF_LONG,  FIELD_CUSTOM, 
00317       0,    0,  "DefaultCropSize" },
00318     { TIFFTAG_DEFAULTCROPSIZE,  2, 2,   TIFF_SHORT, FIELD_CUSTOM, 
00319       0,    0,  "DefaultCropSize" },
00320     { TIFFTAG_DEFAULTCROPSIZE,  2, 2,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00321       0,    0,  "DefaultCropSize" },
00322     { TIFFTAG_COLORMATRIX1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00323       0,    1,  "ColorMatrix1" },
00324     { TIFFTAG_COLORMATRIX2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00325       0,    1,  "ColorMatrix2" },
00326     { TIFFTAG_CAMERACALIBRATION1,   -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00327       0,    1,  "CameraCalibration1" },
00328     { TIFFTAG_CAMERACALIBRATION2,   -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00329       0,    1,  "CameraCalibration2" },
00330     { TIFFTAG_REDUCTIONMATRIX1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00331       0,    1,  "ReductionMatrix1" },
00332     { TIFFTAG_REDUCTIONMATRIX2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00333       0,    1,  "ReductionMatrix2" },
00334     { TIFFTAG_ANALOGBALANCE,    -1, -1, TIFF_RATIONAL,  FIELD_CUSTOM, 
00335       0,    1,  "AnalogBalance" },
00336     { TIFFTAG_ASSHOTNEUTRAL,    -1, -1, TIFF_SHORT, FIELD_CUSTOM, 
00337       0,    1,  "AsShotNeutral" },
00338     { TIFFTAG_ASSHOTNEUTRAL,    -1, -1, TIFF_RATIONAL,  FIELD_CUSTOM, 
00339       0,    1,  "AsShotNeutral" },
00340     { TIFFTAG_ASSHOTWHITEXY,    2, 2,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00341       0,    0,  "AsShotWhiteXY" },
00342     { TIFFTAG_BASELINEEXPOSURE, 1, 1,   TIFF_SRATIONAL, FIELD_CUSTOM, 
00343       0,    0,  "BaselineExposure" },
00344     { TIFFTAG_BASELINENOISE,    1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00345       0,    0,  "BaselineNoise" },
00346     { TIFFTAG_BASELINESHARPNESS,    1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00347       0,    0,  "BaselineSharpness" },
00348     { TIFFTAG_BAYERGREENSPLIT,  1, 1,   TIFF_LONG,  FIELD_CUSTOM, 
00349       0,    0,  "BayerGreenSplit" },
00350     { TIFFTAG_LINEARRESPONSELIMIT,  1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00351       0,    0,  "LinearResponseLimit" },
00352     { TIFFTAG_CAMERASERIALNUMBER,    -1, -1, TIFF_ASCII,    FIELD_CUSTOM,
00353       1,    0,  "CameraSerialNumber" },
00354     { TIFFTAG_LENSINFO, 4, 4,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00355       0,    0,  "LensInfo" },
00356     { TIFFTAG_CHROMABLURRADIUS, 1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00357       0,    0,  "ChromaBlurRadius" },
00358     { TIFFTAG_ANTIALIASSTRENGTH,    1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00359       0,    0,  "AntiAliasStrength" },
00360     { TIFFTAG_SHADOWSCALE,  1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00361       0,    0,  "ShadowScale" },
00362     { TIFFTAG_DNGPRIVATEDATA,    -1, -1, TIFF_BYTE, FIELD_CUSTOM,
00363       0,    1,  "DNGPrivateData" },
00364     { TIFFTAG_MAKERNOTESAFETY,  1, 1,   TIFF_SHORT, FIELD_CUSTOM, 
00365       0,    0,  "MakerNoteSafety" },
00366     { TIFFTAG_CALIBRATIONILLUMINANT1,   1, 1,   TIFF_SHORT, FIELD_CUSTOM, 
00367       0,    0,  "CalibrationIlluminant1" },
00368     { TIFFTAG_CALIBRATIONILLUMINANT2,   1, 1,   TIFF_SHORT, FIELD_CUSTOM, 
00369       0,    0,  "CalibrationIlluminant2" },
00370     { TIFFTAG_RAWDATAUNIQUEID,  16, 16, TIFF_BYTE,  FIELD_CUSTOM, 
00371       0,    0,  "RawDataUniqueID" },
00372     { TIFFTAG_ORIGINALRAWFILENAME,    -1, -1, TIFF_ASCII,   FIELD_CUSTOM,
00373       1,    0,  "OriginalRawFileName" },
00374     { TIFFTAG_ORIGINALRAWFILENAME,    -1, -1, TIFF_BYTE,    FIELD_CUSTOM,
00375       1,    1,  "OriginalRawFileName" },
00376     { TIFFTAG_ORIGINALRAWFILEDATA,    -1, -1, TIFF_UNDEFINED,   FIELD_CUSTOM,
00377       0,    1,  "OriginalRawFileData" },
00378     { TIFFTAG_ACTIVEAREA,   4, 4,   TIFF_LONG,  FIELD_CUSTOM, 
00379       0,    0,  "ActiveArea" },
00380     { TIFFTAG_ACTIVEAREA,   4, 4,   TIFF_SHORT, FIELD_CUSTOM, 
00381       0,    0,  "ActiveArea" },
00382     { TIFFTAG_MASKEDAREAS,  -1, -1, TIFF_LONG,  FIELD_CUSTOM, 
00383       0,    1,  "MaskedAreas" },
00384     { TIFFTAG_ASSHOTICCPROFILE,    -1, -1, TIFF_UNDEFINED,  FIELD_CUSTOM,
00385       0,    1,  "AsShotICCProfile" },
00386     { TIFFTAG_ASSHOTPREPROFILEMATRIX,   -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00387       0,    1,  "AsShotPreProfileMatrix" },
00388     { TIFFTAG_CURRENTICCPROFILE,    -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
00389       0,    1,  "CurrentICCProfile" },
00390     { TIFFTAG_CURRENTPREPROFILEMATRIX,  -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, 
00391       0,    1,  "CurrentPreProfileMatrix" },
00392 /* end DNG tags */
00393 };
00394 
00395 static const TIFFFieldInfo
00396 exifFieldInfo[] = {
00397     { EXIFTAG_EXPOSURETIME, 1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00398       1,    0,  "ExposureTime" },
00399     { EXIFTAG_FNUMBER,      1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00400       1,    0,  "FNumber" },
00401     { EXIFTAG_EXPOSUREPROGRAM,  1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00402       1,    0,  "ExposureProgram" },
00403     { EXIFTAG_SPECTRALSENSITIVITY,    -1, -1,   TIFF_ASCII, FIELD_CUSTOM,
00404       1,    0,  "SpectralSensitivity" },
00405     { EXIFTAG_ISOSPEEDRATINGS,  -1, -1,     TIFF_SHORT, FIELD_CUSTOM,
00406       1,    1,  "ISOSpeedRatings" },
00407     { EXIFTAG_OECF, -1, -1,         TIFF_UNDEFINED, FIELD_CUSTOM,
00408       1,    1,  "OptoelectricConversionFactor" },
00409     { EXIFTAG_EXIFVERSION,  4, 4,       TIFF_UNDEFINED, FIELD_CUSTOM,
00410       1,    0,  "ExifVersion" },
00411     { EXIFTAG_DATETIMEORIGINAL, 20, 20,     TIFF_ASCII, FIELD_CUSTOM,
00412       1,    0,  "DateTimeOriginal" },
00413     { EXIFTAG_DATETIMEDIGITIZED, 20, 20,    TIFF_ASCII, FIELD_CUSTOM,
00414       1,    0,  "DateTimeDigitized" },
00415     { EXIFTAG_COMPONENTSCONFIGURATION,   4, 4,  TIFF_UNDEFINED, FIELD_CUSTOM,
00416       1,    0,  "ComponentsConfiguration" },
00417     { EXIFTAG_COMPRESSEDBITSPERPIXEL,    1, 1,  TIFF_RATIONAL,  FIELD_CUSTOM,
00418       1,    0,  "CompressedBitsPerPixel" },
00419     { EXIFTAG_SHUTTERSPEEDVALUE,    1, 1,   TIFF_SRATIONAL, FIELD_CUSTOM, 
00420       1,    0,  "ShutterSpeedValue" },
00421     { EXIFTAG_APERTUREVALUE,    1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00422       1,    0,  "ApertureValue" },
00423     { EXIFTAG_BRIGHTNESSVALUE,  1, 1,       TIFF_SRATIONAL, FIELD_CUSTOM, 
00424       1,    0,  "BrightnessValue" },
00425     { EXIFTAG_EXPOSUREBIASVALUE,    1, 1,   TIFF_SRATIONAL, FIELD_CUSTOM, 
00426       1,    0,  "ExposureBiasValue" },
00427     { EXIFTAG_MAXAPERTUREVALUE, 1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00428       1,    0,  "MaxApertureValue" },
00429     { EXIFTAG_SUBJECTDISTANCE,  1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00430       1,    0,  "SubjectDistance" },
00431     { EXIFTAG_METERINGMODE, 1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00432       1,    0,  "MeteringMode" },
00433     { EXIFTAG_LIGHTSOURCE,  1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00434       1,    0,  "LightSource" },
00435     { EXIFTAG_FLASH,    1, 1,           TIFF_SHORT, FIELD_CUSTOM,
00436       1,    0,  "Flash" },
00437     { EXIFTAG_FOCALLENGTH,  1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00438       1,    0,  "FocalLength" },
00439     { EXIFTAG_SUBJECTAREA,  -1, -1,     TIFF_SHORT, FIELD_CUSTOM,
00440       1,    1,  "SubjectArea" },
00441     { EXIFTAG_MAKERNOTE,    -1, -1,     TIFF_UNDEFINED, FIELD_CUSTOM,
00442       1,    1,  "MakerNote" },
00443     { EXIFTAG_USERCOMMENT,  -1, -1,     TIFF_UNDEFINED, FIELD_CUSTOM,
00444       1,    1,  "UserComment" },
00445     { EXIFTAG_SUBSECTIME,    -1, -1,        TIFF_ASCII, FIELD_CUSTOM,
00446       1,    0,  "SubSecTime" },
00447     { EXIFTAG_SUBSECTIMEORIGINAL, -1, -1,   TIFF_ASCII, FIELD_CUSTOM,
00448       1,    0,  "SubSecTimeOriginal" },
00449     { EXIFTAG_SUBSECTIMEDIGITIZED,-1, -1,   TIFF_ASCII, FIELD_CUSTOM,
00450       1,    0,  "SubSecTimeDigitized" },
00451     { EXIFTAG_FLASHPIXVERSION,  4, 4,       TIFF_UNDEFINED, FIELD_CUSTOM,
00452       1,    0,  "FlashpixVersion" },
00453     { EXIFTAG_COLORSPACE,   1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00454       1,    0,  "ColorSpace" },
00455     { EXIFTAG_PIXELXDIMENSION,  1, 1,       TIFF_LONG,  FIELD_CUSTOM,
00456       1,    0,  "PixelXDimension" },
00457     { EXIFTAG_PIXELXDIMENSION,  1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00458       1,    0,  "PixelXDimension" },
00459     { EXIFTAG_PIXELYDIMENSION,  1, 1,       TIFF_LONG,  FIELD_CUSTOM,
00460       1,    0,  "PixelYDimension" },
00461     { EXIFTAG_PIXELYDIMENSION,  1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00462       1,    0,  "PixelYDimension" },
00463     { EXIFTAG_RELATEDSOUNDFILE, 13, 13,     TIFF_ASCII, FIELD_CUSTOM,
00464       1,    0,  "RelatedSoundFile" },
00465     { EXIFTAG_FLASHENERGY,  1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00466       1,    0,  "FlashEnergy" },
00467     { EXIFTAG_SPATIALFREQUENCYRESPONSE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
00468       1,    1,  "SpatialFrequencyResponse" },
00469     { EXIFTAG_FOCALPLANEXRESOLUTION,    1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00470       1,    0,  "FocalPlaneXResolution" },
00471     { EXIFTAG_FOCALPLANEYRESOLUTION,    1, 1,   TIFF_RATIONAL,  FIELD_CUSTOM, 
00472       1,    0,  "FocalPlaneYResolution" },
00473     { EXIFTAG_FOCALPLANERESOLUTIONUNIT, 1, 1,   TIFF_SHORT, FIELD_CUSTOM,
00474       1,    0,  "FocalPlaneResolutionUnit" },
00475     { EXIFTAG_SUBJECTLOCATION,  2, 2,       TIFF_SHORT, FIELD_CUSTOM,
00476       1,    0,  "SubjectLocation" },
00477     { EXIFTAG_EXPOSUREINDEX,    1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00478       1,    0,  "ExposureIndex" },
00479     { EXIFTAG_SENSINGMETHOD,    1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00480       1,    0,  "SensingMethod" },
00481     { EXIFTAG_FILESOURCE,   1, 1,       TIFF_UNDEFINED, FIELD_CUSTOM,
00482       1,    0,  "FileSource" },
00483     { EXIFTAG_SCENETYPE,    1, 1,       TIFF_UNDEFINED, FIELD_CUSTOM,
00484       1,    0,  "SceneType" },
00485     { EXIFTAG_CFAPATTERN,   -1, -1,     TIFF_UNDEFINED, FIELD_CUSTOM,
00486       1,    1,  "CFAPattern" },
00487     { EXIFTAG_CUSTOMRENDERED,   1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00488       1,    0,  "CustomRendered" },
00489     { EXIFTAG_EXPOSUREMODE, 1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00490       1,    0,  "ExposureMode" },
00491     { EXIFTAG_WHITEBALANCE, 1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00492       1,    0,  "WhiteBalance" },
00493     { EXIFTAG_DIGITALZOOMRATIO, 1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00494       1,    0,  "DigitalZoomRatio" },
00495     { EXIFTAG_FOCALLENGTHIN35MMFILM, 1, 1,  TIFF_SHORT, FIELD_CUSTOM,
00496       1,    0,  "FocalLengthIn35mmFilm" },
00497     { EXIFTAG_SCENECAPTURETYPE, 1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00498       1,    0,  "SceneCaptureType" },
00499     { EXIFTAG_GAINCONTROL,  1, 1,       TIFF_RATIONAL,  FIELD_CUSTOM, 
00500       1,    0,  "GainControl" },
00501     { EXIFTAG_CONTRAST,     1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00502       1,    0,  "Contrast" },
00503     { EXIFTAG_SATURATION,   1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00504       1,    0,  "Saturation" },
00505     { EXIFTAG_SHARPNESS,    1, 1,       TIFF_SHORT, FIELD_CUSTOM,
00506       1,    0,  "Sharpness" },
00507     { EXIFTAG_DEVICESETTINGDESCRIPTION, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
00508       1,    1,  "DeviceSettingDescription" },
00509     { EXIFTAG_SUBJECTDISTANCERANGE, 1, 1,   TIFF_SHORT, FIELD_CUSTOM,
00510       1,    0,  "SubjectDistanceRange" },
00511     { EXIFTAG_IMAGEUNIQUEID,    33, 33,     TIFF_ASCII, FIELD_CUSTOM,
00512       1,    0,  "ImageUniqueID" }
00513 };
00514 
00515 const TIFFFieldInfo *
00516 _TIFFGetFieldInfo(size_t *size)
00517 {
00518     *size = TIFFArrayCount(tiffFieldInfo);
00519     return tiffFieldInfo;
00520 }
00521 
00522 const TIFFFieldInfo *
00523 _TIFFGetExifFieldInfo(size_t *size)
00524 {
00525     *size = TIFFArrayCount(exifFieldInfo);
00526     return exifFieldInfo;
00527 }
00528 
00529 void
00530 _TIFFSetupFieldInfo(TIFF* tif, const TIFFFieldInfo info[], size_t n)
00531 {
00532     if (tif->tif_fieldinfo) {
00533         size_t  i;
00534 
00535         for (i = 0; i < tif->tif_nfields; i++) 
00536         {
00537             TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
00538             if (fld->field_bit == FIELD_CUSTOM && 
00539                 strncmp("Tag ", fld->field_name, 4) == 0) {
00540                     _TIFFfree(fld->field_name);
00541                     _TIFFfree(fld);
00542                 }
00543         }   
00544       
00545         _TIFFfree(tif->tif_fieldinfo);
00546         tif->tif_nfields = 0;
00547     }
00548     if (!_TIFFMergeFieldInfo(tif, info, n))
00549     {
00550         TIFFErrorExt(tif->tif_clientdata, "_TIFFSetupFieldInfo",
00551                  "Setting up field info failed");
00552     }
00553 }
00554 
00555 static int
00556 tagCompare(const void* a, const void* b)
00557 {
00558     const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
00559     const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
00560     /* NB: be careful of return values for 16-bit platforms */
00561     if (ta->field_tag != tb->field_tag)
00562         return (int)ta->field_tag - (int)tb->field_tag;
00563     else
00564         return (ta->field_type == TIFF_ANY) ?
00565             0 : ((int)tb->field_type - (int)ta->field_type);
00566 }
00567 
00568 static int
00569 tagNameCompare(const void* a, const void* b)
00570 {
00571     const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
00572     const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
00573     int ret = strcmp(ta->field_name, tb->field_name);
00574 
00575     if (ret)
00576         return ret;
00577     else
00578         return (ta->field_type == TIFF_ANY) ?
00579             0 : ((int)tb->field_type - (int)ta->field_type);
00580 }
00581 
00582 void
00583 TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
00584 {
00585     if (_TIFFMergeFieldInfo(tif, info, n) < 0)
00586     {
00587         TIFFErrorExt(tif->tif_clientdata, "TIFFMergeFieldInfo",
00588                  "Merging block of %d fields failed", n);
00589     }
00590 }
00591 
00592 int
00593 _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
00594 {
00595     static const char module[] = "_TIFFMergeFieldInfo";
00596     static const char reason[] = "for field info array";
00597     TIFFFieldInfo** tp;
00598     int i;
00599 
00600         tif->tif_foundfield = NULL;
00601 
00602     if (tif->tif_nfields > 0) {
00603         tif->tif_fieldinfo = (TIFFFieldInfo**)
00604             _TIFFCheckRealloc(tif, tif->tif_fieldinfo,
00605                       (tif->tif_nfields + n),
00606                       sizeof (TIFFFieldInfo*), reason);
00607     } else {
00608         tif->tif_fieldinfo = (TIFFFieldInfo**)
00609             _TIFFCheckMalloc(tif, n, sizeof (TIFFFieldInfo*),
00610                      reason);
00611     }
00612     if (!tif->tif_fieldinfo) {
00613         TIFFErrorExt(tif->tif_clientdata, module,
00614                  "Failed to allocate field info array");
00615         return 0;
00616     }
00617     tp = tif->tif_fieldinfo + tif->tif_nfields;
00618     for (i = 0; i < n; i++)
00619         {
00620             const TIFFFieldInfo *fip =
00621                 _TIFFFindFieldInfo(tif, info[i].field_tag, info[i].field_type);
00622 
00623             /* only add definitions that aren't already present */
00624             if (!fip) {
00625                 *tp++ = (TIFFFieldInfo*) (info + i);
00626                 tif->tif_nfields++;
00627             }
00628         }
00629 
00630         /* Sort the field info by tag number */
00631         qsort(tif->tif_fieldinfo, tif->tif_nfields,
00632           sizeof (TIFFFieldInfo*), tagCompare);
00633 
00634     return n;
00635 }
00636 
00637 void
00638 _TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
00639 {
00640     size_t i;
00641 
00642     fprintf(fd, "%s: \n", tif->tif_name);
00643     for (i = 0; i < tif->tif_nfields; i++) {
00644         const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
00645         fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
00646             , (int)i
00647             , (unsigned long) fip->field_tag
00648             , fip->field_readcount, fip->field_writecount
00649             , fip->field_type
00650             , fip->field_bit
00651             , fip->field_oktochange ? "TRUE" : "FALSE"
00652             , fip->field_passcount ? "TRUE" : "FALSE"
00653             , fip->field_name
00654         );
00655     }
00656 }
00657 
00658 /*
00659  * Return size of TIFFDataType in bytes
00660  */
00661 int
00662 TIFFDataWidth(TIFFDataType type)
00663 {
00664     switch(type)
00665     {
00666     case 0:  /* nothing */
00667     case 1:  /* TIFF_BYTE */
00668     case 2:  /* TIFF_ASCII */
00669     case 6:  /* TIFF_SBYTE */
00670     case 7:  /* TIFF_UNDEFINED */
00671         return 1;
00672     case 3:  /* TIFF_SHORT */
00673     case 8:  /* TIFF_SSHORT */
00674         return 2;
00675     case 4:  /* TIFF_LONG */
00676     case 9:  /* TIFF_SLONG */
00677     case 11: /* TIFF_FLOAT */
00678         case 13: /* TIFF_IFD */
00679         return 4;
00680     case 5:  /* TIFF_RATIONAL */
00681     case 10: /* TIFF_SRATIONAL */
00682     case 12: /* TIFF_DOUBLE */
00683         return 8;
00684     default:
00685         return 0; /* will return 0 for unknown types */
00686     }
00687 }
00688 
00689 /*
00690  * Return size of TIFFDataType in bytes.
00691  *
00692  * XXX: We need a separate function to determine the space needed
00693  * to store the value. For TIFF_RATIONAL values TIFFDataWidth() returns 8,
00694  * but we use 4-byte float to represent rationals.
00695  */
00696 int
00697 _TIFFDataSize(TIFFDataType type)
00698 {
00699     switch (type) {
00700         case TIFF_BYTE:
00701         case TIFF_SBYTE:
00702         case TIFF_ASCII:
00703         case TIFF_UNDEFINED:
00704             return 1;
00705         case TIFF_SHORT:
00706         case TIFF_SSHORT:
00707             return 2;
00708         case TIFF_LONG:
00709         case TIFF_SLONG:
00710         case TIFF_FLOAT:
00711         case TIFF_IFD:
00712         case TIFF_RATIONAL:
00713         case TIFF_SRATIONAL:
00714             return 4;
00715         case TIFF_DOUBLE:
00716             return 8;
00717         default:
00718             return 0;
00719     }
00720 }
00721 
00722 /*
00723  * Return nearest TIFFDataType to the sample type of an image.
00724  */
00725 TIFFDataType
00726 _TIFFSampleToTagType(TIFF* tif)
00727 {
00728     uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample);
00729 
00730     switch (tif->tif_dir.td_sampleformat) {
00731     case SAMPLEFORMAT_IEEEFP:
00732         return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
00733     case SAMPLEFORMAT_INT:
00734         return (bps <= 1 ? TIFF_SBYTE :
00735             bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
00736     case SAMPLEFORMAT_UINT:
00737         return (bps <= 1 ? TIFF_BYTE :
00738             bps <= 2 ? TIFF_SHORT : TIFF_LONG);
00739     case SAMPLEFORMAT_VOID:
00740         return (TIFF_UNDEFINED);
00741     }
00742     /*NOTREACHED*/
00743     return (TIFF_UNDEFINED);
00744 }
00745 
00746 const TIFFFieldInfo*
00747 _TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
00748 {
00749         TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
00750     TIFFFieldInfo* pkey = &key;
00751     const TIFFFieldInfo **ret;
00752 
00753     if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
00754         (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
00755         return tif->tif_foundfield;
00756 
00757     /* If we are invoked with no field information, then just return. */
00758     if ( !tif->tif_fieldinfo ) {
00759         return NULL;
00760     }
00761 
00762     /* NB: use sorted search (e.g. binary search) */
00763     key.field_tag = tag;
00764         key.field_type = dt;
00765 
00766     ret = (const TIFFFieldInfo **) bsearch(&pkey,
00767                            tif->tif_fieldinfo, 
00768                            tif->tif_nfields,
00769                            sizeof(TIFFFieldInfo *), 
00770                            tagCompare);
00771     return tif->tif_foundfield = (ret ? *ret : NULL);
00772 }
00773 
00774 const TIFFFieldInfo*
00775 _TIFFFindFieldInfoByName(TIFF* tif, const char *field_name, TIFFDataType dt)
00776 {
00777         TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
00778     TIFFFieldInfo* pkey = &key;
00779     const TIFFFieldInfo **ret;
00780 
00781     if (tif->tif_foundfield
00782         && streq(tif->tif_foundfield->field_name, field_name)
00783         && (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
00784         return (tif->tif_foundfield);
00785 
00786     /* If we are invoked with no field information, then just return. */
00787     if ( !tif->tif_fieldinfo ) {
00788         return NULL;
00789     }
00790 
00791     /* NB: use sorted search (e.g. binary search) */
00792         key.field_name = (char *)field_name;
00793         key.field_type = dt;
00794 
00795         ret = (const TIFFFieldInfo **) lfind(&pkey,
00796                          tif->tif_fieldinfo, 
00797                          &tif->tif_nfields,
00798                          sizeof(TIFFFieldInfo *),
00799                          tagNameCompare);
00800     return tif->tif_foundfield = (ret ? *ret : NULL);
00801 }
00802 
00803 const TIFFFieldInfo*
00804 _TIFFFieldWithTag(TIFF* tif, ttag_t tag)
00805 {
00806     const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
00807     if (!fip) {
00808         TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",
00809                  "Internal error, unknown tag 0x%x",
00810                  (unsigned int) tag);
00811         assert(fip != NULL);
00812         /*NOTREACHED*/
00813     }
00814     return (fip);
00815 }
00816 
00817 const TIFFFieldInfo*
00818 _TIFFFieldWithName(TIFF* tif, const char *field_name)
00819 {
00820     const TIFFFieldInfo* fip =
00821         _TIFFFindFieldInfoByName(tif, field_name, TIFF_ANY);
00822     if (!fip) {
00823         TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",
00824                  "Internal error, unknown tag %s", field_name);
00825         assert(fip != NULL);
00826         /*NOTREACHED*/
00827     }
00828     return (fip);
00829 }
00830 
00831 const TIFFFieldInfo*
00832 _TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )
00833 
00834 {
00835     const TIFFFieldInfo *fld;
00836 
00837     fld = _TIFFFindFieldInfo( tif, tag, dt );
00838     if( fld == NULL )
00839     {
00840         fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
00841         if (!_TIFFMergeFieldInfo(tif, fld, 1))
00842         return NULL;
00843     }
00844 
00845     return fld;
00846 }
00847 
00848 TIFFFieldInfo*
00849 _TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
00850 {
00851     TIFFFieldInfo *fld;
00852     (void) tif;
00853 
00854     fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo));
00855     if (fld == NULL)
00856         return NULL;
00857     _TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );
00858 
00859     fld->field_tag = tag;
00860     fld->field_readcount = TIFF_VARIABLE2;
00861     fld->field_writecount = TIFF_VARIABLE2;
00862     fld->field_type = field_type;
00863     fld->field_bit = FIELD_CUSTOM;
00864     fld->field_oktochange = TRUE;
00865     fld->field_passcount = TRUE;
00866     fld->field_name = (char *) _TIFFmalloc(32);
00867     if (fld->field_name == NULL) {
00868         _TIFFfree(fld);
00869         return NULL;
00870     }
00871 
00872     /* 
00873      * note that this name is a special sign to TIFFClose() and
00874      * _TIFFSetupFieldInfo() to free the field
00875      */
00876     sprintf(fld->field_name, "Tag %d", (int) tag);
00877 
00878     return fld;    
00879 }
00880 
00881 /* vim: set ts=8 sts=8 sw=8 noet: */
00882 /*
00883  * Local Variables:
00884  * mode: c
00885  * c-basic-offset: 8
00886  * fill-column: 78
00887  * End:
00888  */
Generated on Tue May 15 04:41:29 2012 for ReactOS by
1.6.3