1 #ifndef lint
2 static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_dir.c,v 1.110 92/03/06 11:59:49 sam Exp $";
3 #endif
4
5 /*
6 * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
7 * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
8 *
9 * Permission to use, copy, modify, distribute, and sell this software and
10 * its documentation for any purpose is hereby granted without fee, provided
11 * that (i) the above copyright notices and this permission notice appear in
12 * all copies of the software and related documentation, and (ii) the names of
13 * Sam Leffler and Silicon Graphics may not be used in any advertising or
14 * publicity relating to the software without the specific, prior written
15 * permission of Sam Leffler and Silicon Graphics.
16 *
17 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
19 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
20 *
21 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
22 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
23 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
24 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
25 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
26 * OF THIS SOFTWARE.
27 */
28
29 /*
30 * TIFF Library.
31 *
32 * Directory Tag Get & Set Routines.
33 * (and also some miscellaneous stuff)
34 *
35 * NB: Beware of the varargs declarations for routines in
36 * this file. The names and types of variables has been
37 * carefully chosen to make things work with compilers that
38 * are busted in one way or another (e.g. SGI/MIPS).
39 */
40 #include "tiffioP.h"
41 #include "prototypes.h"
42
43 static
DECLARE2(setString,char **,cpp,char *,cp)44 DECLARE2(setString, char**, cpp, char*, cp)
45 {
46 if (*cpp)
47 free(*cpp), *cpp = 0;
48 if (cp) {
49 int len = strlen(cp)+1;
50 if (*cpp = malloc(len))
51 bcopy(cp, *cpp, len);
52 }
53 }
54
55 static
DECLARE3(setShortArray,u_short **,wpp,u_short *,wp,long,n)56 DECLARE3(setShortArray, u_short**, wpp, u_short*, wp, long, n)
57 {
58 if (*wpp)
59 free((char *)*wpp), *wpp = 0;
60 n *= sizeof (u_short);
61 if (wp && (*wpp = (u_short *)malloc(n)))
62 bcopy(wp, *wpp, n);
63 }
64
65 static
DECLARE3(setLongArray,u_long **,wpp,u_long *,wp,long,n)66 DECLARE3(setLongArray, u_long**, wpp, u_long*, wp, long, n)
67 {
68 if (*wpp)
69 free((char *)*wpp), *wpp = 0;
70 n *= sizeof (u_long);
71 if (wp && (*wpp = (u_long *)malloc(n)))
72 bcopy(wp, *wpp, n);
73 }
74
75 static
DECLARE3(setFloatArray,float **,wpp,float *,wp,long,n)76 DECLARE3(setFloatArray, float**, wpp, float*, wp, long, n)
77 {
78 if (*wpp)
79 free((char *)*wpp), *wpp = 0;
80 n *= sizeof (float);
81 if (wp && (*wpp = (float *)malloc(n)))
82 bcopy(wp, *wpp, n);
83 }
84
85 #ifdef JPEG_SUPPORT
86 /*
87 * Install a JPEG Quantization table.
88 * Note that we reorder the elements
89 * of the array in the zig-zag order
90 * that is expected by the compression code
91 * and that is to be stored in the file.
92 */
93 static
DECLARE3(setJPEGQTable,u_char ***,wpp,u_char **,wp,int,nc)94 DECLARE3(setJPEGQTable, u_char***, wpp, u_char**, wp, int, nc)
95 {
96 static u_char zigzag[64] = {
97 0, 1, 5, 6, 14, 15, 27, 28,
98 2, 4, 7, 13, 16, 26, 29, 42,
99 3, 8, 12, 17, 25, 30, 41, 43,
100 9, 11, 18, 24, 31, 40, 44, 53,
101 10, 19, 23, 32, 39, 45, 52, 54,
102 20, 22, 33, 38, 46, 51, 55, 60,
103 21, 34, 37, 47, 50, 56, 59, 61,
104 35, 36, 48, 49, 57, 58, 62, 63
105 };
106 char *tab;
107 int i, j;
108
109 if (*wpp)
110 free((char *)*wpp), *wpp = 0;
111 *wpp = (u_char **)
112 malloc(nc * (sizeof (u_char *) + 64*sizeof (u_char)));
113 tab = (((char *)*wpp) + nc*sizeof (u_short *));
114 for (i = 0; i < nc; i++) {
115 (*wpp)[i] = (u_char *)tab;
116 for (j = 0; j < 64; j++)
117 tab[zigzag[j]] = wp[i][j];
118 tab += 64*sizeof (u_char);
119 }
120 }
121
122 /*
123 * Install a JPEG Coefficient table.
124 */
125 static
DECLARE3(setJPEGCTable,u_char ***,cpp,u_char **,cp,int,nc)126 DECLARE3(setJPEGCTable, u_char***, cpp, u_char**, cp, int, nc)
127 {
128 u_char *tab;
129 int i, j, nw;
130
131 if (*cpp)
132 free(*cpp), *cpp = 0;
133 /*
134 * Calculate the size of the table by counting
135 * the number of codes specified in the bits array.
136 */
137 nw = 0;
138 for (i = 0; i < nc; i++) {
139 nw += 16; /* 16 bytes for bits array */
140 for (j = 0; j < 16; j++)/* sum up count of codes */
141 nw += cp[i][j];
142 }
143 *cpp = (u_char **)malloc(nc*sizeof (u_char *) + nw);
144 tab = ((u_char *)*cpp) + nc*sizeof (u_char *);
145 /*
146 * Setup internal array and copy user data.
147 */
148 for (i = 0; i < nc; i++) {
149 (*cpp)[i] = tab;
150 for (nw = 16, j = 0; j < 16; j++)
151 nw += cp[i][j];
152 bcopy(cp[i], tab, nw);
153 tab += nw;
154 }
155 }
156 #endif
157
158 static
TIFFSetField1(tif,tag,ap)159 TIFFSetField1(tif, tag, ap)
160 TIFF *tif;
161 int tag;
162 va_list ap;
163 {
164 TIFFDirectory *td = &tif->tif_dir;
165 int i, status = 1;
166 long v;
167
168 switch (tag) {
169 case TIFFTAG_SUBFILETYPE:
170 td->td_subfiletype = va_arg(ap, u_long);
171 break;
172 case TIFFTAG_IMAGEWIDTH:
173 td->td_imagewidth = va_arg(ap, u_long);
174 break;
175 case TIFFTAG_IMAGELENGTH:
176 td->td_imagelength = va_arg(ap, u_long);
177 break;
178 case TIFFTAG_BITSPERSAMPLE:
179 td->td_bitspersample = va_arg(ap, int);
180 break;
181 case TIFFTAG_COMPRESSION:
182 v = va_arg(ap, int) & 0xffff;
183 /*
184 * If we're changing the compression scheme,
185 * the notify the previous module so that it
186 * can cleanup any state it's setup.
187 */
188 if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
189 if (td->td_compression == v)
190 break;
191 if (tif->tif_cleanup)
192 (*tif->tif_cleanup)(tif);
193 }
194 /*
195 * Setup new compression routine state.
196 */
197 if (status = TIFFSetCompressionScheme(tif, v))
198 td->td_compression = v;
199 break;
200 case TIFFTAG_PHOTOMETRIC:
201 td->td_photometric = va_arg(ap, int);
202 break;
203 case TIFFTAG_THRESHHOLDING:
204 td->td_threshholding = va_arg(ap, int);
205 break;
206 case TIFFTAG_FILLORDER:
207 v = va_arg(ap, int);
208 if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
209 goto badvalue;
210 td->td_fillorder = v;
211 break;
212 case TIFFTAG_DOCUMENTNAME:
213 setString(&td->td_documentname, va_arg(ap, char *));
214 break;
215 case TIFFTAG_ARTIST:
216 setString(&td->td_artist, va_arg(ap, char *));
217 break;
218 case TIFFTAG_DATETIME:
219 setString(&td->td_datetime, va_arg(ap, char *));
220 break;
221 case TIFFTAG_HOSTCOMPUTER:
222 setString(&td->td_hostcomputer, va_arg(ap, char *));
223 break;
224 case TIFFTAG_IMAGEDESCRIPTION:
225 setString(&td->td_imagedescription, va_arg(ap, char *));
226 break;
227 case TIFFTAG_MAKE:
228 setString(&td->td_make, va_arg(ap, char *));
229 break;
230 case TIFFTAG_MODEL:
231 setString(&td->td_model, va_arg(ap, char *));
232 break;
233 case TIFFTAG_SOFTWARE:
234 setString(&td->td_software, va_arg(ap, char *));
235 break;
236 case TIFFTAG_ORIENTATION:
237 v = va_arg(ap, int);
238 if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
239 TIFFWarning(tif->tif_name,
240 "Bad value %ld for \"%s\" tag ignored",
241 v, TIFFFieldWithTag(tag)->field_name);
242 } else
243 td->td_orientation = v;
244 break;
245 case TIFFTAG_SAMPLESPERPIXEL:
246 /* XXX should cross check -- e.g. if pallette, then 1 */
247 v = va_arg(ap, int);
248 if (v == 0)
249 goto badvalue;
250 if (v > 4) {
251 TIFFError(tif->tif_name,
252 "Cannot handle %ld-channel data", v);
253 status = 0;
254 } else
255 td->td_samplesperpixel = v;
256 break;
257 case TIFFTAG_ROWSPERSTRIP:
258 v = va_arg(ap, u_long);
259 if (v == 0)
260 goto badvalue;
261 td->td_rowsperstrip = v;
262 if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
263 td->td_tilelength = v;
264 td->td_tilewidth = td->td_imagewidth;
265 }
266 break;
267 case TIFFTAG_MINSAMPLEVALUE:
268 td->td_minsamplevalue = va_arg(ap, int) & 0xffff;
269 break;
270 case TIFFTAG_MAXSAMPLEVALUE:
271 td->td_maxsamplevalue = va_arg(ap, int) & 0xffff;
272 break;
273 case TIFFTAG_XRESOLUTION:
274 td->td_xresolution = va_arg(ap, dblparam_t);
275 break;
276 case TIFFTAG_YRESOLUTION:
277 td->td_yresolution = va_arg(ap, dblparam_t);
278 break;
279 case TIFFTAG_PLANARCONFIG:
280 v = va_arg(ap, int);
281 if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
282 goto badvalue;
283 td->td_planarconfig = v;
284 break;
285 case TIFFTAG_PAGENAME:
286 setString(&td->td_pagename, va_arg(ap, char *));
287 break;
288 case TIFFTAG_XPOSITION:
289 td->td_xposition = va_arg(ap, dblparam_t);
290 break;
291 case TIFFTAG_YPOSITION:
292 td->td_yposition = va_arg(ap, dblparam_t);
293 break;
294 case TIFFTAG_GROUP3OPTIONS:
295 td->td_group3options = va_arg(ap, u_long);
296 break;
297 case TIFFTAG_GROUP4OPTIONS:
298 td->td_group4options = va_arg(ap, u_long);
299 break;
300 case TIFFTAG_RESOLUTIONUNIT:
301 v = va_arg(ap, int);
302 if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
303 goto badvalue;
304 td->td_resolutionunit = v;
305 break;
306 case TIFFTAG_PAGENUMBER:
307 td->td_pagenumber[0] = va_arg(ap, int);
308 td->td_pagenumber[1] = va_arg(ap, int);
309 break;
310 case TIFFTAG_HALFTONEHINTS:
311 td->td_halftonehints[0] = va_arg(ap, int);
312 td->td_halftonehints[1] = va_arg(ap, int);
313 break;
314 case TIFFTAG_COLORMAP:
315 v = 1L<<td->td_bitspersample;
316 setShortArray(&td->td_colormap[0], va_arg(ap, u_short *), v);
317 setShortArray(&td->td_colormap[1], va_arg(ap, u_short *), v);
318 setShortArray(&td->td_colormap[2], va_arg(ap, u_short *), v);
319 break;
320 case TIFFTAG_PREDICTOR:
321 td->td_predictor = va_arg(ap, int);
322 break;
323 case TIFFTAG_EXTRASAMPLES:
324 v = va_arg(ap, int);
325 if (v > td->td_samplesperpixel)
326 goto badvalue;
327 if (v != 1) /* XXX */
328 goto badvalue; /* XXX */
329 v = va_arg(ap, int);
330 if (v != EXTRASAMPLE_ASSOCALPHA)/* XXX */
331 goto badvalue; /* XXX */
332 td->td_matteing = 1;
333 break;
334 case TIFFTAG_MATTEING:
335 td->td_matteing = va_arg(ap, int);
336 break;
337 case TIFFTAG_BADFAXLINES:
338 td->td_badfaxlines = va_arg(ap, u_long);
339 break;
340 case TIFFTAG_CLEANFAXDATA:
341 td->td_cleanfaxdata = va_arg(ap, int);
342 break;
343 case TIFFTAG_CONSECUTIVEBADFAXLINES:
344 td->td_badfaxrun = va_arg(ap, u_long);
345 break;
346 case TIFFTAG_TILEWIDTH:
347 v = va_arg(ap, u_long);
348 if (v % 8)
349 goto badvalue;
350 td->td_tilewidth = v;
351 tif->tif_flags |= TIFF_ISTILED;
352 break;
353 case TIFFTAG_TILELENGTH:
354 v = va_arg(ap, u_long);
355 if (v % 8)
356 goto badvalue;
357 td->td_tilelength = v;
358 tif->tif_flags |= TIFF_ISTILED;
359 break;
360 case TIFFTAG_TILEDEPTH:
361 v = va_arg(ap, u_long);
362 if (v == 0)
363 goto badvalue;
364 td->td_tiledepth = v;
365 break;
366 case TIFFTAG_DATATYPE:
367 case TIFFTAG_SAMPLEFORMAT:
368 v = va_arg(ap, int);
369 if (tag == TIFFTAG_DATATYPE && v == 0)
370 v = SAMPLEFORMAT_VOID;
371 if (v < SAMPLEFORMAT_INT || SAMPLEFORMAT_VOID < v)
372 goto badvalue;
373 td->td_sampleformat = v;
374 break;
375 case TIFFTAG_IMAGEDEPTH:
376 td->td_imagedepth = va_arg(ap, u_long);
377 break;
378 #ifdef YCBCR_SUPPORT
379 case TIFFTAG_YCBCRCOEFFICIENTS:
380 setFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float *), 3);
381 break;
382 case TIFFTAG_YCBCRPOSITIONING:
383 td->td_ycbcrpositioning = va_arg(ap, int);
384 break;
385 case TIFFTAG_YCBCRSUBSAMPLING:
386 td->td_ycbcrsubsampling[0] = va_arg(ap, int);
387 td->td_ycbcrsubsampling[1] = va_arg(ap, int);
388 break;
389 #endif
390 #ifdef JPEG_SUPPORT
391 case TIFFTAG_JPEGPROC:
392 td->td_jpegproc = va_arg(ap, int);
393 break;
394 case TIFFTAG_JPEGRESTARTINTERVAL:
395 td->td_jpegrestartinterval = va_arg(ap, int);
396 break;
397 case TIFFTAG_JPEGQTABLES:
398 setJPEGQTable(&td->td_qtab, va_arg(ap, u_char **),
399 td->td_samplesperpixel);
400 break;
401 case TIFFTAG_JPEGDCTABLES:
402 setJPEGCTable(&td->td_dctab, va_arg(ap, u_char **),
403 td->td_samplesperpixel);
404 break;
405 case TIFFTAG_JPEGACTABLES:
406 setJPEGCTable(&td->td_actab, va_arg(ap, u_char **),
407 td->td_samplesperpixel);
408 break;
409 #endif
410 #ifdef COLORIMETRY_SUPPORT
411 case TIFFTAG_WHITEPOINT:
412 setFloatArray(&td->td_whitepoint, va_arg(ap, float *), 2);
413 break;
414 case TIFFTAG_PRIMARYCHROMATICITIES:
415 setFloatArray(&td->td_primarychromas, va_arg(ap, float *), 6);
416 break;
417 case TIFFTAG_TRANSFERFUNCTION:
418 for (i = 0; i < td->td_samplesperpixel; i++)
419 setShortArray(&td->td_transferfunction[i],
420 va_arg(ap, u_short *), 1L<<td->td_bitspersample);
421 break;
422 case TIFFTAG_REFERENCEBLACKWHITE:
423 /* XXX should check for null range */
424 v = 2 * td->td_samplesperpixel;
425 setFloatArray(&td->td_refblackwhite, va_arg(ap, float *), v);
426 break;
427 #endif
428 #ifdef CMYK_SUPPORT
429 case TIFFTAG_INKSET:
430 td->td_inkset = va_arg(ap, int);
431 break;
432 case TIFFTAG_DOTRANGE:
433 /* XXX should check for null range */
434 td->td_dotrange[0] = va_arg(ap, int);
435 td->td_dotrange[1] = va_arg(ap, int);
436 break;
437 case TIFFTAG_INKNAMES:
438 setString(&td->td_inknames, va_arg(ap, char *));
439 break;
440 case TIFFTAG_TARGETPRINTER:
441 setString(&td->td_targetprinter, va_arg(ap, char *));
442 break;
443 #endif
444 default:
445 TIFFError(tif->tif_name,
446 "Internal error, tag value botch, tag \"%s\"",
447 TIFFFieldWithTag(tag)->field_name);
448 status = 0;
449 break;
450 }
451 if (status) {
452 TIFFSetFieldBit(tif, TIFFFieldWithTag(tag)->field_bit);
453 tif->tif_flags |= TIFF_DIRTYDIRECT;
454 }
455 va_end(ap);
456 return (status);
457 badvalue:
458 TIFFError(tif->tif_name, "%ld: Bad value for \"%s\"", v,
459 TIFFFieldWithTag(tag)->field_name);
460 va_end(ap);
461 return (0);
462 }
463
464 /*
465 * Return 1/0 according to whether or not
466 * it is permissible to set the tag's value.
467 * Note that we allow ImageLength to be changed
468 * so that we can append and extend to images.
469 * Any other tag may not be altered once writing
470 * has commenced, unless its value has no effect
471 * on the format of the data that is written.
472 */
473 static
OkToChangeTag(tif,tag)474 OkToChangeTag(tif, tag)
475 TIFF *tif;
476 int tag;
477 {
478 if (tag != TIFFTAG_IMAGELENGTH &&
479 (tif->tif_flags & TIFF_BEENWRITING)) {
480 TIFFFieldInfo const *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
481 /*
482 * Consult info table to see if tag can be changed
483 * after we've started writing. We only allow changes
484 * to those tags that don't/shouldn't affect the
485 * compression and/or format of the data.
486 */
487 if (fip && !fip->field_oktochange)
488 return (0);
489 }
490 return (1);
491 }
492
493 /*
494 * Record the value of a field in the
495 * internal directory structure. The
496 * field will be written to the file
497 * when/if the directory structure is
498 * updated.
499 */
500 /*VARARGS2*/
DECLARE2V(TIFFSetField,TIFF *,tif,int,tag)501 DECLARE2V(TIFFSetField, TIFF*, tif, int, tag)
502 {
503 int status = 0;
504
505 if (OkToChangeTag(tif, tag)) {
506 va_list ap;
507
508 VA_START(ap, tag);
509 status = TIFFSetField1(tif, tag, ap);
510 va_end(ap);
511 } else {
512 TIFFFieldInfo const *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
513 if (fip)
514 TIFFError("TIFFSetField",
515 "%s: Cannot modify tag \"%s\" while writing",
516 tif->tif_name, fip->field_name);
517 }
518 return (status);
519 }
520
521 /*
522 * Like TIFFSetField, but taking a varargs
523 * parameter list. This routine is useful
524 * for building higher-level interfaces on
525 * top of the library.
526 */
TIFFVSetField(tif,tag,ap)527 TIFFVSetField(tif, tag, ap)
528 TIFF *tif;
529 int tag;
530 va_list ap;
531 {
532 int status = 0;
533
534 if (!OkToChangeTag(tif, tag)) {
535 TIFFFieldInfo const *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
536 if (fip)
537 TIFFError("TIFFVSetField",
538 "%s: Cannot modify tag \"%s\" while writing",
539 tif->tif_name, fip->field_name);
540 } else
541 status = TIFFSetField1(tif, tag, ap);
542 return (status);
543 }
544
545 static
TIFFGetField1(td,tag,ap)546 TIFFGetField1(td, tag, ap)
547 TIFFDirectory *td;
548 int tag;
549 va_list ap;
550 {
551
552 switch (tag) {
553 case TIFFTAG_SUBFILETYPE:
554 *va_arg(ap, u_long *) = td->td_subfiletype;
555 break;
556 case TIFFTAG_IMAGEWIDTH:
557 *va_arg(ap, u_long *) = td->td_imagewidth;
558 break;
559 case TIFFTAG_IMAGELENGTH:
560 *va_arg(ap, u_long *) = td->td_imagelength;
561 break;
562 case TIFFTAG_BITSPERSAMPLE:
563 *va_arg(ap, u_short *) = td->td_bitspersample;
564 break;
565 case TIFFTAG_COMPRESSION:
566 *va_arg(ap, u_short *) = td->td_compression;
567 break;
568 case TIFFTAG_PHOTOMETRIC:
569 *va_arg(ap, u_short *) = td->td_photometric;
570 break;
571 case TIFFTAG_THRESHHOLDING:
572 *va_arg(ap, u_short *) = td->td_threshholding;
573 break;
574 case TIFFTAG_FILLORDER:
575 *va_arg(ap, u_short *) = td->td_fillorder;
576 break;
577 case TIFFTAG_DOCUMENTNAME:
578 *va_arg(ap, char **) = td->td_documentname;
579 break;
580 case TIFFTAG_ARTIST:
581 *va_arg(ap, char **) = td->td_artist;
582 break;
583 case TIFFTAG_DATETIME:
584 *va_arg(ap, char **) = td->td_datetime;
585 break;
586 case TIFFTAG_HOSTCOMPUTER:
587 *va_arg(ap, char **) = td->td_hostcomputer;
588 break;
589 case TIFFTAG_IMAGEDESCRIPTION:
590 *va_arg(ap, char **) = td->td_imagedescription;
591 break;
592 case TIFFTAG_MAKE:
593 *va_arg(ap, char **) = td->td_make;
594 break;
595 case TIFFTAG_MODEL:
596 *va_arg(ap, char **) = td->td_model;
597 break;
598 case TIFFTAG_SOFTWARE:
599 *va_arg(ap, char **) = td->td_software;
600 break;
601 case TIFFTAG_ORIENTATION:
602 *va_arg(ap, u_short *) = td->td_orientation;
603 break;
604 case TIFFTAG_SAMPLESPERPIXEL:
605 *va_arg(ap, u_short *) = td->td_samplesperpixel;
606 break;
607 case TIFFTAG_ROWSPERSTRIP:
608 *va_arg(ap, u_long *) = td->td_rowsperstrip;
609 break;
610 case TIFFTAG_MINSAMPLEVALUE:
611 *va_arg(ap, u_short *) = td->td_minsamplevalue;
612 break;
613 case TIFFTAG_MAXSAMPLEVALUE:
614 *va_arg(ap, u_short *) = td->td_maxsamplevalue;
615 break;
616 case TIFFTAG_XRESOLUTION:
617 *va_arg(ap, float *) = td->td_xresolution;
618 break;
619 case TIFFTAG_YRESOLUTION:
620 *va_arg(ap, float *) = td->td_yresolution;
621 break;
622 case TIFFTAG_PLANARCONFIG:
623 *va_arg(ap, u_short *) = td->td_planarconfig;
624 break;
625 case TIFFTAG_XPOSITION:
626 *va_arg(ap, float *) = td->td_xposition;
627 break;
628 case TIFFTAG_YPOSITION:
629 *va_arg(ap, float *) = td->td_yposition;
630 break;
631 case TIFFTAG_PAGENAME:
632 *va_arg(ap, char **) = td->td_pagename;
633 break;
634 case TIFFTAG_GROUP3OPTIONS:
635 *va_arg(ap, u_long *) = td->td_group3options;
636 break;
637 case TIFFTAG_GROUP4OPTIONS:
638 *va_arg(ap, u_long *) = td->td_group4options;
639 break;
640 case TIFFTAG_RESOLUTIONUNIT:
641 *va_arg(ap, u_short *) = td->td_resolutionunit;
642 break;
643 case TIFFTAG_PAGENUMBER:
644 *va_arg(ap, u_short *) = td->td_pagenumber[0];
645 *va_arg(ap, u_short *) = td->td_pagenumber[1];
646 break;
647 case TIFFTAG_HALFTONEHINTS:
648 *va_arg(ap, u_short *) = td->td_halftonehints[0];
649 *va_arg(ap, u_short *) = td->td_halftonehints[1];
650 break;
651 case TIFFTAG_COLORMAP:
652 *va_arg(ap, u_short **) = td->td_colormap[0];
653 *va_arg(ap, u_short **) = td->td_colormap[1];
654 *va_arg(ap, u_short **) = td->td_colormap[2];
655 break;
656 case TIFFTAG_PREDICTOR:
657 *va_arg(ap, u_short *) = td->td_predictor;
658 break;
659 case TIFFTAG_STRIPOFFSETS:
660 case TIFFTAG_TILEOFFSETS:
661 *va_arg(ap, u_long **) = td->td_stripoffset;
662 break;
663 case TIFFTAG_STRIPBYTECOUNTS:
664 case TIFFTAG_TILEBYTECOUNTS:
665 *va_arg(ap, u_long **) = td->td_stripbytecount;
666 break;
667 case TIFFTAG_MATTEING:
668 *va_arg(ap, u_short *) = td->td_matteing;
669 break;
670 case TIFFTAG_EXTRASAMPLES:
671 *va_arg(ap, u_short *) = td->td_matteing;
672 *va_arg(ap, u_short **) = &td->td_matteing;
673 break;
674 case TIFFTAG_BADFAXLINES:
675 *va_arg(ap, u_long *) = td->td_badfaxlines;
676 break;
677 case TIFFTAG_CLEANFAXDATA:
678 *va_arg(ap, u_short *) = td->td_cleanfaxdata;
679 break;
680 case TIFFTAG_CONSECUTIVEBADFAXLINES:
681 *va_arg(ap, u_long *) = td->td_badfaxrun;
682 break;
683 case TIFFTAG_TILEWIDTH:
684 *va_arg(ap, u_long *) = td->td_tilewidth;
685 break;
686 case TIFFTAG_TILELENGTH:
687 *va_arg(ap, u_long *) = td->td_tilelength;
688 break;
689 case TIFFTAG_TILEDEPTH:
690 *va_arg(ap, u_long *) = td->td_tiledepth;
691 break;
692 case TIFFTAG_DATATYPE:
693 *va_arg(ap, u_short *) =
694 (td->td_sampleformat == SAMPLEFORMAT_VOID ?
695 0 : td->td_sampleformat);
696 break;
697 case TIFFTAG_SAMPLEFORMAT:
698 *va_arg(ap, u_short *) = td->td_sampleformat;
699 break;
700 case TIFFTAG_IMAGEDEPTH:
701 *va_arg(ap, u_long *) = td->td_imagedepth;
702 break;
703 #ifdef YCBCR_SUPPORT
704 case TIFFTAG_YCBCRCOEFFICIENTS:
705 *va_arg(ap, float **) = td->td_ycbcrcoeffs;
706 break;
707 case TIFFTAG_YCBCRPOSITIONING:
708 *va_arg(ap, u_short *) = td->td_ycbcrpositioning;
709 break;
710 case TIFFTAG_YCBCRSUBSAMPLING:
711 *va_arg(ap, u_short *) = td->td_ycbcrsubsampling[0];
712 *va_arg(ap, u_short *) = td->td_ycbcrsubsampling[1];
713 break;
714 #endif
715 #ifdef JPEG_SUPPORT
716 case TIFFTAG_JPEGPROC:
717 *va_arg(ap, u_short *) = td->td_jpegproc;
718 break;
719 case TIFFTAG_JPEGRESTARTINTERVAL:
720 *va_arg(ap, u_short *) = td->td_jpegrestartinterval;
721 break;
722 case TIFFTAG_JPEGQTABLES:
723 *va_arg(ap, u_char ***) = td->td_qtab;
724 break;
725 case TIFFTAG_JPEGDCTABLES:
726 *va_arg(ap, u_char ***) = td->td_dctab;
727 break;
728 case TIFFTAG_JPEGACTABLES:
729 *va_arg(ap, u_char ***) = td->td_actab;
730 break;
731 #endif
732 #ifdef COLORIMETRY_SUPPORT
733 case TIFFTAG_WHITEPOINT:
734 *va_arg(ap, float **) = td->td_whitepoint;
735 break;
736 case TIFFTAG_PRIMARYCHROMATICITIES:
737 *va_arg(ap, float **) = td->td_primarychromas;
738 break;
739 case TIFFTAG_TRANSFERFUNCTION: {
740 int i;
741 for (i = 0; i < td->td_samplesperpixel; i++)
742 *va_arg(ap, u_short **) = td->td_transferfunction[i];
743 break;
744 }
745 case TIFFTAG_REFERENCEBLACKWHITE:
746 *va_arg(ap, float **) = td->td_refblackwhite;
747 break;
748 #endif
749 #ifdef CMYK_SUPPORT
750 case TIFFTAG_INKSET:
751 *va_arg(ap, u_short *) = td->td_inkset;
752 break;
753 case TIFFTAG_DOTRANGE:
754 *va_arg(ap, u_short *) = td->td_dotrange[0];
755 *va_arg(ap, u_short *) = td->td_dotrange[1];
756 break;
757 case TIFFTAG_INKNAMES:
758 *va_arg(ap, char **) = td->td_inknames;
759 break;
760 case TIFFTAG_TARGETPRINTER:
761 *va_arg(ap, char **) = td->td_targetprinter;
762 break;
763 #endif
764 default:
765 TIFFError("TIFFGetField1",
766 "Internal error, no value returned for tag \"%s\"",
767 TIFFFieldWithTag(tag)->field_name);
768 break;
769 }
770 va_end(ap);
771 }
772
773 /*
774 * Return the value of a field in the
775 * internal directory structure.
776 */
777 /*VARARGS2*/
DECLARE2V(TIFFGetField,TIFF *,tif,int,tag)778 DECLARE2V(TIFFGetField, TIFF*, tif, int, tag)
779 {
780 TIFFFieldInfo const *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
781
782 if (fip) {
783 u_short bit = fip->field_bit;
784 if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
785 va_list ap;
786 VA_START(ap, tag);
787 (void) TIFFGetField1(&tif->tif_dir, tag, ap);
788 va_end(ap);
789 return (1);
790 }
791 } else
792 TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
793 return (0);
794 }
795
796 /*
797 * Like TIFFGetField, but taking a varargs
798 * parameter list. This routine is useful
799 * for building higher-level interfaces on
800 * top of the library.
801 */
TIFFVGetField(tif,tag,ap)802 TIFFVGetField(tif, tag, ap)
803 TIFF *tif;
804 int tag;
805 va_list ap;
806 {
807 TIFFFieldInfo const *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
808
809 if (fip) {
810 u_short bit = fip->field_bit;
811 if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
812 (void) TIFFGetField1(&tif->tif_dir, tag, ap);
813 return (1);
814 }
815 } else
816 TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
817 return (0);
818 }
819
820 /*
821 * Internal interface to TIFFGetField...
822 */
823 int
824 /*VARARGS2*/
DECLARE2V(_TIFFgetfield,TIFFDirectory *,td,int,tag)825 DECLARE2V(_TIFFgetfield, TIFFDirectory*, td, int, tag)
826 {
827 va_list ap;
828
829 VA_START(ap, tag);
830 (void) TIFFGetField1(td, tag, ap);
831 va_end(ap);
832 }
833
834 #define CleanupField(member) { \
835 if (td->member) { \
836 free((char *)td->member); \
837 td->member = 0; \
838 } \
839 }
840
841 /*
842 * Release storage associated with a directory.
843 */
TIFFFreeDirectory(tif)844 TIFFFreeDirectory(tif)
845 TIFF *tif;
846 {
847 register TIFFDirectory *td = &tif->tif_dir;
848
849 CleanupField(td_colormap[0]);
850 CleanupField(td_colormap[1]);
851 CleanupField(td_colormap[2]);
852 CleanupField(td_documentname);
853 CleanupField(td_artist);
854 CleanupField(td_datetime);
855 CleanupField(td_hostcomputer);
856 CleanupField(td_imagedescription);
857 CleanupField(td_make);
858 CleanupField(td_model);
859 CleanupField(td_software);
860 CleanupField(td_pagename);
861 #ifdef YCBCR_SUPPORT
862 CleanupField(td_ycbcrcoeffs);
863 #endif
864 #ifdef JPEG_SUPPORT
865 CleanupField(td_qtab);
866 CleanupField(td_dctab);
867 CleanupField(td_actab);
868 #endif
869 #ifdef CMYK_SUPPORT
870 CleanupField(td_inknames);
871 CleanupField(td_targetprinter);
872 #endif
873 #ifdef COLORIMETRY_SUPPORT
874 CleanupField(td_whitepoint);
875 CleanupField(td_primarychromas);
876 CleanupField(td_refblackwhite);
877 CleanupField(td_transferfunction[0]);
878 CleanupField(td_transferfunction[1]);
879 CleanupField(td_transferfunction[2]);
880 CleanupField(td_transferfunction[3]);
881 #endif
882 CleanupField(td_stripoffset);
883 CleanupField(td_stripbytecount);
884 }
885 #undef CleanupField
886
887 /*
888 * Setup a default directory structure.
889 */
TIFFDefaultDirectory(tif)890 TIFFDefaultDirectory(tif)
891 TIFF *tif;
892 {
893 register TIFFDirectory *td = &tif->tif_dir;
894
895 bzero((char *)td, sizeof (*td));
896 td->td_fillorder = FILLORDER_MSB2LSB;
897 td->td_bitspersample = 1;
898 td->td_threshholding = THRESHHOLD_BILEVEL;
899 td->td_orientation = ORIENTATION_TOPLEFT;
900 td->td_samplesperpixel = 1;
901 td->td_predictor = 1;
902 td->td_rowsperstrip = 0xffffffff;
903 td->td_tilewidth = 0xffffffff;
904 td->td_tilelength = 0xffffffff;
905 td->td_tiledepth = 1;
906 td->td_resolutionunit = RESUNIT_INCH;
907 td->td_sampleformat = SAMPLEFORMAT_VOID;
908 td->td_imagedepth = 1;
909 #ifdef YCBCR_SUPPORT
910 td->td_ycbcrsubsampling[0] = 2;
911 td->td_ycbcrsubsampling[1] = 2;
912 td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
913 #endif
914 #ifdef CMYK_SUPPORT
915 td->td_inkset = INKSET_CMYK;
916 #endif
917 (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
918 /*
919 * NB: The directory is marked dirty as a result of setting
920 * up the default compression scheme. However, this really
921 * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
922 * if the user does something. We could just do the setup
923 * by hand, but it seems better to use the normal mechanism
924 * (i.e. TIFFSetField).
925 */
926 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
927 return (1);
928 }
929
930 /*
931 * Set the n-th directory as the current directory.
932 * NB: Directories are numbered starting at 0.
933 */
TIFFSetDirectory(tif,dirn)934 TIFFSetDirectory(tif, dirn)
935 register TIFF *tif;
936 int dirn;
937 {
938 static char module[] = "TIFFSetDirectory";
939 u_short dircount;
940 long nextdir;
941 int n;
942
943 nextdir = tif->tif_header.tiff_diroff;
944 for (n = dirn; n > 0 && nextdir != 0; n--) {
945 if (!SeekOK(tif->tif_fd, nextdir) ||
946 !ReadOK(tif->tif_fd, &dircount, sizeof (dircount))) {
947 TIFFError(module, "%s: Error fetching directory count",
948 tif->tif_name);
949 return (0);
950 }
951 if (tif->tif_flags & TIFF_SWAB)
952 TIFFSwabShort(&dircount);
953 lseek(tif->tif_fd, dircount*sizeof (TIFFDirEntry), L_INCR);
954 if (!ReadOK(tif->tif_fd, &nextdir, sizeof (nextdir))) {
955 TIFFError(module, "%s: Error fetching directory link",
956 tif->tif_name);
957 return (0);
958 }
959 if (tif->tif_flags & TIFF_SWAB)
960 TIFFSwabLong((u_long *)&nextdir);
961 }
962 tif->tif_nextdiroff = nextdir;
963 /*
964 * Set curdir to the actual directory index. The
965 * -1 is because TIFFReadDirectory will increment
966 * tif_curdir after successfully reading the directory.
967 */
968 tif->tif_curdir = (dirn - n) - 1;
969 return (TIFFReadDirectory(tif));
970 }
971