~ubuntu-branches/ubuntu/utopic/tiff/utopic-security : revision 40

1

/* $Id: tif_dirinfo.c,v 1.117 2012-08-19 16:56:34 bfriesen Exp $ */

2

3

/*

4

5

6

*

7

* Permission to use, copy, modify, distribute, and sell this software and

8

* its documentation for any purpose is hereby granted without fee, provided

9

* that (i) the above copyright notices and this permission notice appear in

10

* all copies of the software and related documentation, and (ii) the names of

11

* Sam Leffler and Silicon Graphics may not be used in any advertising or

12

* publicity relating to the software without the specific, prior written

13

* permission of Sam Leffler and Silicon Graphics.

14

*

15

* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

16

* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

17

* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

18

*

19

* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR

20

* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

21

* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

22

* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

23

* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

24

* OF THIS SOFTWARE.

25

*/

26

27

/*

28

* TIFF Library.

29

*

30

* Core Directory Tag Support.

31

*/

32

#include "tiffiop.h"

33

#include <stdlib.h>

34

35

/*

36

* NOTE: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.

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 TIFF_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

45

static TIFFFieldArray tiffFieldArray;

46

static TIFFFieldArray exifFieldArray;

47

48

static TIFFField

49

tiffFields[] = {

50

{ TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_SUBFILETYPE, 1, 0, "SubfileType", NULL },

51

{ TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_SUBFILETYPE, 1, 0, "OldSubfileType", NULL },

52

{ TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_IMAGEDIMENSIONS, 0, 0, "ImageWidth", NULL },

53

{ TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_IMAGEDIMENSIONS, 1, 0, "ImageLength", NULL },

54

{ TIFFTAG_BITSPERSAMPLE, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_BITSPERSAMPLE, 0, 0, "BitsPerSample", NULL },

55

{ TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_COMPRESSION, 0, 0, "Compression", NULL },

56

{ TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_PHOTOMETRIC, 0, 0, "PhotometricInterpretation", NULL },

57

{ TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_THRESHHOLDING, 1, 0, "Threshholding", NULL },

58

{ TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "CellWidth", NULL },

59

{ TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "CellLength", NULL },

60

{ TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_FILLORDER, 0, 0, "FillOrder", NULL },

61

{ TIFFTAG_DOCUMENTNAME, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DocumentName", NULL },

62

{ TIFFTAG_IMAGEDESCRIPTION, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageDescription", NULL },

63

{ TIFFTAG_MAKE, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Make", NULL },

64

{ TIFFTAG_MODEL, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Model", NULL },

65

{ TIFFTAG_STRIPOFFSETS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPOFFSETS, 0, 0, "StripOffsets", NULL },

66

{ TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_ORIENTATION, 0, 0, "Orientation", NULL },

67

{ TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_SAMPLESPERPIXEL, 0, 0, "SamplesPerPixel", NULL },

68

{ TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_ROWSPERSTRIP, 0, 0, "RowsPerStrip", NULL },

69

{ TIFFTAG_STRIPBYTECOUNTS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPBYTECOUNTS, 0, 0, "StripByteCounts", NULL },

70

{ TIFFTAG_MINSAMPLEVALUE, -2, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_MINSAMPLEVALUE, 1, 0, "MinSampleValue", NULL },

71

{ TIFFTAG_MAXSAMPLEVALUE, -2, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_MAXSAMPLEVALUE, 1, 0, "MaxSampleValue", NULL },

72

{ TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_RESOLUTION, 1, 0, "XResolution", NULL },

73

{ TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_RESOLUTION, 1, 0, "YResolution", NULL },

74

{ TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_PLANARCONFIG, 0, 0, "PlanarConfiguration", NULL },

75

{ TIFFTAG_PAGENAME, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PageName", NULL },

76

{ TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_POSITION, 1, 0, "XPosition", NULL },

77

{ TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_POSITION, 1, 0, "YPosition", NULL },

78

{ TIFFTAG_FREEOFFSETS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 0, 0, "FreeOffsets", NULL },

79

{ TIFFTAG_FREEBYTECOUNTS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 0, 0, "FreeByteCounts", NULL },

80

{ TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "GrayResponseUnit", NULL },

81

{ TIFFTAG_GRAYRESPONSECURVE, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "GrayResponseCurve", NULL },

82

{ TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_RESOLUTIONUNIT, 1, 0, "ResolutionUnit", NULL },

83

{ TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_PAGENUMBER, 1, 0, "PageNumber", NULL },

84

{ TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "ColorResponseUnit", NULL },

85

{ TIFFTAG_TRANSFERFUNCTION, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_TRANSFERFUNCTION, 1, 0, "TransferFunction", NULL },

86

{ TIFFTAG_SOFTWARE, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Software", NULL },

87

{ TIFFTAG_DATETIME, 20, 20, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DateTime", NULL },

88

{ TIFFTAG_ARTIST, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Artist", NULL },

89

{ TIFFTAG_HOSTCOMPUTER, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "HostComputer", NULL },

90

{ TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "WhitePoint", NULL },

91

{ TIFFTAG_PRIMARYCHROMATICITIES, 6, 6, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PrimaryChromaticities", NULL },

92

{ TIFFTAG_COLORMAP, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_COLORMAP, 1, 0, "ColorMap", NULL },

93

{ TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_HALFTONEHINTS, 1, 0, "HalftoneHints", NULL },

94

{ TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_TILEDIMENSIONS, 0, 0, "TileWidth", NULL },

95

{ TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_TILEDIMENSIONS, 0, 0, "TileLength", NULL },

96

{ TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPOFFSETS, 0, 0, "TileOffsets", NULL },

97

{ TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPBYTECOUNTS, 0, 0, "TileByteCounts", NULL },

98

{ TIFFTAG_SUBIFD, -1, -1, TIFF_IFD8, 0, TIFF_SETGET_C16_IFD8, TIFF_SETGET_UNDEFINED, FIELD_SUBIFD, 1, 1, "SubIFD", &tiffFieldArray },

99

{ TIFFTAG_INKSET, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "InkSet", NULL },

100

{ TIFFTAG_INKNAMES, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_C16_ASCII, TIFF_SETGET_UNDEFINED, FIELD_INKNAMES, 1, 1, "InkNames", NULL },

101

{ TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "NumberOfInks", NULL },

102

{ TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DotRange", NULL },

103

{ TIFFTAG_TARGETPRINTER, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "TargetPrinter", NULL },

104

{ TIFFTAG_EXTRASAMPLES, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_EXTRASAMPLES, 0, 1, "ExtraSamples", NULL },

105

{ TIFFTAG_SAMPLEFORMAT, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_SAMPLEFORMAT, 0, 0, "SampleFormat", NULL },

106

{ TIFFTAG_SMINSAMPLEVALUE, -2, -1, TIFF_ANY, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_SMINSAMPLEVALUE, 1, 0, "SMinSampleValue", NULL },

107

{ TIFFTAG_SMAXSAMPLEVALUE, -2, -1, TIFF_ANY, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_SMAXSAMPLEVALUE, 1, 0, "SMaxSampleValue", NULL },

108

{ TIFFTAG_CLIPPATH, -1, -3, TIFF_BYTE, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ClipPath", NULL },

109

{ TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SLONG, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "XClipPathUnits", NULL },

110

{ TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SBYTE, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "XClipPathUnits", NULL },

111

{ TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SLONG, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "YClipPathUnits", NULL },

112

{ TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "YCbCrCoefficients", NULL },

113

{ TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_YCBCRSUBSAMPLING, 0, 0, "YCbCrSubsampling", NULL },

114

{ TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_YCBCRPOSITIONING, 0, 0, "YCbCrPositioning", NULL },

115

{ TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_REFBLACKWHITE, 1, 0, "ReferenceBlackWhite", NULL },

116

{ TIFFTAG_XMLPACKET, -3, -3, TIFF_BYTE, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "XMLPacket", NULL },

117

/* begin SGI tags */

118

{ TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_EXTRASAMPLES, 0, 0, "Matteing", NULL },

119

{ TIFFTAG_DATATYPE, -2, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_SAMPLEFORMAT, 0, 0, "DataType", NULL },

120

{ TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_IMAGEDEPTH, 0, 0, "ImageDepth", NULL },

121

{ TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_TILEDEPTH, 0, 0, "TileDepth", NULL },

122

/* end SGI tags */

123

/* begin Pixar tags */

124

{ TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageFullWidth", NULL },

125

{ TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageFullLength", NULL },

126

{ TIFFTAG_PIXAR_TEXTUREFORMAT, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "TextureFormat", NULL },

127

{ TIFFTAG_PIXAR_WRAPMODES, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "TextureWrapModes", NULL },

128

{ TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, 0, TIFF_SETGET_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FieldOfViewCotangent", NULL },

129

{ TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16, 16, TIFF_FLOAT, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MatrixWorldToScreen", NULL },

130

{ TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16, 16, TIFF_FLOAT, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MatrixWorldToCamera", NULL },

131

{ TIFFTAG_COPYRIGHT, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Copyright", NULL },

132

/* end Pixar tags */

133

{ TIFFTAG_RICHTIFFIPTC, -3, -3, TIFF_LONG, 0, TIFF_SETGET_C32_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "RichTIFFIPTC", NULL },

134

{ TIFFTAG_PHOTOSHOP, -3, -3, TIFF_BYTE, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "Photoshop", NULL },

135

{ TIFFTAG_EXIFIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "EXIFIFDOffset", &exifFieldArray },

136

{ TIFFTAG_ICCPROFILE, -3, -3, TIFF_UNDEFINED, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ICC Profile", NULL },

137

{ TIFFTAG_GPSIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "GPSIFDOffset", NULL },

138

{ TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_CUSTOM, TRUE, FALSE, "FaxRecvParams", NULL },

139

{ TIFFTAG_FAXSUBADDRESS, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_ASCII, FIELD_CUSTOM, TRUE, FALSE, "FaxSubAddress", NULL },

140

{ TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_CUSTOM, TRUE, FALSE, "FaxRecvTime", NULL },

141

{ TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_ASCII, FIELD_CUSTOM, TRUE, FALSE, "FaxDcs", NULL },

142

{ TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "StoNits", NULL },

143

{ TIFFTAG_INTEROPERABILITYIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "InteroperabilityIFDOffset", NULL },

144

/* begin DNG tags */

145

{ TIFFTAG_DNGVERSION, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DNGVersion", NULL },

146

{ TIFFTAG_DNGBACKWARDVERSION, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DNGBackwardVersion", NULL },

147

{ TIFFTAG_UNIQUECAMERAMODEL, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "UniqueCameraModel", NULL },

148

{ TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "LocalizedCameraModel", NULL },

149

{ TIFFTAG_CFAPLANECOLOR, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CFAPlaneColor", NULL },

150

{ TIFFTAG_CFALAYOUT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CFALayout", NULL },

151

{ TIFFTAG_LINEARIZATIONTABLE, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "LinearizationTable", NULL },

152

{ TIFFTAG_BLACKLEVELREPEATDIM, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_C0_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BlackLevelRepeatDim", NULL },

153

{ TIFFTAG_BLACKLEVEL, -1, -1, TIFF_RATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "BlackLevel", NULL },

154

{ TIFFTAG_BLACKLEVELDELTAH, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "BlackLevelDeltaH", NULL },

155

{ TIFFTAG_BLACKLEVELDELTAV, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "BlackLevelDeltaV", NULL },

156

{ TIFFTAG_WHITELEVEL, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "WhiteLevel", NULL },

157

{ TIFFTAG_DEFAULTSCALE, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DefaultScale", NULL },

158

{ TIFFTAG_BESTQUALITYSCALE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BestQualityScale", NULL },

159

{ TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DefaultCropOrigin", NULL },

160

{ TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DefaultCropSize", NULL },

161

{ TIFFTAG_COLORMATRIX1, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ColorMatrix1", NULL },

162

{ TIFFTAG_COLORMATRIX2, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ColorMatrix2", NULL },

163

{ TIFFTAG_CAMERACALIBRATION1, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CameraCalibration1", NULL },

164

{ TIFFTAG_CAMERACALIBRATION2, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CameraCalibration2", NULL },

165

{ TIFFTAG_REDUCTIONMATRIX1, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ReductionMatrix1", NULL },

166

{ TIFFTAG_REDUCTIONMATRIX2, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ReductionMatrix2", NULL },

167

{ TIFFTAG_ANALOGBALANCE, -1, -1, TIFF_RATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AnalogBalance", NULL },

168

{ TIFFTAG_ASSHOTNEUTRAL, -1, -1, TIFF_RATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AsShotNeutral", NULL },

169

{ TIFFTAG_ASSHOTWHITEXY, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "AsShotWhiteXY", NULL },

170

{ TIFFTAG_BASELINEEXPOSURE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BaselineExposure", NULL },

171

{ TIFFTAG_BASELINENOISE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BaselineNoise", NULL },

172

{ TIFFTAG_BASELINESHARPNESS, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BaselineSharpness", NULL },

173

{ TIFFTAG_BAYERGREENSPLIT, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BayerGreenSplit", NULL },

174

{ TIFFTAG_LINEARRESPONSELIMIT, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "LinearResponseLimit", NULL },

175

{ TIFFTAG_CAMERASERIALNUMBER, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "CameraSerialNumber", NULL },

176

{ TIFFTAG_LENSINFO, 4, 4, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "LensInfo", NULL },

177

{ TIFFTAG_CHROMABLURRADIUS, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ChromaBlurRadius", NULL },

178

{ TIFFTAG_ANTIALIASSTRENGTH, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "AntiAliasStrength", NULL },

179

{ TIFFTAG_SHADOWSCALE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ShadowScale", NULL },

180

{ TIFFTAG_DNGPRIVATEDATA, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "DNGPrivateData", NULL },

181

{ TIFFTAG_MAKERNOTESAFETY, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "MakerNoteSafety", NULL },

182

{ TIFFTAG_CALIBRATIONILLUMINANT1, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CalibrationIlluminant1", NULL },

183

{ TIFFTAG_CALIBRATIONILLUMINANT2, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CalibrationIlluminant2", NULL },

184

{ TIFFTAG_RAWDATAUNIQUEID, 16, 16, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "RawDataUniqueID", NULL },

185

{ TIFFTAG_ORIGINALRAWFILENAME, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "OriginalRawFileName", NULL },

186

{ TIFFTAG_ORIGINALRAWFILEDATA, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "OriginalRawFileData", NULL },

187

{ TIFFTAG_ACTIVEAREA, 4, 4, TIFF_LONG, 0, TIFF_SETGET_C0_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ActiveArea", NULL },

188

{ TIFFTAG_MASKEDAREAS, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "MaskedAreas", NULL },

189

{ TIFFTAG_ASSHOTICCPROFILE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AsShotICCProfile", NULL },

190

{ TIFFTAG_ASSHOTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AsShotPreProfileMatrix", NULL },

191

{ TIFFTAG_CURRENTICCPROFILE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CurrentICCProfile", NULL },

192

{ TIFFTAG_CURRENTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CurrentPreProfileMatrix", NULL },

193

{ TIFFTAG_PERSAMPLE, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "PerSample", NULL},

194

/* end DNG tags */

195

/* begin TIFF/FX tags */

196

{ TIFFTAG_INDEXED, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "Indexed" },

197

{ TIFFTAG_GLOBALPARAMETERSIFD, 1, 1, TIFF_IFD, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "GlobalParametersIFD", NULL },

198

{ TIFFTAG_PROFILETYPE, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ProfileType", NULL },

199

{ TIFFTAG_FAXPROFILE, 1, 1, TIFF_BYTE, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "FaxProfile", NULL },

200

{ TIFFTAG_CODINGMETHODS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CodingMethods", NULL },

201

{ TIFFTAG_VERSIONYEAR, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "VersionYear", NULL },

202

{ TIFFTAG_MODENUMBER, 1, 1, TIFF_BYTE, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ModeNumber", NULL },

203

{ TIFFTAG_DECODE, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "Decode", NULL },

204

{ TIFFTAG_IMAGEBASECOLOR, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ImageBaseColor", NULL },

205

{ TIFFTAG_T82OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "T82Options", NULL },

206

{ TIFFTAG_STRIPROWCOUNTS, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "StripRowCounts", NULL },

207

{ TIFFTAG_IMAGELAYER, 2, 2, TIFF_LONG, 0, TIFF_SETGET_C0_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ImageLayer", NULL },

208

/* end DNG tags */

209

/* begin pseudo tags */

210

};

211

212

static TIFFField

213

exifFields[] = {

214

{ EXIFTAG_EXPOSURETIME, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureTime", NULL },

215

{ EXIFTAG_FNUMBER, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FNumber", NULL },

216

{ EXIFTAG_EXPOSUREPROGRAM, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureProgram", NULL },

217

{ EXIFTAG_SPECTRALSENSITIVITY, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SpectralSensitivity", NULL },

218

{ EXIFTAG_ISOSPEEDRATINGS, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "ISOSpeedRatings", NULL },

219

{ EXIFTAG_OECF, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "OptoelectricConversionFactor", NULL },

220

{ EXIFTAG_EXIFVERSION, 4, 4, TIFF_UNDEFINED, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExifVersion", NULL },

221

{ EXIFTAG_DATETIMEORIGINAL, 20, 20, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DateTimeOriginal", NULL },

222

{ EXIFTAG_DATETIMEDIGITIZED, 20, 20, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DateTimeDigitized", NULL },

223

{ EXIFTAG_COMPONENTSCONFIGURATION, 4, 4, TIFF_UNDEFINED, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ComponentsConfiguration", NULL },

224

{ EXIFTAG_COMPRESSEDBITSPERPIXEL, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "CompressedBitsPerPixel", NULL },

225

{ EXIFTAG_SHUTTERSPEEDVALUE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ShutterSpeedValue", NULL },

226

{ EXIFTAG_APERTUREVALUE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ApertureValue", NULL },

227

{ EXIFTAG_BRIGHTNESSVALUE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "BrightnessValue", NULL },

228

{ EXIFTAG_EXPOSUREBIASVALUE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureBiasValue", NULL },

229

{ EXIFTAG_MAXAPERTUREVALUE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MaxApertureValue", NULL },

230

{ EXIFTAG_SUBJECTDISTANCE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubjectDistance", NULL },

231

{ EXIFTAG_METERINGMODE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MeteringMode", NULL },

232

{ EXIFTAG_LIGHTSOURCE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "LightSource", NULL },

233

{ EXIFTAG_FLASH, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Flash", NULL },

234

{ EXIFTAG_FOCALLENGTH, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalLength", NULL },

235

{ EXIFTAG_SUBJECTAREA, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "SubjectArea", NULL },

236

{ EXIFTAG_MAKERNOTE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "MakerNote", NULL },

237

{ EXIFTAG_USERCOMMENT, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "UserComment", NULL },

238

{ EXIFTAG_SUBSECTIME, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubSecTime", NULL },

239

{ EXIFTAG_SUBSECTIMEORIGINAL, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubSecTimeOriginal", NULL },

240

{ EXIFTAG_SUBSECTIMEDIGITIZED, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubSecTimeDigitized", NULL },

241

{ EXIFTAG_FLASHPIXVERSION, 4, 4, TIFF_UNDEFINED, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FlashpixVersion", NULL },

242

{ EXIFTAG_COLORSPACE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ColorSpace", NULL },

243

{ EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PixelXDimension", NULL },

244

{ EXIFTAG_PIXELYDIMENSION, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PixelYDimension", NULL },

245

{ EXIFTAG_RELATEDSOUNDFILE, 13, 13, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "RelatedSoundFile", NULL },

246

{ EXIFTAG_FLASHENERGY, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FlashEnergy", NULL },

247

{ EXIFTAG_SPATIALFREQUENCYRESPONSE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "SpatialFrequencyResponse", NULL },

248

{ EXIFTAG_FOCALPLANEXRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalPlaneXResolution", NULL },

249

{ EXIFTAG_FOCALPLANEYRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalPlaneYResolution", NULL },

250

{ EXIFTAG_FOCALPLANERESOLUTIONUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalPlaneResolutionUnit", NULL },

251

{ EXIFTAG_SUBJECTLOCATION, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_C0_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubjectLocation", NULL },

252

{ EXIFTAG_EXPOSUREINDEX, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureIndex", NULL },

253

{ EXIFTAG_SENSINGMETHOD, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SensingMethod", NULL },

254

{ EXIFTAG_FILESOURCE, 1, 1, TIFF_UNDEFINED, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FileSource", NULL },

255

{ EXIFTAG_SCENETYPE, 1, 1, TIFF_UNDEFINED, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SceneType", NULL },

256

{ EXIFTAG_CFAPATTERN, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "CFAPattern", NULL },

257

{ EXIFTAG_CUSTOMRENDERED, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "CustomRendered", NULL },

258

{ EXIFTAG_EXPOSUREMODE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureMode", NULL },

259

{ EXIFTAG_WHITEBALANCE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "WhiteBalance", NULL },

260

{ EXIFTAG_DIGITALZOOMRATIO, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DigitalZoomRatio", NULL },

261

{ EXIFTAG_FOCALLENGTHIN35MMFILM, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalLengthIn35mmFilm", NULL },

262

{ EXIFTAG_SCENECAPTURETYPE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SceneCaptureType", NULL },

263

{ EXIFTAG_GAINCONTROL, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "GainControl", NULL },

264

{ EXIFTAG_CONTRAST, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Contrast", NULL },

265

{ EXIFTAG_SATURATION, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Saturation", NULL },

266

{ EXIFTAG_SHARPNESS, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Sharpness", NULL },

267

{ EXIFTAG_DEVICESETTINGDESCRIPTION, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "DeviceSettingDescription", NULL },

268

{ EXIFTAG_SUBJECTDISTANCERANGE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubjectDistanceRange", NULL },

269

{ EXIFTAG_IMAGEUNIQUEID, 33, 33, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageUniqueID", NULL }

270

};

271

272

static TIFFFieldArray

273

tiffFieldArray = { tfiatImage, 0, TIFFArrayCount(tiffFields), tiffFields };

274

static TIFFFieldArray

275

exifFieldArray = { tfiatExif, 0, TIFFArrayCount(exifFields), exifFields };

276

277

/*

278

* We have our own local lfind() equivelent to avoid subtle differences

279

* in types passed to lfind() on different systems.

280

*/

281

282

static void *

283

td_lfind(const void *key, const void *base, size_t *nmemb, size_t size,

284

int(*compar)(const void *, const void *))

285

{

286

char *element, *end;

287

288

end = (char *)base + *nmemb * size;

289

for (element = (char *)base; element < end; element += size)

290

if (!compar(key, element)) /* key found */

291

return element;

292

293

return NULL;

294

}

295

296

const TIFFFieldArray*

297

_TIFFGetFields(void)

298

{

299

return(&tiffFieldArray);

300

}

301

302

const TIFFFieldArray*

303

_TIFFGetExifFields(void)

304

{

305

return(&exifFieldArray);

306

}

307

308

void

309

_TIFFSetupFields(TIFF* tif, const TIFFFieldArray* fieldarray)

310

{

311

if (tif->tif_fields && tif->tif_nfields > 0) {

312

uint32 i;

313

314

for (i = 0; i < tif->tif_nfields; i++) {

315

TIFFField *fld = tif->tif_fields[i];

316

if (fld->field_bit == FIELD_CUSTOM &&

317

strncmp("Tag ", fld->field_name, 4) == 0) {

318

_TIFFfree(fld->field_name);

319

_TIFFfree(fld);

320

}

321

}

322

323

_TIFFfree(tif->tif_fields);

324

tif->tif_fields = NULL;

325

tif->tif_nfields = 0;

326

}

327

if (!_TIFFMergeFields(tif, fieldarray->fields, fieldarray->count)) {

328

TIFFErrorExt(tif->tif_clientdata, "_TIFFSetupFields",

329

"Setting up field info failed");

330

}

331

}

332

333

static int

334

tagCompare(const void* a, const void* b)

335

{

336

const TIFFField* ta = *(const TIFFField**) a;

337

const TIFFField* tb = *(const TIFFField**) b;

338

/* NB: be careful of return values for 16-bit platforms */

339

if (ta->field_tag != tb->field_tag)

340

return (int)ta->field_tag - (int)tb->field_tag;

341

else

342

return (ta->field_type == TIFF_ANY) ?

343

0 : ((int)tb->field_type - (int)ta->field_type);

344

}

345

346

static int

347

tagNameCompare(const void* a, const void* b)

348

{

349

const TIFFField* ta = *(const TIFFField**) a;

350

const TIFFField* tb = *(const TIFFField**) b;

351

int ret = strcmp(ta->field_name, tb->field_name);

352

353

if (ret)

354

return ret;

355

else

356

return (ta->field_type == TIFF_ANY) ?

357

0 : ((int)tb->field_type - (int)ta->field_type);

358

}

359

360

int

361

_TIFFMergeFields(TIFF* tif, const TIFFField info[], uint32 n)

362

{

363

static const char module[] = "_TIFFMergeFields";

364

static const char reason[] = "for fields array";

365

/* TIFFField** tp; */

366

uint32 i;

367

368

tif->tif_foundfield = NULL;

369

370

if (tif->tif_fields && tif->tif_nfields > 0) {

371

tif->tif_fields = (TIFFField**)

372

_TIFFCheckRealloc(tif, tif->tif_fields,

373

(tif->tif_nfields + n),

374

sizeof(TIFFField *), reason);

375

} else {

376

tif->tif_fields = (TIFFField **)

377

_TIFFCheckMalloc(tif, n, sizeof(TIFFField *),

378

reason);

379

}

380

if (!tif->tif_fields) {

381

TIFFErrorExt(tif->tif_clientdata, module,

382

"Failed to allocate fields array");

383

return 0;

384

}

385

386

/* tp = tif->tif_fields + tif->tif_nfields; */

387

for (i = 0; i < n; i++) {

388

const TIFFField *fip =

389

TIFFFindField(tif, info[i].field_tag, TIFF_ANY);

390

391

/* only add definitions that aren't already present */

392

if (!fip) {

393

tif->tif_fields[tif->tif_nfields] = (TIFFField *) (info+i);

394

tif->tif_nfields++;

395

}

396

}

397

398

/* Sort the field info by tag number */

399

qsort(tif->tif_fields, tif->tif_nfields,

400

sizeof(TIFFField *), tagCompare);

401

402

return n;

403

}

404

405

void

406

_TIFFPrintFieldInfo(TIFF* tif, FILE* fd)

407

{

408

uint32 i;

409

410

fprintf(fd, "%s: \n", tif->tif_name);

411

for (i = 0; i < tif->tif_nfields; i++) {

412

const TIFFField* fip = tif->tif_fields[i];

413

fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"

414

, (int)i

415

, (unsigned long) fip->field_tag

416

, fip->field_readcount, fip->field_writecount

417

, fip->field_type

418

, fip->field_bit

419

, fip->field_oktochange ? "TRUE" : "FALSE"

420

, fip->field_passcount ? "TRUE" : "FALSE"

421

, fip->field_name

422

);

423

}

424

}

425

426

/*

427

* Return size of TIFFDataType in bytes

428

*/

429

int

430

TIFFDataWidth(TIFFDataType type)

431

{

432

switch(type)

433

{

434

case 0: /* nothing */

435

case TIFF_BYTE:

436

case TIFF_ASCII:

437

case TIFF_SBYTE:

438

case TIFF_UNDEFINED:

439

return 1;

440

case TIFF_SHORT:

441

case TIFF_SSHORT:

442

return 2;

443

case TIFF_LONG:

444

case TIFF_SLONG:

445

case TIFF_FLOAT:

446

case TIFF_IFD:

447

return 4;

448

case TIFF_RATIONAL:

449

case TIFF_SRATIONAL:

450

case TIFF_DOUBLE:

451

case TIFF_LONG8:

452

case TIFF_SLONG8:

453

case TIFF_IFD8:

454

return 8;

455

default:

456

return 0; /* will return 0 for unknown types */

457

}

458

}

459

460

/*

461

* Return size of TIFFDataType in bytes.

462

*

463

* XXX: We need a separate function to determine the space needed

464

* to store the value. For TIFF_RATIONAL values TIFFDataWidth() returns 8,

465

* but we use 4-byte float to represent rationals.

466

*/

467

int

468

_TIFFDataSize(TIFFDataType type)

469

{

470

switch (type)

471

{

472

case TIFF_BYTE:

473

case TIFF_SBYTE:

474

case TIFF_ASCII:

475

case TIFF_UNDEFINED:

476

return 1;

477

case TIFF_SHORT:

478

case TIFF_SSHORT:

479

return 2;

480

case TIFF_LONG:

481

case TIFF_SLONG:

482

case TIFF_FLOAT:

483

case TIFF_IFD:

484

case TIFF_RATIONAL:

485

case TIFF_SRATIONAL:

486

return 4;

487

case TIFF_DOUBLE:

488

case TIFF_LONG8:

489

case TIFF_SLONG8:

490

case TIFF_IFD8:

491

return 8;

492

default:

493

return 0;

494

}

495

}

496

497

const TIFFField*

498

TIFFFindField(TIFF* tif, uint32 tag, TIFFDataType dt)

499

{

500

TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, 0, NULL, NULL};

501

TIFFField* pkey = &key;

502

const TIFFField **ret;

503

if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&

504

(dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))

505

return tif->tif_foundfield;

506

507

/* If we are invoked with no field information, then just return. */

508

if (!tif->tif_fields)

509

return NULL;

510

511

/* NB: use sorted search (e.g. binary search) */

512

513

key.field_tag = tag;

514

key.field_type = dt;

515

516

ret = (const TIFFField **) bsearch(&pkey, tif->tif_fields,

517

tif->tif_nfields,

518

sizeof(TIFFField *), tagCompare);

519

return tif->tif_foundfield = (ret ? *ret : NULL);

520

}

521

522

const TIFFField*

523

_TIFFFindFieldByName(TIFF* tif, const char *field_name, TIFFDataType dt)

524

{

525

TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, 0, NULL, NULL};

526

TIFFField* pkey = &key;

527

const TIFFField **ret;

528

if (tif->tif_foundfield

529

&& streq(tif->tif_foundfield->field_name, field_name)

530

&& (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))

531

return (tif->tif_foundfield);

532

533

/* If we are invoked with no field information, then just return. */

534

if (!tif->tif_fields)

535

return NULL;

536

537

/* NB: use linear search since list is sorted by key#, not name */

538

539

key.field_name = (char *)field_name;

540

key.field_type = dt;

541

542

ret = (const TIFFField **)

543

td_lfind(&pkey, tif->tif_fields, &tif->tif_nfields,

544

sizeof(TIFFField *), tagNameCompare);

545

546

return tif->tif_foundfield = (ret ? *ret : NULL);

547

}

548

549

const TIFFField*

550

TIFFFieldWithTag(TIFF* tif, uint32 tag)

551

{

552

const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);

553

if (!fip) {

554

TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",

555

"Internal error, unknown tag 0x%x",

556

(unsigned int) tag);

557

}

558

return (fip);

559

}

560

561

const TIFFField*

562

TIFFFieldWithName(TIFF* tif, const char *field_name)

563

{

564

const TIFFField* fip =

565

_TIFFFindFieldByName(tif, field_name, TIFF_ANY);

566

if (!fip) {

567

TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",

568

"Internal error, unknown tag %s", field_name);

569

}

570

return (fip);

571

}

572

573

uint32

574

TIFFFieldTag(const TIFFField* fip)

575

{

576

return fip->field_tag;

577

}

578

579

const char *

580

TIFFFieldName(const TIFFField* fip)

581

{

582

return fip->field_name;

583

}

584

585

TIFFDataType

586

TIFFFieldDataType(const TIFFField* fip)

587

{

588

return fip->field_type;

589

}

590

591

int

592

TIFFFieldPassCount(const TIFFField* fip)

593

{

594

return fip->field_passcount;

595

}

596

597

int

598

TIFFFieldReadCount(const TIFFField* fip)

599

{

600

return fip->field_readcount;

601

}

602

603

int

604

TIFFFieldWriteCount(const TIFFField* fip)

605

{

606

return fip->field_writecount;

607

}

608

609

const TIFFField*

610

_TIFFFindOrRegisterField(TIFF *tif, uint32 tag, TIFFDataType dt)

611

612

{

613

const TIFFField *fld;

614

615

fld = TIFFFindField(tif, tag, dt);

616

if (fld == NULL) {

617

fld = _TIFFCreateAnonField(tif, tag, dt);

618

if (!_TIFFMergeFields(tif, fld, 1))

619

return NULL;

620

}

621

622

return fld;

623

}

624

625

TIFFField*

626

_TIFFCreateAnonField(TIFF *tif, uint32 tag, TIFFDataType field_type)

627

{

628

TIFFField *fld;

629

(void) tif;

630

631

fld = (TIFFField *) _TIFFmalloc(sizeof (TIFFField));

632

if (fld == NULL)

633

return NULL;

634

_TIFFmemset(fld, 0, sizeof(TIFFField));

635

636

fld->field_tag = tag;

637

fld->field_readcount = TIFF_VARIABLE2;

638

fld->field_writecount = TIFF_VARIABLE2;

639

fld->field_type = field_type;

640

fld->reserved = 0;

641

switch (field_type)

642

{

643

case TIFF_BYTE:

644

case TIFF_UNDEFINED:

645

fld->set_field_type = TIFF_SETGET_C32_UINT8;

646

fld->get_field_type = TIFF_SETGET_C32_UINT8;

647

break;

648

case TIFF_ASCII:

649

fld->set_field_type = TIFF_SETGET_C32_ASCII;

650

fld->get_field_type = TIFF_SETGET_C32_ASCII;

651

break;

652

case TIFF_SHORT:

653

fld->set_field_type = TIFF_SETGET_C32_UINT16;

654

fld->get_field_type = TIFF_SETGET_C32_UINT16;

655

break;

656

case TIFF_LONG:

657

fld->set_field_type = TIFF_SETGET_C32_UINT32;

658

fld->get_field_type = TIFF_SETGET_C32_UINT32;

659

break;

660

case TIFF_RATIONAL:

661

case TIFF_SRATIONAL:

662

case TIFF_FLOAT:

663

fld->set_field_type = TIFF_SETGET_C32_FLOAT;

664

fld->get_field_type = TIFF_SETGET_C32_FLOAT;

665

break;

666

case TIFF_SBYTE:

667

fld->set_field_type = TIFF_SETGET_C32_SINT8;

668

fld->get_field_type = TIFF_SETGET_C32_SINT8;

669

break;

670

case TIFF_SSHORT:

671

fld->set_field_type = TIFF_SETGET_C32_SINT16;

672

fld->get_field_type = TIFF_SETGET_C32_SINT16;

673

break;

674

case TIFF_SLONG:

675

fld->set_field_type = TIFF_SETGET_C32_SINT32;

676

fld->get_field_type = TIFF_SETGET_C32_SINT32;

677

break;

678

case TIFF_DOUBLE:

679

fld->set_field_type = TIFF_SETGET_C32_DOUBLE;

680

fld->get_field_type = TIFF_SETGET_C32_DOUBLE;

681

break;

682

case TIFF_IFD:

683

case TIFF_IFD8:

684

fld->set_field_type = TIFF_SETGET_C32_IFD8;

685

fld->get_field_type = TIFF_SETGET_C32_IFD8;

686

break;

687

case TIFF_LONG8:

688

fld->set_field_type = TIFF_SETGET_C32_UINT64;

689

fld->get_field_type = TIFF_SETGET_C32_UINT64;

690

break;

691

case TIFF_SLONG8:

692

fld->set_field_type = TIFF_SETGET_C32_SINT64;

693

fld->get_field_type = TIFF_SETGET_C32_SINT64;

694

break;

695

default:

696

fld->set_field_type = TIFF_SETGET_UNDEFINED;

697

fld->get_field_type = TIFF_SETGET_UNDEFINED;

698

break;

699

}

700

fld->field_bit = FIELD_CUSTOM;

701

fld->field_oktochange = TRUE;

702

fld->field_passcount = TRUE;

703

fld->field_name = (char *) _TIFFmalloc(32);

704

if (fld->field_name == NULL) {

705

_TIFFfree(fld);

706

return NULL;

707

}

708

fld->field_subfields = NULL;

709

710

/*

711

* note that this name is a special sign to TIFFClose() and

712

* _TIFFSetupFields() to free the field

713

*/

714

snprintf(fld->field_name, 32, "Tag %d", (int) tag);

715

716

return fld;

717

}

718

719

/****************************************************************************

720

* O B S O L E T E D I N T E R F A C E S

721

*

722

* Don't use this stuff in your applications, it may be removed in the future

723

* libtiff versions.

724

****************************************************************************/

725

726

static TIFFSetGetFieldType

727

_TIFFSetGetType(TIFFDataType type, short count, unsigned char passcount)

728

{

729

if (type == TIFF_ASCII && count == TIFF_VARIABLE && passcount == 0)

730

return TIFF_SETGET_ASCII;

731

732

else if (count == 1 && passcount == 0) {

733

switch (type)

734

{

735

case TIFF_BYTE:

736

case TIFF_UNDEFINED:

737

return TIFF_SETGET_UINT8;

738

case TIFF_ASCII:

739

return TIFF_SETGET_ASCII;

740

case TIFF_SHORT:

741

return TIFF_SETGET_UINT16;

742

case TIFF_LONG:

743

return TIFF_SETGET_UINT32;

744

case TIFF_RATIONAL:

745

case TIFF_SRATIONAL:

746

case TIFF_FLOAT:

747

return TIFF_SETGET_FLOAT;

748

case TIFF_SBYTE:

749

return TIFF_SETGET_SINT8;

750

case TIFF_SSHORT:

751

return TIFF_SETGET_SINT16;

752

case TIFF_SLONG:

753

return TIFF_SETGET_SINT32;

754

case TIFF_DOUBLE:

755

return TIFF_SETGET_DOUBLE;

756

case TIFF_IFD:

757

case TIFF_IFD8:

758

return TIFF_SETGET_IFD8;

759

case TIFF_LONG8:

760

return TIFF_SETGET_UINT64;

761

case TIFF_SLONG8:

762

return TIFF_SETGET_SINT64;

763

default:

764

return TIFF_SETGET_UNDEFINED;

765

}

766

}

767

768

else if (count >= 1 && passcount == 0) {

769

switch (type)

770

{

771

case TIFF_BYTE:

772

case TIFF_UNDEFINED:

773

return TIFF_SETGET_C0_UINT8;

774

case TIFF_ASCII:

775

return TIFF_SETGET_C0_ASCII;

776

case TIFF_SHORT:

777

return TIFF_SETGET_C0_UINT16;

778

case TIFF_LONG:

779

return TIFF_SETGET_C0_UINT32;

780

case TIFF_RATIONAL:

781

case TIFF_SRATIONAL:

782

case TIFF_FLOAT:

783

return TIFF_SETGET_C0_FLOAT;

784

case TIFF_SBYTE:

785

return TIFF_SETGET_C0_SINT8;

786

case TIFF_SSHORT:

787

return TIFF_SETGET_C0_SINT16;

788

case TIFF_SLONG:

789

return TIFF_SETGET_C0_SINT32;

790

case TIFF_DOUBLE:

791

return TIFF_SETGET_C0_DOUBLE;

792

case TIFF_IFD:

793

case TIFF_IFD8:

794

return TIFF_SETGET_C0_IFD8;

795

case TIFF_LONG8:

796

return TIFF_SETGET_C0_UINT64;

797

case TIFF_SLONG8:

798

return TIFF_SETGET_C0_SINT64;

799

default:

800

return TIFF_SETGET_UNDEFINED;

801

}

802

}

803

804

else if (count == TIFF_VARIABLE && passcount == 1) {

805

switch (type)

806

{

807

case TIFF_BYTE:

808

case TIFF_UNDEFINED:

809

return TIFF_SETGET_C16_UINT8;

810

case TIFF_ASCII:

811

return TIFF_SETGET_C16_ASCII;

812

case TIFF_SHORT:

813

return TIFF_SETGET_C16_UINT16;

814

case TIFF_LONG:

815

return TIFF_SETGET_C16_UINT32;

816

case TIFF_RATIONAL:

817

case TIFF_SRATIONAL:

818

case TIFF_FLOAT:

819

return TIFF_SETGET_C16_FLOAT;

820

case TIFF_SBYTE:

821

return TIFF_SETGET_C16_SINT8;

822

case TIFF_SSHORT:

823

return TIFF_SETGET_C16_SINT16;

824

case TIFF_SLONG:

825

return TIFF_SETGET_C16_SINT32;

826

case TIFF_DOUBLE:

827

return TIFF_SETGET_C16_DOUBLE;

828

case TIFF_IFD:

829

case TIFF_IFD8:

830

return TIFF_SETGET_C16_IFD8;

831

case TIFF_LONG8:

832

return TIFF_SETGET_C16_UINT64;

833

case TIFF_SLONG8:

834

return TIFF_SETGET_C16_SINT64;

835

default:

836

return TIFF_SETGET_UNDEFINED;

837

}

838

}

839

840

else if (count == TIFF_VARIABLE2 && passcount == 1) {

841

switch (type)

842

{

843

case TIFF_BYTE:

844

case TIFF_UNDEFINED:

845

return TIFF_SETGET_C32_UINT8;

846

case TIFF_ASCII:

847

return TIFF_SETGET_C32_ASCII;

848

case TIFF_SHORT:

849

return TIFF_SETGET_C32_UINT16;

850

case TIFF_LONG:

851

return TIFF_SETGET_C32_UINT32;

852

case TIFF_RATIONAL:

853

case TIFF_SRATIONAL:

854

case TIFF_FLOAT:

855

return TIFF_SETGET_C32_FLOAT;

856

case TIFF_SBYTE:

857

return TIFF_SETGET_C32_SINT8;

858

case TIFF_SSHORT:

859

return TIFF_SETGET_C32_SINT16;

860

case TIFF_SLONG:

861

return TIFF_SETGET_C32_SINT32;

862

case TIFF_DOUBLE:

863

return TIFF_SETGET_C32_DOUBLE;

864

case TIFF_IFD:

865

case TIFF_IFD8:

866

return TIFF_SETGET_C32_IFD8;

867

case TIFF_LONG8:

868

return TIFF_SETGET_C32_UINT64;

869

case TIFF_SLONG8:

870

return TIFF_SETGET_C32_SINT64;

871

default:

872

return TIFF_SETGET_UNDEFINED;

873

}

874

}

875

876

return TIFF_SETGET_UNDEFINED;

877

}

878

879

int

880

TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], uint32 n)

881

{

882

static const char module[] = "TIFFMergeFieldInfo";

883

static const char reason[] = "for fields array";

884

TIFFField *tp;

885

size_t nfields;

886

uint32 i;

887

888

if (tif->tif_nfieldscompat > 0) {

889

tif->tif_fieldscompat = (TIFFFieldArray *)

890

_TIFFCheckRealloc(tif, tif->tif_fieldscompat,

891

tif->tif_nfieldscompat + 1,

892

sizeof(TIFFFieldArray), reason);

893

} else {

894

tif->tif_fieldscompat = (TIFFFieldArray *)

895

_TIFFCheckMalloc(tif, 1, sizeof(TIFFFieldArray),

896

reason);

897

}

898

if (!tif->tif_fieldscompat) {

899

TIFFErrorExt(tif->tif_clientdata, module,

900

"Failed to allocate fields array");

901

return -1;

902

}

903

nfields = tif->tif_nfieldscompat++;

904

905

tif->tif_fieldscompat[nfields].type = tfiatOther;

906

tif->tif_fieldscompat[nfields].allocated_size = n;

907

tif->tif_fieldscompat[nfields].count = n;

908

tif->tif_fieldscompat[nfields].fields =

909

(TIFFField *)_TIFFCheckMalloc(tif, n, sizeof(TIFFField),

910

reason);

911

if (!tif->tif_fieldscompat[nfields].fields) {

912

TIFFErrorExt(tif->tif_clientdata, module,

913

"Failed to allocate fields array");

914

return -1;

915

}

916

917

tp = tif->tif_fieldscompat[nfields].fields;

918

for (i = 0; i < n; i++) {

919

tp->field_tag = info[i].field_tag;

920

tp->field_readcount = info[i].field_readcount;

921

tp->field_writecount = info[i].field_writecount;

922

tp->field_type = info[i].field_type;

923

tp->reserved = 0;

924

tp->set_field_type =

925

_TIFFSetGetType(info[i].field_type,

926

info[i].field_readcount,

927

info[i].field_passcount);

928

tp->get_field_type =

929

_TIFFSetGetType(info[i].field_type,

930

info[i].field_readcount,

931

info[i].field_passcount);

932

tp->field_bit = info[i].field_bit;

933

tp->field_oktochange = info[i].field_oktochange;

934

tp->field_passcount = info[i].field_passcount;

935

tp->field_name = info[i].field_name;

936

tp->field_subfields = NULL;

937

tp++;

938

}

939

940

if (!_TIFFMergeFields(tif, tif->tif_fieldscompat[nfields].fields, n)) {

941

TIFFErrorExt(tif->tif_clientdata, module,

942

"Setting up field info failed");

943

return -1;

944

}

945

946

return 0;

947

}

948

949

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

950

951

/*

952

* Local Variables:

953

* mode: c

954

* c-basic-offset: 8

955

* fill-column: 78

956

* End:

957

*/