1 /* $Header$ */
2
3 /*
4 * Copyright (c) 1988-1997 Sam Leffler
5 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and
8 * its documentation for any purpose is hereby granted without fee, provided
9 * that (i) the above copyright notices and this permission notice appear in
10 * all copies of the software and related documentation, and (ii) the names of
11 * Sam Leffler and Silicon Graphics may not be used in any advertising or
12 * publicity relating to the software without the specific, prior written
13 * permission of Sam Leffler and Silicon Graphics.
14 *
15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18 *
19 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 */
26
27 /*
28 * TIFF Library.
29 *
30 * Core Directory Tag Support.
31 */
32 #include "tiffiop.h"
33 #include <stdlib.h>
34 #include <assert.h>
35 #include <stdio.h>
36
37 /*
38 * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
39 * If a tag can have both LONG and SHORT types
40 * then the LONG must be placed before the SHORT for
41 * writing to work properly.
42 *
43 * NOTE: The second field (field_readcount) and third field (field_writecount)
44 * sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
45 * and TIFFTAG_SPP (-2). The macros should be used but would throw off
46 * the formatting of the code, so please interprete the -1, -2 and -3
47 * values accordingly.
48 */
49 #ifndef VMS
50 static
51 #endif
52 const TIFFFieldInfo tiffFieldInfo[] = {
53 { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, FIELD_SUBFILETYPE,
54 TRUE, FALSE, "SubfileType" },
55 /* XXX SHORT for compatibility w/ old versions of the library */
56 { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
57 TRUE, FALSE, "SubfileType" },
58 { TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
59 TRUE, FALSE, "OldSubfileType" },
60 { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
61 FALSE, FALSE, "ImageWidth" },
62 { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
63 FALSE, FALSE, "ImageWidth" },
64 { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
65 TRUE, FALSE, "ImageLength" },
66 { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
67 TRUE, FALSE, "ImageLength" },
68 /* XXX LONG for compatibility with some broken TIFF writers */
69 { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_LONG, FIELD_BITSPERSAMPLE,
70 FALSE, FALSE, "BitsPerSample" },
71 { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_SHORT, FIELD_BITSPERSAMPLE,
72 FALSE, FALSE, "BitsPerSample" },
73 /* XXX LONG for compatibility with some broken TIFF writers */
74 { TIFFTAG_COMPRESSION, -1, 1, TIFF_LONG, FIELD_COMPRESSION,
75 FALSE, FALSE, "Compression" },
76 { TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, FIELD_COMPRESSION,
77 FALSE, FALSE, "Compression" },
78 /* XXX LONG for compatibility with some broken TIFF writers */
79 { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_LONG, FIELD_PHOTOMETRIC,
80 FALSE, FALSE, "PhotometricInterpretation" },
81 { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, FIELD_PHOTOMETRIC,
82 FALSE, FALSE, "PhotometricInterpretation" },
83 { TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, FIELD_THRESHHOLDING,
84 TRUE, FALSE, "Threshholding" },
85 { TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
86 TRUE, FALSE, "CellWidth" },
87 { TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
88 TRUE, FALSE, "CellLength" },
89 { TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, FIELD_FILLORDER,
90 FALSE, FALSE, "FillOrder" },
91 { TIFFTAG_DOCUMENTNAME, -1,-1, TIFF_ASCII, FIELD_DOCUMENTNAME,
92 TRUE, FALSE, "DocumentName" },
93 { TIFFTAG_IMAGEDESCRIPTION, -1,-1, TIFF_ASCII, FIELD_IMAGEDESCRIPTION,
94 TRUE, FALSE, "ImageDescription" },
95 { TIFFTAG_MAKE, -1,-1, TIFF_ASCII, FIELD_MAKE,
96 TRUE, FALSE, "Make" },
97 { TIFFTAG_MODEL, -1,-1, TIFF_ASCII, FIELD_MODEL,
98 TRUE, FALSE, "Model" },
99 { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_LONG, FIELD_STRIPOFFSETS,
100 FALSE, FALSE, "StripOffsets" },
101 { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_SHORT, FIELD_STRIPOFFSETS,
102 FALSE, FALSE, "StripOffsets" },
103 { TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, FIELD_ORIENTATION,
104 FALSE, FALSE, "Orientation" },
105 { TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, FIELD_SAMPLESPERPIXEL,
106 FALSE, FALSE, "SamplesPerPixel" },
107 { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, FIELD_ROWSPERSTRIP,
108 FALSE, FALSE, "RowsPerStrip" },
109 { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_SHORT, FIELD_ROWSPERSTRIP,
110 FALSE, FALSE, "RowsPerStrip" },
111 { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
112 FALSE, FALSE, "StripByteCounts" },
113 { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
114 FALSE, FALSE, "StripByteCounts" },
115 { TIFFTAG_MINSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MINSAMPLEVALUE,
116 TRUE, FALSE, "MinSampleValue" },
117 { TIFFTAG_MAXSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MAXSAMPLEVALUE,
118 TRUE, FALSE, "MaxSampleValue" },
119 { TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
120 FALSE, FALSE, "XResolution" },
121 { TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
122 FALSE, FALSE, "YResolution" },
123 { TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, FIELD_PLANARCONFIG,
124 FALSE, FALSE, "PlanarConfiguration" },
125 { TIFFTAG_PAGENAME, -1,-1, TIFF_ASCII, FIELD_PAGENAME,
126 TRUE, FALSE, "PageName" },
127 { TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
128 TRUE, FALSE, "XPosition" },
129 { TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
130 TRUE, FALSE, "YPosition" },
131 { TIFFTAG_FREEOFFSETS, -1,-1, TIFF_LONG, FIELD_IGNORE,
132 FALSE, FALSE, "FreeOffsets" },
133 { TIFFTAG_FREEBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_IGNORE,
134 FALSE, FALSE, "FreeByteCounts" },
135 { TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
136 TRUE, FALSE, "GrayResponseUnit" },
137 { TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT, FIELD_IGNORE,
138 TRUE, FALSE, "GrayResponseCurve" },
139 { TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_RESOLUTIONUNIT,
140 FALSE, FALSE, "ResolutionUnit" },
141 { TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, FIELD_PAGENUMBER,
142 TRUE, FALSE, "PageNumber" },
143 { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
144 TRUE, FALSE, "ColorResponseUnit" },
145 { TIFFTAG_TRANSFERFUNCTION, -1,-1, TIFF_SHORT, FIELD_TRANSFERFUNCTION,
146 TRUE, FALSE, "TransferFunction" },
147 { TIFFTAG_SOFTWARE, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
148 TRUE, FALSE, "Software" },
149 { TIFFTAG_DATETIME, 20,20, TIFF_ASCII, FIELD_DATETIME,
150 TRUE, FALSE, "DateTime" },
151 { TIFFTAG_ARTIST, -1,-1, TIFF_ASCII, FIELD_ARTIST,
152 TRUE, FALSE, "Artist" },
153 { TIFFTAG_HOSTCOMPUTER, -1,-1, TIFF_ASCII, FIELD_HOSTCOMPUTER,
154 TRUE, FALSE, "HostComputer" },
155 { TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL,FIELD_WHITEPOINT,
156 TRUE, FALSE, "WhitePoint" },
157 { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,FIELD_PRIMARYCHROMAS,
158 TRUE, FALSE, "PrimaryChromaticities" },
159 { TIFFTAG_COLORMAP, -1,-1, TIFF_SHORT, FIELD_COLORMAP,
160 TRUE, FALSE, "ColorMap" },
161 { TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, FIELD_HALFTONEHINTS,
162 TRUE, FALSE, "HalftoneHints" },
163 { TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
164 FALSE, FALSE, "TileWidth" },
165 { TIFFTAG_TILEWIDTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
166 FALSE, FALSE, "TileWidth" },
167 { TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
168 FALSE, FALSE, "TileLength" },
169 { TIFFTAG_TILELENGTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
170 FALSE, FALSE, "TileLength" },
171 { TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG, FIELD_STRIPOFFSETS,
172 FALSE, FALSE, "TileOffsets" },
173 { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
174 FALSE, FALSE, "TileByteCounts" },
175 { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
176 FALSE, FALSE, "TileByteCounts" },
177 { TIFFTAG_SUBIFD, -1,-1, TIFF_LONG, FIELD_SUBIFD,
178 TRUE, TRUE, "SubIFD" },
179 { TIFFTAG_INKSET, 1, 1, TIFF_SHORT, FIELD_INKSET,
180 FALSE, FALSE, "InkSet" },
181 { TIFFTAG_INKNAMES, -1,-1, TIFF_ASCII, FIELD_INKNAMES,
182 TRUE, TRUE, "InkNames" },
183 { TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, FIELD_NUMBEROFINKS,
184 TRUE, FALSE, "NumberOfInks" },
185 { TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, FIELD_DOTRANGE,
186 FALSE, FALSE, "DotRange" },
187 { TIFFTAG_DOTRANGE, 2, 2, TIFF_BYTE, FIELD_DOTRANGE,
188 FALSE, FALSE, "DotRange" },
189 { TIFFTAG_TARGETPRINTER, -1,-1, TIFF_ASCII, FIELD_TARGETPRINTER,
190 TRUE, FALSE, "TargetPrinter" },
191 { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_SHORT, FIELD_EXTRASAMPLES,
192 FALSE, FALSE, "ExtraSamples" },
193 /* XXX for bogus Adobe Photoshop v2.5 files */
194 { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_BYTE, FIELD_EXTRASAMPLES,
195 FALSE, FALSE, "ExtraSamples" },
196 { TIFFTAG_SAMPLEFORMAT, -1,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
197 FALSE, FALSE, "SampleFormat" },
198 { TIFFTAG_SMINSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMINSAMPLEVALUE,
199 TRUE, FALSE, "SMinSampleValue" },
200 { TIFFTAG_SMAXSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMAXSAMPLEVALUE,
201 TRUE, FALSE, "SMaxSampleValue" },
202 { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, FIELD_YCBCRCOEFFICIENTS,
203 FALSE, FALSE, "YCbCrCoefficients" },
204 { TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, FIELD_YCBCRSUBSAMPLING,
205 FALSE, FALSE, "YCbCrSubsampling" },
206 { TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, FIELD_YCBCRPOSITIONING,
207 FALSE, FALSE, "YCbCrPositioning" },
208 { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL, FIELD_REFBLACKWHITE,
209 TRUE, FALSE, "ReferenceBlackWhite" },
210 /* XXX temporarily accept LONG for backwards compatibility */
211 { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG, FIELD_REFBLACKWHITE,
212 TRUE, FALSE, "ReferenceBlackWhite" },
213 { TIFFTAG_XMLPACKET, -1,-3, TIFF_UNDEFINED, FIELD_XMLPACKET,
214 FALSE, TRUE, "XMLPacket" },
215 /* begin SGI tags */
216 { TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, FIELD_EXTRASAMPLES,
217 FALSE, FALSE, "Matteing" },
218 { TIFFTAG_DATATYPE, -2,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
219 FALSE, FALSE, "DataType" },
220 { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, FIELD_IMAGEDEPTH,
221 FALSE, FALSE, "ImageDepth" },
222 { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDEPTH,
223 FALSE, FALSE, "ImageDepth" },
224 { TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, FIELD_TILEDEPTH,
225 FALSE, FALSE, "TileDepth" },
226 { TIFFTAG_TILEDEPTH, 1, 1, TIFF_SHORT, FIELD_TILEDEPTH,
227 FALSE, FALSE, "TileDepth" },
228 /* end SGI tags */
229 /* begin Pixar tags */
230 { TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLWIDTH,
231 TRUE, FALSE, "ImageFullWidth" },
232 { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLLENGTH,
233 TRUE, FALSE, "ImageFullLength" },
234 { TIFFTAG_PIXAR_TEXTUREFORMAT, -1,-1, TIFF_ASCII, FIELD_TEXTUREFORMAT,
235 TRUE, FALSE, "TextureFormat" },
236 { TIFFTAG_PIXAR_WRAPMODES, -1,-1, TIFF_ASCII, FIELD_WRAPMODES,
237 TRUE, FALSE, "TextureWrapModes" },
238 { TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, FIELD_FOVCOT,
239 TRUE, FALSE, "FieldOfViewCotan" },
240 { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16, TIFF_FLOAT,
241 FIELD_MATRIX_WORLDTOSCREEN, TRUE, FALSE, "MatrixWorldToScreen" },
242 { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16, TIFF_FLOAT,
243 FIELD_MATRIX_WORLDTOCAMERA, TRUE, FALSE, "MatrixWorldToCamera" },
244 { TIFFTAG_COPYRIGHT, -1,-1, TIFF_ASCII, FIELD_COPYRIGHT,
245 TRUE, FALSE, "Copyright" },
246 /* end Pixar tags */
247 #ifdef IPTC_SUPPORT
248 #ifdef PHOTOSHOP_SUPPORT
249 { TIFFTAG_RICHTIFFIPTC, -1,-1, TIFF_LONG, FIELD_RICHTIFFIPTC,
250 FALSE, TRUE, "RichTIFFIPTC" },
251 #else
252 { TIFFTAG_RICHTIFFIPTC, -1,-3, TIFF_UNDEFINED, FIELD_RICHTIFFIPTC,
253 FALSE, TRUE, "RichTIFFIPTC" },
254 #endif
255 #endif
256 { TIFFTAG_PHOTOSHOP, -1,-3, TIFF_BYTE, FIELD_PHOTOSHOP,
257 FALSE, TRUE, "Photoshop" },
258 { TIFFTAG_ICCPROFILE, -1,-3, TIFF_UNDEFINED, FIELD_ICCPROFILE,
259 FALSE, TRUE, "ICC Profile" },
260 { TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, FIELD_STONITS,
261 FALSE, FALSE, "StoNits" },
262 };
263 #define N(a) (sizeof (a) / sizeof (a[0]))
264
265 void
_TIFFSetupFieldInfo(TIFF * tif)266 _TIFFSetupFieldInfo(TIFF* tif)
267 {
268 if (tif->tif_fieldinfo) {
269 int i;
270
271 for (i = 0; i < tif->tif_nfields; i++)
272 {
273 TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
274 if (fld->field_bit == FIELD_CUSTOM &&
275 strncmp("Tag ", fld->field_name, 4) == 0)
276 {
277 _TIFFfree(fld->field_name);
278 _TIFFfree(fld);
279 }
280 }
281
282 _TIFFfree(tif->tif_fieldinfo);
283 tif->tif_nfields = 0;
284 }
285 _TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo));
286 }
287
288 static int
tagCompare(const void * a,const void * b)289 tagCompare(const void* a, const void* b)
290 {
291 const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
292 const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
293 /* NB: be careful of return values for 16-bit platforms */
294 if (ta->field_tag != tb->field_tag)
295 return (ta->field_tag < tb->field_tag ? -1 : 1);
296 else
297 return ((int)tb->field_type - (int)ta->field_type);
298 }
299
300 void
_TIFFMergeFieldInfo(TIFF * tif,const TIFFFieldInfo info[],int n)301 _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
302 {
303 TIFFFieldInfo** tp;
304 int i;
305
306 if (tif->tif_nfields > 0) {
307 tif->tif_fieldinfo = (TIFFFieldInfo**)
308 _TIFFrealloc(tif->tif_fieldinfo,
309 (tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
310 } else {
311 tif->tif_fieldinfo = (TIFFFieldInfo**)
312 _TIFFmalloc(n * sizeof (TIFFFieldInfo*));
313 }
314 assert(tif->tif_fieldinfo != NULL);
315 tp = &tif->tif_fieldinfo[tif->tif_nfields];
316 for (i = 0; i < n; i++)
317 tp[i] = (TIFFFieldInfo*) &info[i]; /* XXX */
318
319 /* Sort the field info by tag number */
320 qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
321 sizeof (TIFFFieldInfo*), tagCompare);
322 }
323
324 void
_TIFFPrintFieldInfo(TIFF * tif,FILE * fd)325 _TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
326 {
327 int i;
328
329 fprintf(fd, "%s: \n", tif->tif_name);
330 for (i = 0; i < tif->tif_nfields; i++) {
331 const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
332 fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
333 , i
334 , (unsigned long) fip->field_tag
335 , fip->field_readcount, fip->field_writecount
336 , fip->field_type
337 , fip->field_bit
338 , fip->field_oktochange ? "TRUE" : "FALSE"
339 , fip->field_passcount ? "TRUE" : "FALSE"
340 , fip->field_name
341 );
342 }
343 }
344
345 /*
346 * Return size of TIFFDataType in bytes
347 */
348 int
TIFFDataWidth(TIFFDataType type)349 TIFFDataWidth(TIFFDataType type)
350 {
351 switch(type)
352 {
353 case 0: /* nothing */
354 case 1: /* TIFF_BYTE */
355 case 2: /* TIFF_ASCII */
356 case 6: /* TIFF_SBYTE */
357 case 7: /* TIFF_UNDEFINED */
358 return 1;
359 case 3: /* TIFF_SHORT */
360 case 8: /* TIFF_SSHORT */
361 return 2;
362 case 4: /* TIFF_LONG */
363 case 9: /* TIFF_SLONG */
364 case 11: /* TIFF_FLOAT */
365 case 13: /* TIFF_IFD */
366 return 4;
367 case 5: /* TIFF_RATIONAL */
368 case 10: /* TIFF_SRATIONAL */
369 case 12: /* TIFF_DOUBLE */
370 return 8;
371 default:
372 return 0; /* will return 0 for unknown types */
373 }
374 }
375
376 /*
377 * Return nearest TIFFDataType to the sample type of an image.
378 */
379 TIFFDataType
_TIFFSampleToTagType(TIFF * tif)380 _TIFFSampleToTagType(TIFF* tif)
381 {
382 uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample);
383
384 switch (tif->tif_dir.td_sampleformat) {
385 case SAMPLEFORMAT_IEEEFP:
386 return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
387 case SAMPLEFORMAT_INT:
388 return (bps <= 1 ? TIFF_SBYTE :
389 bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
390 case SAMPLEFORMAT_UINT:
391 return (bps <= 1 ? TIFF_BYTE :
392 bps <= 2 ? TIFF_SHORT : TIFF_LONG);
393 case SAMPLEFORMAT_VOID:
394 return (TIFF_UNDEFINED);
395 }
396 /*NOTREACHED*/
397 return (TIFF_UNDEFINED);
398 }
399
400 const TIFFFieldInfo*
_TIFFFindFieldInfo(TIFF * tif,ttag_t tag,TIFFDataType dt)401 _TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
402 {
403 static const TIFFFieldInfo *last = NULL;
404 int i, n;
405
406 if (last && last->field_tag == tag &&
407 (dt == TIFF_ANY || dt == last->field_type))
408 return (last);
409 /* NB: if table gets big, use sorted search (e.g. binary search) */
410 if(dt != TIFF_ANY) {
411 TIFFFieldInfo key = {0, 0, 0, 0, 0, 0, 0, 0};
412 key.field_tag = tag;
413 key.field_type = dt;
414 return((const TIFFFieldInfo *) bsearch(&key,
415 tif->tif_fieldinfo,
416 tif->tif_nfields,
417 sizeof(TIFFFieldInfo),
418 tagCompare));
419 } else for (i = 0, n = tif->tif_nfields; i < n; i++) {
420 const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
421 if (fip->field_tag == tag &&
422 (dt == TIFF_ANY || fip->field_type == dt))
423 return (last = fip);
424 }
425 return ((const TIFFFieldInfo *)0);
426 }
427
428 const TIFFFieldInfo*
_TIFFFieldWithTag(TIFF * tif,ttag_t tag)429 _TIFFFieldWithTag(TIFF* tif, ttag_t tag)
430 {
431 const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
432 if (!fip) {
433 TIFFError("TIFFFieldWithTag",
434 "Internal error, unknown tag 0x%x", (u_int) tag);
435 assert(fip != NULL);
436 /*NOTREACHED*/
437 }
438 return (fip);
439 }
440
441 const TIFFFieldInfo*
_TIFFFindOrRegisterFieldInfo(TIFF * tif,ttag_t tag,TIFFDataType dt)442 _TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )
443
444 {
445 const TIFFFieldInfo *fld;
446
447 fld = _TIFFFindFieldInfo( tif, tag, dt );
448 if( fld == NULL )
449 {
450 fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
451 _TIFFMergeFieldInfo( tif, fld, 1 );
452 }
453
454 return fld;
455 }
456
457 TIFFFieldInfo*
_TIFFCreateAnonFieldInfo(TIFF * tif,ttag_t tag,TIFFDataType field_type)458 _TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
459 {
460 TIFFFieldInfo *fld;
461
462 fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo));
463 if (fld == NULL)
464 return NULL;
465 _TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );
466
467 fld->field_tag = tag;
468 fld->field_readcount = TIFF_VARIABLE;
469 fld->field_writecount = TIFF_VARIABLE;
470 fld->field_type = field_type;
471 fld->field_bit = FIELD_CUSTOM;
472 fld->field_oktochange = TRUE;
473 fld->field_passcount = TRUE;
474 fld->field_name = (char *) _TIFFmalloc(32);
475 if (fld->field_name == NULL) {
476 _TIFFfree(fld);
477 return NULL;
478 }
479
480 /* note that this name is a special sign to TIFFClose() and
481 * _TIFFSetupFieldInfo() to free the field
482 */
483 sprintf(fld->field_name, "Tag %d", (int) tag);
484
485 return fld;
486 }
487