/src/FreeImage/Source/LibTIFF/tif_dirinfo.c

https://bitbucket.org/cabalistic/ogredeps/ · C · 884 lines · 752 code · 47 blank · 85 comment · 46 complexity · c527f0465b4490d235b1c0863b8262ba MD5 · raw file

  1. /* $Id: tif_dirinfo.c,v 1.38 2011/04/10 17:14:09 drolon Exp $ */
  2. /*
  3. * Copyright (c) 1988-1997 Sam Leffler
  4. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  5. *
  6. * Permission to use, copy, modify, distribute, and sell this software and
  7. * its documentation for any purpose is hereby granted without fee, provided
  8. * that (i) the above copyright notices and this permission notice appear in
  9. * all copies of the software and related documentation, and (ii) the names of
  10. * Sam Leffler and Silicon Graphics may not be used in any advertising or
  11. * publicity relating to the software without the specific, prior written
  12. * permission of Sam Leffler and Silicon Graphics.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  15. * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  16. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  17. *
  18. * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  19. * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  20. * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  22. * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  23. * OF THIS SOFTWARE.
  24. */
  25. /*
  26. * TIFF Library.
  27. *
  28. * Core Directory Tag Support.
  29. */
  30. #include "tiffiop.h"
  31. #include <stdlib.h>
  32. #include <string.h>
  33. /*
  34. * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
  35. * If a tag can have both LONG and SHORT types then the LONG must be
  36. * placed before the SHORT for writing to work properly.
  37. *
  38. * NOTE: The second field (field_readcount) and third field (field_writecount)
  39. * sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
  40. * and TIFFTAG_SPP (-2). The macros should be used but would throw off
  41. * the formatting of the code, so please interprete the -1, -2 and -3
  42. * values accordingly.
  43. */
  44. static const TIFFFieldInfo
  45. tiffFieldInfo[] = {
  46. { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, FIELD_SUBFILETYPE,
  47. 1, 0, "SubfileType" },
  48. /* XXX SHORT for compatibility w/ old versions of the library */
  49. { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
  50. 1, 0, "SubfileType" },
  51. { TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
  52. 1, 0, "OldSubfileType" },
  53. { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
  54. 0, 0, "ImageWidth" },
  55. { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
  56. 0, 0, "ImageWidth" },
  57. { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
  58. 1, 0, "ImageLength" },
  59. { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
  60. 1, 0, "ImageLength" },
  61. { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_SHORT, FIELD_BITSPERSAMPLE,
  62. 0, 0, "BitsPerSample" },
  63. /* XXX LONG for compatibility with some broken TIFF writers */
  64. { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_LONG, FIELD_BITSPERSAMPLE,
  65. 0, 0, "BitsPerSample" },
  66. { TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, FIELD_COMPRESSION,
  67. 0, 0, "Compression" },
  68. /* XXX LONG for compatibility with some broken TIFF writers */
  69. { TIFFTAG_COMPRESSION, -1, 1, TIFF_LONG, FIELD_COMPRESSION,
  70. 0, 0, "Compression" },
  71. { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, FIELD_PHOTOMETRIC,
  72. 0, 0, "PhotometricInterpretation" },
  73. /* XXX LONG for compatibility with some broken TIFF writers */
  74. { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_LONG, FIELD_PHOTOMETRIC,
  75. 0, 0, "PhotometricInterpretation" },
  76. { TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, FIELD_THRESHHOLDING,
  77. 1, 0, "Threshholding" },
  78. { TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
  79. 1, 0, "CellWidth" },
  80. { TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
  81. 1, 0, "CellLength" },
  82. { TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, FIELD_FILLORDER,
  83. 0, 0, "FillOrder" },
  84. { TIFFTAG_DOCUMENTNAME, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  85. 1, 0, "DocumentName" },
  86. { TIFFTAG_IMAGEDESCRIPTION, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  87. 1, 0, "ImageDescription" },
  88. { TIFFTAG_MAKE, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  89. 1, 0, "Make" },
  90. { TIFFTAG_MODEL, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  91. 1, 0, "Model" },
  92. { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_LONG, FIELD_STRIPOFFSETS,
  93. 0, 0, "StripOffsets" },
  94. { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_SHORT, FIELD_STRIPOFFSETS,
  95. 0, 0, "StripOffsets" },
  96. { TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, FIELD_ORIENTATION,
  97. 0, 0, "Orientation" },
  98. { TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, FIELD_SAMPLESPERPIXEL,
  99. 0, 0, "SamplesPerPixel" },
  100. { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, FIELD_ROWSPERSTRIP,
  101. 0, 0, "RowsPerStrip" },
  102. { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_SHORT, FIELD_ROWSPERSTRIP,
  103. 0, 0, "RowsPerStrip" },
  104. { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
  105. 0, 0, "StripByteCounts" },
  106. { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
  107. 0, 0, "StripByteCounts" },
  108. { TIFFTAG_MINSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MINSAMPLEVALUE,
  109. 1, 0, "MinSampleValue" },
  110. { TIFFTAG_MAXSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MAXSAMPLEVALUE,
  111. 1, 0, "MaxSampleValue" },
  112. { TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
  113. 1, 0, "XResolution" },
  114. { TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
  115. 1, 0, "YResolution" },
  116. { TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, FIELD_PLANARCONFIG,
  117. 0, 0, "PlanarConfiguration" },
  118. { TIFFTAG_PAGENAME, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  119. 1, 0, "PageName" },
  120. { TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
  121. 1, 0, "XPosition" },
  122. { TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
  123. 1, 0, "YPosition" },
  124. { TIFFTAG_FREEOFFSETS, -1,-1, TIFF_LONG, FIELD_IGNORE,
  125. 0, 0, "FreeOffsets" },
  126. { TIFFTAG_FREEBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_IGNORE,
  127. 0, 0, "FreeByteCounts" },
  128. { TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
  129. 1, 0, "GrayResponseUnit" },
  130. { TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT, FIELD_IGNORE,
  131. 1, 0, "GrayResponseCurve" },
  132. { TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_RESOLUTIONUNIT,
  133. 1, 0, "ResolutionUnit" },
  134. { TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, FIELD_PAGENUMBER,
  135. 1, 0, "PageNumber" },
  136. { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
  137. 1, 0, "ColorResponseUnit" },
  138. { TIFFTAG_TRANSFERFUNCTION, -1,-1, TIFF_SHORT, FIELD_TRANSFERFUNCTION,
  139. 1, 0, "TransferFunction" },
  140. { TIFFTAG_SOFTWARE, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  141. 1, 0, "Software" },
  142. { TIFFTAG_DATETIME, 20,20, TIFF_ASCII, FIELD_CUSTOM,
  143. 1, 0, "DateTime" },
  144. { TIFFTAG_ARTIST, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  145. 1, 0, "Artist" },
  146. { TIFFTAG_HOSTCOMPUTER, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  147. 1, 0, "HostComputer" },
  148. { TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM,
  149. 1, 0, "WhitePoint" },
  150. { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL, FIELD_CUSTOM,
  151. 1, 0, "PrimaryChromaticities" },
  152. { TIFFTAG_COLORMAP, -1,-1, TIFF_SHORT, FIELD_COLORMAP,
  153. 1, 0, "ColorMap" },
  154. { TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, FIELD_HALFTONEHINTS,
  155. 1, 0, "HalftoneHints" },
  156. { TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
  157. 0, 0, "TileWidth" },
  158. { TIFFTAG_TILEWIDTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
  159. 0, 0, "TileWidth" },
  160. { TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
  161. 0, 0, "TileLength" },
  162. { TIFFTAG_TILELENGTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
  163. 0, 0, "TileLength" },
  164. { TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG, FIELD_STRIPOFFSETS,
  165. 0, 0, "TileOffsets" },
  166. { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
  167. 0, 0, "TileByteCounts" },
  168. { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
  169. 0, 0, "TileByteCounts" },
  170. { TIFFTAG_SUBIFD, -1,-1, TIFF_IFD, FIELD_SUBIFD,
  171. 1, 1, "SubIFD" },
  172. { TIFFTAG_SUBIFD, -1,-1, TIFF_LONG, FIELD_SUBIFD,
  173. 1, 1, "SubIFD" },
  174. { TIFFTAG_INKSET, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  175. 0, 0, "InkSet" },
  176. { TIFFTAG_INKNAMES, -1,-1, TIFF_ASCII, FIELD_INKNAMES,
  177. 1, 1, "InkNames" },
  178. { TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  179. 1, 0, "NumberOfInks" },
  180. { TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, FIELD_CUSTOM,
  181. 0, 0, "DotRange" },
  182. { TIFFTAG_DOTRANGE, 2, 2, TIFF_BYTE, FIELD_CUSTOM,
  183. 0, 0, "DotRange" },
  184. { TIFFTAG_TARGETPRINTER, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
  185. 1, 0, "TargetPrinter" },
  186. { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_SHORT, FIELD_EXTRASAMPLES,
  187. 0, 1, "ExtraSamples" },
  188. /* XXX for bogus Adobe Photoshop v2.5 files */
  189. { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_BYTE, FIELD_EXTRASAMPLES,
  190. 0, 1, "ExtraSamples" },
  191. { TIFFTAG_SAMPLEFORMAT, -1,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
  192. 0, 0, "SampleFormat" },
  193. { TIFFTAG_SMINSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMINSAMPLEVALUE,
  194. 1, 0, "SMinSampleValue" },
  195. { TIFFTAG_SMAXSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMAXSAMPLEVALUE,
  196. 1, 0, "SMaxSampleValue" },
  197. { TIFFTAG_CLIPPATH, -1, -3, TIFF_BYTE, FIELD_CUSTOM,
  198. 0, 1, "ClipPath" },
  199. { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SLONG, FIELD_CUSTOM,
  200. 0, 0, "XClipPathUnits" },
  201. { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SSHORT, FIELD_CUSTOM,
  202. 0, 0, "XClipPathUnits" },
  203. { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SBYTE, FIELD_CUSTOM,
  204. 0, 0, "XClipPathUnits" },
  205. { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SLONG, FIELD_CUSTOM,
  206. 0, 0, "YClipPathUnits" },
  207. { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SSHORT, FIELD_CUSTOM,
  208. 0, 0, "YClipPathUnits" },
  209. { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SBYTE, FIELD_CUSTOM,
  210. 0, 0, "YClipPathUnits" },
  211. { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, FIELD_CUSTOM,
  212. 0, 0, "YCbCrCoefficients" },
  213. { TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, FIELD_YCBCRSUBSAMPLING,
  214. 0, 0, "YCbCrSubsampling" },
  215. { TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, FIELD_YCBCRPOSITIONING,
  216. 0, 0, "YCbCrPositioning" },
  217. { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_RATIONAL, FIELD_REFBLACKWHITE,
  218. 1, 0, "ReferenceBlackWhite" },
  219. /* XXX temporarily accept LONG for backwards compatibility */
  220. { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_LONG, FIELD_REFBLACKWHITE,
  221. 1, 0, "ReferenceBlackWhite" },
  222. { TIFFTAG_XMLPACKET, -3,-3, TIFF_BYTE, FIELD_CUSTOM,
  223. 0, 1, "XMLPacket" },
  224. /* begin SGI tags */
  225. { TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, FIELD_EXTRASAMPLES,
  226. 0, 0, "Matteing" },
  227. { TIFFTAG_DATATYPE, -2,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
  228. 0, 0, "DataType" },
  229. { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, FIELD_IMAGEDEPTH,
  230. 0, 0, "ImageDepth" },
  231. { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDEPTH,
  232. 0, 0, "ImageDepth" },
  233. { TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, FIELD_TILEDEPTH,
  234. 0, 0, "TileDepth" },
  235. { TIFFTAG_TILEDEPTH, 1, 1, TIFF_SHORT, FIELD_TILEDEPTH,
  236. 0, 0, "TileDepth" },
  237. /* end SGI tags */
  238. /* begin Pixar tags */
  239. { TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  240. 1, 0, "ImageFullWidth" },
  241. { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  242. 1, 0, "ImageFullLength" },
  243. { TIFFTAG_PIXAR_TEXTUREFORMAT, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  244. 1, 0, "TextureFormat" },
  245. { TIFFTAG_PIXAR_WRAPMODES, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  246. 1, 0, "TextureWrapModes" },
  247. { TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, FIELD_CUSTOM,
  248. 1, 0, "FieldOfViewCotangent" },
  249. { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16, TIFF_FLOAT,
  250. FIELD_CUSTOM, 1, 0, "MatrixWorldToScreen" },
  251. { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16, TIFF_FLOAT,
  252. FIELD_CUSTOM, 1, 0, "MatrixWorldToCamera" },
  253. { TIFFTAG_COPYRIGHT, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  254. 1, 0, "Copyright" },
  255. /* end Pixar tags */
  256. { TIFFTAG_RICHTIFFIPTC, -3, -3, TIFF_LONG, FIELD_CUSTOM,
  257. 0, 1, "RichTIFFIPTC" },
  258. { TIFFTAG_PHOTOSHOP, -3, -3, TIFF_BYTE, FIELD_CUSTOM,
  259. 0, 1, "Photoshop" },
  260. { TIFFTAG_EXIFIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  261. 0, 0, "EXIFIFDOffset" },
  262. { TIFFTAG_ICCPROFILE, -3, -3, TIFF_UNDEFINED, FIELD_CUSTOM,
  263. 0, 1, "ICC Profile" },
  264. { TIFFTAG_GPSIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  265. 0, 0, "GPSIFDOffset" },
  266. { TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, FIELD_CUSTOM,
  267. 0, 0, "StoNits" },
  268. { TIFFTAG_INTEROPERABILITYIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  269. 0, 0, "InteroperabilityIFDOffset" },
  270. /* begin DNG tags */
  271. { TIFFTAG_DNGVERSION, 4, 4, TIFF_BYTE, FIELD_CUSTOM,
  272. 0, 0, "DNGVersion" },
  273. { TIFFTAG_DNGBACKWARDVERSION, 4, 4, TIFF_BYTE, FIELD_CUSTOM,
  274. 0, 0, "DNGBackwardVersion" },
  275. { TIFFTAG_UNIQUECAMERAMODEL, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  276. 1, 0, "UniqueCameraModel" },
  277. { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  278. 1, 0, "LocalizedCameraModel" },
  279. { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_BYTE, FIELD_CUSTOM,
  280. 1, 1, "LocalizedCameraModel" },
  281. { TIFFTAG_CFAPLANECOLOR, -1, -1, TIFF_BYTE, FIELD_CUSTOM,
  282. 0, 1, "CFAPlaneColor" },
  283. { TIFFTAG_CFALAYOUT, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  284. 0, 0, "CFALayout" },
  285. { TIFFTAG_LINEARIZATIONTABLE, -1, -1, TIFF_SHORT, FIELD_CUSTOM,
  286. 0, 1, "LinearizationTable" },
  287. { TIFFTAG_BLACKLEVELREPEATDIM, 2, 2, TIFF_SHORT, FIELD_CUSTOM,
  288. 0, 0, "BlackLevelRepeatDim" },
  289. { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_LONG, FIELD_CUSTOM,
  290. 0, 1, "BlackLevel" },
  291. { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_SHORT, FIELD_CUSTOM,
  292. 0, 1, "BlackLevel" },
  293. { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_RATIONAL, FIELD_CUSTOM,
  294. 0, 1, "BlackLevel" },
  295. { TIFFTAG_BLACKLEVELDELTAH, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  296. 0, 1, "BlackLevelDeltaH" },
  297. { TIFFTAG_BLACKLEVELDELTAV, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  298. 0, 1, "BlackLevelDeltaV" },
  299. { TIFFTAG_WHITELEVEL, -2, -2, TIFF_LONG, FIELD_CUSTOM,
  300. 0, 0, "WhiteLevel" },
  301. { TIFFTAG_WHITELEVEL, -2, -2, TIFF_SHORT, FIELD_CUSTOM,
  302. 0, 0, "WhiteLevel" },
  303. { TIFFTAG_DEFAULTSCALE, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM,
  304. 0, 0, "DefaultScale" },
  305. { TIFFTAG_BESTQUALITYSCALE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  306. 0, 0, "BestQualityScale" },
  307. { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_LONG, FIELD_CUSTOM,
  308. 0, 0, "DefaultCropOrigin" },
  309. { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_SHORT, FIELD_CUSTOM,
  310. 0, 0, "DefaultCropOrigin" },
  311. { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM,
  312. 0, 0, "DefaultCropOrigin" },
  313. { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_LONG, FIELD_CUSTOM,
  314. 0, 0, "DefaultCropSize" },
  315. { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_SHORT, FIELD_CUSTOM,
  316. 0, 0, "DefaultCropSize" },
  317. { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM,
  318. 0, 0, "DefaultCropSize" },
  319. { TIFFTAG_COLORMATRIX1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  320. 0, 1, "ColorMatrix1" },
  321. { TIFFTAG_COLORMATRIX2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  322. 0, 1, "ColorMatrix2" },
  323. { TIFFTAG_CAMERACALIBRATION1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  324. 0, 1, "CameraCalibration1" },
  325. { TIFFTAG_CAMERACALIBRATION2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  326. 0, 1, "CameraCalibration2" },
  327. { TIFFTAG_REDUCTIONMATRIX1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  328. 0, 1, "ReductionMatrix1" },
  329. { TIFFTAG_REDUCTIONMATRIX2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  330. 0, 1, "ReductionMatrix2" },
  331. { TIFFTAG_ANALOGBALANCE, -1, -1, TIFF_RATIONAL, FIELD_CUSTOM,
  332. 0, 1, "AnalogBalance" },
  333. { TIFFTAG_ASSHOTNEUTRAL, -1, -1, TIFF_SHORT, FIELD_CUSTOM,
  334. 0, 1, "AsShotNeutral" },
  335. { TIFFTAG_ASSHOTNEUTRAL, -1, -1, TIFF_RATIONAL, FIELD_CUSTOM,
  336. 0, 1, "AsShotNeutral" },
  337. { TIFFTAG_ASSHOTWHITEXY, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM,
  338. 0, 0, "AsShotWhiteXY" },
  339. { TIFFTAG_BASELINEEXPOSURE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM,
  340. 0, 0, "BaselineExposure" },
  341. { TIFFTAG_BASELINENOISE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  342. 0, 0, "BaselineNoise" },
  343. { TIFFTAG_BASELINESHARPNESS, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  344. 0, 0, "BaselineSharpness" },
  345. { TIFFTAG_BAYERGREENSPLIT, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  346. 0, 0, "BayerGreenSplit" },
  347. { TIFFTAG_LINEARRESPONSELIMIT, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  348. 0, 0, "LinearResponseLimit" },
  349. { TIFFTAG_CAMERASERIALNUMBER, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  350. 1, 0, "CameraSerialNumber" },
  351. { TIFFTAG_LENSINFO, 4, 4, TIFF_RATIONAL, FIELD_CUSTOM,
  352. 0, 0, "LensInfo" },
  353. { TIFFTAG_CHROMABLURRADIUS, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  354. 0, 0, "ChromaBlurRadius" },
  355. { TIFFTAG_ANTIALIASSTRENGTH, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  356. 0, 0, "AntiAliasStrength" },
  357. { TIFFTAG_SHADOWSCALE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  358. 0, 0, "ShadowScale" },
  359. { TIFFTAG_DNGPRIVATEDATA, -1, -1, TIFF_BYTE, FIELD_CUSTOM,
  360. 0, 1, "DNGPrivateData" },
  361. { TIFFTAG_MAKERNOTESAFETY, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  362. 0, 0, "MakerNoteSafety" },
  363. { TIFFTAG_CALIBRATIONILLUMINANT1, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  364. 0, 0, "CalibrationIlluminant1" },
  365. { TIFFTAG_CALIBRATIONILLUMINANT2, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  366. 0, 0, "CalibrationIlluminant2" },
  367. { TIFFTAG_RAWDATAUNIQUEID, 16, 16, TIFF_BYTE, FIELD_CUSTOM,
  368. 0, 0, "RawDataUniqueID" },
  369. { TIFFTAG_ORIGINALRAWFILENAME, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  370. 1, 0, "OriginalRawFileName" },
  371. { TIFFTAG_ORIGINALRAWFILENAME, -1, -1, TIFF_BYTE, FIELD_CUSTOM,
  372. 1, 1, "OriginalRawFileName" },
  373. { TIFFTAG_ORIGINALRAWFILEDATA, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  374. 0, 1, "OriginalRawFileData" },
  375. { TIFFTAG_ACTIVEAREA, 4, 4, TIFF_LONG, FIELD_CUSTOM,
  376. 0, 0, "ActiveArea" },
  377. { TIFFTAG_ACTIVEAREA, 4, 4, TIFF_SHORT, FIELD_CUSTOM,
  378. 0, 0, "ActiveArea" },
  379. { TIFFTAG_MASKEDAREAS, -1, -1, TIFF_LONG, FIELD_CUSTOM,
  380. 0, 1, "MaskedAreas" },
  381. { TIFFTAG_ASSHOTICCPROFILE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  382. 0, 1, "AsShotICCProfile" },
  383. { TIFFTAG_ASSHOTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  384. 0, 1, "AsShotPreProfileMatrix" },
  385. { TIFFTAG_CURRENTICCPROFILE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  386. 0, 1, "CurrentICCProfile" },
  387. { TIFFTAG_CURRENTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM,
  388. 0, 1, "CurrentPreProfileMatrix" },
  389. /* end DNG tags */
  390. };
  391. static const TIFFFieldInfo
  392. exifFieldInfo[] = {
  393. { EXIFTAG_EXPOSURETIME, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  394. 1, 0, "ExposureTime" },
  395. { EXIFTAG_FNUMBER, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  396. 1, 0, "FNumber" },
  397. { EXIFTAG_EXPOSUREPROGRAM, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  398. 1, 0, "ExposureProgram" },
  399. { EXIFTAG_SPECTRALSENSITIVITY, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  400. 1, 0, "SpectralSensitivity" },
  401. { EXIFTAG_ISOSPEEDRATINGS, -1, -1, TIFF_SHORT, FIELD_CUSTOM,
  402. 1, 1, "ISOSpeedRatings" },
  403. { EXIFTAG_OECF, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  404. 1, 1, "OptoelectricConversionFactor" },
  405. { EXIFTAG_EXIFVERSION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM,
  406. 1, 0, "ExifVersion" },
  407. { EXIFTAG_DATETIMEORIGINAL, 20, 20, TIFF_ASCII, FIELD_CUSTOM,
  408. 1, 0, "DateTimeOriginal" },
  409. { EXIFTAG_DATETIMEDIGITIZED, 20, 20, TIFF_ASCII, FIELD_CUSTOM,
  410. 1, 0, "DateTimeDigitized" },
  411. { EXIFTAG_COMPONENTSCONFIGURATION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM,
  412. 1, 0, "ComponentsConfiguration" },
  413. { EXIFTAG_COMPRESSEDBITSPERPIXEL, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  414. 1, 0, "CompressedBitsPerPixel" },
  415. { EXIFTAG_SHUTTERSPEEDVALUE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM,
  416. 1, 0, "ShutterSpeedValue" },
  417. { EXIFTAG_APERTUREVALUE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  418. 1, 0, "ApertureValue" },
  419. { EXIFTAG_BRIGHTNESSVALUE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM,
  420. 1, 0, "BrightnessValue" },
  421. { EXIFTAG_EXPOSUREBIASVALUE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM,
  422. 1, 0, "ExposureBiasValue" },
  423. { EXIFTAG_MAXAPERTUREVALUE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  424. 1, 0, "MaxApertureValue" },
  425. { EXIFTAG_SUBJECTDISTANCE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  426. 1, 0, "SubjectDistance" },
  427. { EXIFTAG_METERINGMODE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  428. 1, 0, "MeteringMode" },
  429. { EXIFTAG_LIGHTSOURCE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  430. 1, 0, "LightSource" },
  431. { EXIFTAG_FLASH, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  432. 1, 0, "Flash" },
  433. { EXIFTAG_FOCALLENGTH, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  434. 1, 0, "FocalLength" },
  435. { EXIFTAG_SUBJECTAREA, -1, -1, TIFF_SHORT, FIELD_CUSTOM,
  436. 1, 1, "SubjectArea" },
  437. { EXIFTAG_MAKERNOTE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  438. 1, 1, "MakerNote" },
  439. { EXIFTAG_USERCOMMENT, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  440. 1, 1, "UserComment" },
  441. { EXIFTAG_SUBSECTIME, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  442. 1, 0, "SubSecTime" },
  443. { EXIFTAG_SUBSECTIMEORIGINAL, -1, -1, TIFF_ASCII, FIELD_CUSTOM,
  444. 1, 0, "SubSecTimeOriginal" },
  445. { EXIFTAG_SUBSECTIMEDIGITIZED,-1, -1, TIFF_ASCII, FIELD_CUSTOM,
  446. 1, 0, "SubSecTimeDigitized" },
  447. { EXIFTAG_FLASHPIXVERSION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM,
  448. 1, 0, "FlashpixVersion" },
  449. { EXIFTAG_COLORSPACE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  450. 1, 0, "ColorSpace" },
  451. { EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  452. 1, 0, "PixelXDimension" },
  453. { EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  454. 1, 0, "PixelXDimension" },
  455. { EXIFTAG_PIXELYDIMENSION, 1, 1, TIFF_LONG, FIELD_CUSTOM,
  456. 1, 0, "PixelYDimension" },
  457. { EXIFTAG_PIXELYDIMENSION, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  458. 1, 0, "PixelYDimension" },
  459. { EXIFTAG_RELATEDSOUNDFILE, 13, 13, TIFF_ASCII, FIELD_CUSTOM,
  460. 1, 0, "RelatedSoundFile" },
  461. { EXIFTAG_FLASHENERGY, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  462. 1, 0, "FlashEnergy" },
  463. { EXIFTAG_SPATIALFREQUENCYRESPONSE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  464. 1, 1, "SpatialFrequencyResponse" },
  465. { EXIFTAG_FOCALPLANEXRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  466. 1, 0, "FocalPlaneXResolution" },
  467. { EXIFTAG_FOCALPLANEYRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  468. 1, 0, "FocalPlaneYResolution" },
  469. { EXIFTAG_FOCALPLANERESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  470. 1, 0, "FocalPlaneResolutionUnit" },
  471. { EXIFTAG_SUBJECTLOCATION, 2, 2, TIFF_SHORT, FIELD_CUSTOM,
  472. 1, 0, "SubjectLocation" },
  473. { EXIFTAG_EXPOSUREINDEX, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  474. 1, 0, "ExposureIndex" },
  475. { EXIFTAG_SENSINGMETHOD, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  476. 1, 0, "SensingMethod" },
  477. { EXIFTAG_FILESOURCE, 1, 1, TIFF_UNDEFINED, FIELD_CUSTOM,
  478. 1, 0, "FileSource" },
  479. { EXIFTAG_SCENETYPE, 1, 1, TIFF_UNDEFINED, FIELD_CUSTOM,
  480. 1, 0, "SceneType" },
  481. { EXIFTAG_CFAPATTERN, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  482. 1, 1, "CFAPattern" },
  483. { EXIFTAG_CUSTOMRENDERED, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  484. 1, 0, "CustomRendered" },
  485. { EXIFTAG_EXPOSUREMODE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  486. 1, 0, "ExposureMode" },
  487. { EXIFTAG_WHITEBALANCE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  488. 1, 0, "WhiteBalance" },
  489. { EXIFTAG_DIGITALZOOMRATIO, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  490. 1, 0, "DigitalZoomRatio" },
  491. { EXIFTAG_FOCALLENGTHIN35MMFILM, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  492. 1, 0, "FocalLengthIn35mmFilm" },
  493. { EXIFTAG_SCENECAPTURETYPE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  494. 1, 0, "SceneCaptureType" },
  495. { EXIFTAG_GAINCONTROL, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM,
  496. 1, 0, "GainControl" },
  497. { EXIFTAG_CONTRAST, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  498. 1, 0, "Contrast" },
  499. { EXIFTAG_SATURATION, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  500. 1, 0, "Saturation" },
  501. { EXIFTAG_SHARPNESS, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  502. 1, 0, "Sharpness" },
  503. { EXIFTAG_DEVICESETTINGDESCRIPTION, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM,
  504. 1, 1, "DeviceSettingDescription" },
  505. { EXIFTAG_SUBJECTDISTANCERANGE, 1, 1, TIFF_SHORT, FIELD_CUSTOM,
  506. 1, 0, "SubjectDistanceRange" },
  507. { EXIFTAG_IMAGEUNIQUEID, 33, 33, TIFF_ASCII, FIELD_CUSTOM,
  508. 1, 0, "ImageUniqueID" }
  509. };
  510. const TIFFFieldInfo *
  511. _TIFFGetFieldInfo(size_t *size)
  512. {
  513. *size = TIFFArrayCount(tiffFieldInfo);
  514. return tiffFieldInfo;
  515. }
  516. const TIFFFieldInfo *
  517. _TIFFGetExifFieldInfo(size_t *size)
  518. {
  519. *size = TIFFArrayCount(exifFieldInfo);
  520. return exifFieldInfo;
  521. }
  522. void
  523. _TIFFSetupFieldInfo(TIFF* tif, const TIFFFieldInfo info[], size_t n)
  524. {
  525. if (tif->tif_fieldinfo) {
  526. size_t i;
  527. for (i = 0; i < tif->tif_nfields; i++)
  528. {
  529. TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
  530. if (fld->field_bit == FIELD_CUSTOM &&
  531. strncmp("Tag ", fld->field_name, 4) == 0) {
  532. _TIFFfree(fld->field_name);
  533. _TIFFfree(fld);
  534. }
  535. }
  536. _TIFFfree(tif->tif_fieldinfo);
  537. tif->tif_nfields = 0;
  538. }
  539. if (!_TIFFMergeFieldInfo(tif, info, n))
  540. {
  541. TIFFErrorExt(tif->tif_clientdata, "_TIFFSetupFieldInfo",
  542. "Setting up field info failed");
  543. }
  544. }
  545. static int
  546. tagCompare(const void* a, const void* b)
  547. {
  548. const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
  549. const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
  550. /* NB: be careful of return values for 16-bit platforms */
  551. if (ta->field_tag != tb->field_tag)
  552. return (int)ta->field_tag - (int)tb->field_tag;
  553. else
  554. return (ta->field_type == TIFF_ANY) ?
  555. 0 : ((int)tb->field_type - (int)ta->field_type);
  556. }
  557. static int
  558. tagNameCompare(const void* a, const void* b)
  559. {
  560. const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
  561. const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
  562. int ret = strcmp(ta->field_name, tb->field_name);
  563. if (ret)
  564. return ret;
  565. else
  566. return (ta->field_type == TIFF_ANY) ?
  567. 0 : ((int)tb->field_type - (int)ta->field_type);
  568. }
  569. void
  570. TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
  571. {
  572. if (_TIFFMergeFieldInfo(tif, info, n) < 0)
  573. {
  574. TIFFErrorExt(tif->tif_clientdata, "TIFFMergeFieldInfo",
  575. "Merging block of %d fields failed", n);
  576. }
  577. }
  578. int
  579. _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
  580. {
  581. static const char module[] = "_TIFFMergeFieldInfo";
  582. static const char reason[] = "for field info array";
  583. TIFFFieldInfo** tp;
  584. int i;
  585. tif->tif_foundfield = NULL;
  586. if (tif->tif_nfields > 0) {
  587. tif->tif_fieldinfo = (TIFFFieldInfo**)
  588. _TIFFCheckRealloc(tif, tif->tif_fieldinfo,
  589. (tif->tif_nfields + n),
  590. sizeof (TIFFFieldInfo*), reason);
  591. } else {
  592. tif->tif_fieldinfo = (TIFFFieldInfo**)
  593. _TIFFCheckMalloc(tif, n, sizeof (TIFFFieldInfo*),
  594. reason);
  595. }
  596. if (!tif->tif_fieldinfo) {
  597. TIFFErrorExt(tif->tif_clientdata, module,
  598. "Failed to allocate field info array");
  599. return 0;
  600. }
  601. tp = tif->tif_fieldinfo + tif->tif_nfields;
  602. for (i = 0; i < n; i++)
  603. {
  604. const TIFFFieldInfo *fip =
  605. _TIFFFindFieldInfo(tif, info[i].field_tag, info[i].field_type);
  606. /* only add definitions that aren't already present */
  607. if (!fip) {
  608. *tp++ = (TIFFFieldInfo*) (info + i);
  609. tif->tif_nfields++;
  610. }
  611. }
  612. /* Sort the field info by tag number */
  613. qsort(tif->tif_fieldinfo, tif->tif_nfields,
  614. sizeof (TIFFFieldInfo*), tagCompare);
  615. return n;
  616. }
  617. void
  618. _TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
  619. {
  620. size_t i;
  621. fprintf(fd, "%s: \n", tif->tif_name);
  622. for (i = 0; i < tif->tif_nfields; i++) {
  623. const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
  624. fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
  625. , (int)i
  626. , (unsigned long) fip->field_tag
  627. , fip->field_readcount, fip->field_writecount
  628. , fip->field_type
  629. , fip->field_bit
  630. , fip->field_oktochange ? "TRUE" : "FALSE"
  631. , fip->field_passcount ? "TRUE" : "FALSE"
  632. , fip->field_name
  633. );
  634. }
  635. }
  636. /*
  637. * Return size of TIFFDataType in bytes
  638. */
  639. int
  640. TIFFDataWidth(TIFFDataType type)
  641. {
  642. switch(type)
  643. {
  644. case 0: /* nothing */
  645. case 1: /* TIFF_BYTE */
  646. case 2: /* TIFF_ASCII */
  647. case 6: /* TIFF_SBYTE */
  648. case 7: /* TIFF_UNDEFINED */
  649. return 1;
  650. case 3: /* TIFF_SHORT */
  651. case 8: /* TIFF_SSHORT */
  652. return 2;
  653. case 4: /* TIFF_LONG */
  654. case 9: /* TIFF_SLONG */
  655. case 11: /* TIFF_FLOAT */
  656. case 13: /* TIFF_IFD */
  657. return 4;
  658. case 5: /* TIFF_RATIONAL */
  659. case 10: /* TIFF_SRATIONAL */
  660. case 12: /* TIFF_DOUBLE */
  661. return 8;
  662. default:
  663. return 0; /* will return 0 for unknown types */
  664. }
  665. }
  666. /*
  667. * Return size of TIFFDataType in bytes.
  668. *
  669. * XXX: We need a separate function to determine the space needed
  670. * to store the value. For TIFF_RATIONAL values TIFFDataWidth() returns 8,
  671. * but we use 4-byte float to represent rationals.
  672. */
  673. int
  674. _TIFFDataSize(TIFFDataType type)
  675. {
  676. switch (type) {
  677. case TIFF_BYTE:
  678. case TIFF_SBYTE:
  679. case TIFF_ASCII:
  680. case TIFF_UNDEFINED:
  681. return 1;
  682. case TIFF_SHORT:
  683. case TIFF_SSHORT:
  684. return 2;
  685. case TIFF_LONG:
  686. case TIFF_SLONG:
  687. case TIFF_FLOAT:
  688. case TIFF_IFD:
  689. case TIFF_RATIONAL:
  690. case TIFF_SRATIONAL:
  691. return 4;
  692. case TIFF_DOUBLE:
  693. return 8;
  694. default:
  695. return 0;
  696. }
  697. }
  698. /*
  699. * Return nearest TIFFDataType to the sample type of an image.
  700. */
  701. TIFFDataType
  702. _TIFFSampleToTagType(TIFF* tif)
  703. {
  704. uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample);
  705. switch (tif->tif_dir.td_sampleformat) {
  706. case SAMPLEFORMAT_IEEEFP:
  707. return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
  708. case SAMPLEFORMAT_INT:
  709. return (bps <= 1 ? TIFF_SBYTE :
  710. bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
  711. case SAMPLEFORMAT_UINT:
  712. return (bps <= 1 ? TIFF_BYTE :
  713. bps <= 2 ? TIFF_SHORT : TIFF_LONG);
  714. case SAMPLEFORMAT_VOID:
  715. return (TIFF_UNDEFINED);
  716. }
  717. /*NOTREACHED*/
  718. return (TIFF_UNDEFINED);
  719. }
  720. const TIFFFieldInfo*
  721. _TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
  722. {
  723. TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
  724. TIFFFieldInfo* pkey = &key;
  725. const TIFFFieldInfo **ret;
  726. if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
  727. (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
  728. return tif->tif_foundfield;
  729. /* If we are invoked with no field information, then just return. */
  730. if ( !tif->tif_fieldinfo ) {
  731. return NULL;
  732. }
  733. /* NB: use sorted search (e.g. binary search) */
  734. key.field_tag = tag;
  735. key.field_type = dt;
  736. ret = (const TIFFFieldInfo **) bsearch(&pkey,
  737. tif->tif_fieldinfo,
  738. tif->tif_nfields,
  739. sizeof(TIFFFieldInfo *),
  740. tagCompare);
  741. return tif->tif_foundfield = (ret ? *ret : NULL);
  742. }
  743. const TIFFFieldInfo*
  744. _TIFFFindFieldInfoByName(TIFF* tif, const char *field_name, TIFFDataType dt)
  745. {
  746. TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0};
  747. TIFFFieldInfo* pkey = &key;
  748. const TIFFFieldInfo **ret;
  749. if (tif->tif_foundfield
  750. && streq(tif->tif_foundfield->field_name, field_name)
  751. && (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
  752. return (tif->tif_foundfield);
  753. /* If we are invoked with no field information, then just return. */
  754. if ( !tif->tif_fieldinfo ) {
  755. return NULL;
  756. }
  757. /* NB: use sorted search (e.g. binary search) */
  758. key.field_name = (char *)field_name;
  759. key.field_type = dt;
  760. ret = (const TIFFFieldInfo **) lfind(&pkey,
  761. tif->tif_fieldinfo,
  762. &tif->tif_nfields,
  763. sizeof(TIFFFieldInfo *),
  764. tagNameCompare);
  765. return tif->tif_foundfield = (ret ? *ret : NULL);
  766. }
  767. const TIFFFieldInfo*
  768. _TIFFFieldWithTag(TIFF* tif, ttag_t tag)
  769. {
  770. const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
  771. if (!fip) {
  772. TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",
  773. "Internal error, unknown tag 0x%x",
  774. (unsigned int) tag);
  775. }
  776. return (fip);
  777. }
  778. const TIFFFieldInfo*
  779. _TIFFFieldWithName(TIFF* tif, const char *field_name)
  780. {
  781. const TIFFFieldInfo* fip =
  782. _TIFFFindFieldInfoByName(tif, field_name, TIFF_ANY);
  783. if (!fip) {
  784. TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",
  785. "Internal error, unknown tag %s", field_name);
  786. }
  787. return (fip);
  788. }
  789. const TIFFFieldInfo*
  790. _TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )
  791. {
  792. const TIFFFieldInfo *fld;
  793. fld = _TIFFFindFieldInfo( tif, tag, dt );
  794. if( fld == NULL )
  795. {
  796. fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
  797. if (!_TIFFMergeFieldInfo(tif, fld, 1))
  798. return NULL;
  799. }
  800. return fld;
  801. }
  802. TIFFFieldInfo*
  803. _TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
  804. {
  805. TIFFFieldInfo *fld;
  806. (void) tif;
  807. fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo));
  808. if (fld == NULL)
  809. return NULL;
  810. _TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );
  811. fld->field_tag = tag;
  812. fld->field_readcount = TIFF_VARIABLE2;
  813. fld->field_writecount = TIFF_VARIABLE2;
  814. fld->field_type = field_type;
  815. fld->field_bit = FIELD_CUSTOM;
  816. fld->field_oktochange = TRUE;
  817. fld->field_passcount = TRUE;
  818. fld->field_name = (char *) _TIFFmalloc(32);
  819. if (fld->field_name == NULL) {
  820. _TIFFfree(fld);
  821. return NULL;
  822. }
  823. /*
  824. * note that this name is a special sign to TIFFClose() and
  825. * _TIFFSetupFieldInfo() to free the field
  826. */
  827. sprintf(fld->field_name, "Tag %d", (int) tag);
  828. return fld;
  829. }
  830. /* vim: set ts=8 sts=8 sw=8 noet: */
  831. /*
  832. * Local Variables:
  833. * mode: c
  834. * c-basic-offset: 8
  835. * fill-column: 78
  836. * End:
  837. */