projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Update libjpeg from 6b to 8b.
[reactos.git] / reactos / dll / 3rdparty / libtiff / tif_dir.c
1 /* $Id: tif_dir.c,v 1.75.2.5 2010-06-09 21:15:27 bfriesen Exp $ */
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 * Directory Tag Get & Set Routines.
31 * (and also some miscellaneous stuff)
32 */
33 #include "tiffiop.h"
34
35 /*
36 * These are used in the backwards compatibility code...
37 */
38 #define DATATYPE_VOID 0 /* !untyped data */
39 #define DATATYPE_INT 1 /* !signed integer data */
40 #define DATATYPE_UINT 2 /* !unsigned integer data */
41 #define DATATYPE_IEEEFP 3 /* !IEEE floating point data */
42
43 static void
44 setByteArray(void** vpp, void* vp, size_t nmemb, size_t elem_size)
45 {
46 if (*vpp)
47 _TIFFfree(*vpp), *vpp = 0;
48 if (vp) {
49 tsize_t bytes = nmemb * elem_size;
50 if (elem_size && bytes / elem_size == nmemb)
51 *vpp = (void*) _TIFFmalloc(bytes);
52 if (*vpp)
53 _TIFFmemcpy(*vpp, vp, bytes);
54 }
55 }
56 void _TIFFsetByteArray(void** vpp, void* vp, uint32 n)
57 { setByteArray(vpp, vp, n, 1); }
58 void _TIFFsetString(char** cpp, char* cp)
59 { setByteArray((void**) cpp, (void*) cp, strlen(cp)+1, 1); }
60 void _TIFFsetNString(char** cpp, char* cp, uint32 n)
61 { setByteArray((void**) cpp, (void*) cp, n, 1); }
62 void _TIFFsetShortArray(uint16** wpp, uint16* wp, uint32 n)
63 { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); }
64 void _TIFFsetLongArray(uint32** lpp, uint32* lp, uint32 n)
65 { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); }
66 void _TIFFsetFloatArray(float** fpp, float* fp, uint32 n)
67 { setByteArray((void**) fpp, (void*) fp, n, sizeof (float)); }
68 void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n)
69 { setByteArray((void**) dpp, (void*) dp, n, sizeof (double)); }
70
71 /*
72 * Install extra samples information.
73 */
74 static int
75 setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v)
76 {
77 /* XXX: Unassociated alpha data == 999 is a known Corel Draw bug, see below */
78 #define EXTRASAMPLE_COREL_UNASSALPHA 999
79
80 uint16* va;
81 uint32 i;
82
83 *v = va_arg(ap, uint32);
84 if ((uint16) *v > td->td_samplesperpixel)
85 return 0;
86 va = va_arg(ap, uint16*);
87 if (*v > 0 && va == NULL) /* typically missing param */
88 return 0;
89 for (i = 0; i < *v; i++) {
90 if (va[i] > EXTRASAMPLE_UNASSALPHA) {
91 /*
92 * XXX: Corel Draw is known to produce incorrect
93 * ExtraSamples tags which must be patched here if we
94 * want to be able to open some of the damaged TIFF
95 * files:
96 */
97 if (va[i] == EXTRASAMPLE_COREL_UNASSALPHA)
98 va[i] = EXTRASAMPLE_UNASSALPHA;
99 else
100 return 0;
101 }
102 }
103 td->td_extrasamples = (uint16) *v;
104 _TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
105 return 1;
106
107 #undef EXTRASAMPLE_COREL_UNASSALPHA
108 }
109
110 static uint32
111 checkInkNamesString(TIFF* tif, uint32 slen, const char* s)
112 {
113 TIFFDirectory* td = &tif->tif_dir;
114 uint16 i = td->td_samplesperpixel;
115
116 if (slen > 0) {
117 const char* ep = s+slen;
118 const char* cp = s;
119 for (; i > 0; i--) {
120 for (; *cp != '\0'; cp++)
121 if (cp >= ep)
122 goto bad;
123 cp++; /* skip \0 */
124 }
125 return (cp-s);
126 }
127 bad:
128 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",
129 "%s: Invalid InkNames value; expecting %d names, found %d",
130 tif->tif_name,
131 td->td_samplesperpixel,
132 td->td_samplesperpixel-i);
133 return (0);
134 }
135
136 static int
137 _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
138 {
139 static const char module[] = "_TIFFVSetField";
140
141 TIFFDirectory* td = &tif->tif_dir;
142 int status = 1;
143 uint32 v32, i, v;
144 char* s;
145
146 switch (tag) {
147 case TIFFTAG_SUBFILETYPE:
148 td->td_subfiletype = va_arg(ap, uint32);
149 break;
150 case TIFFTAG_IMAGEWIDTH:
151 td->td_imagewidth = va_arg(ap, uint32);
152 break;
153 case TIFFTAG_IMAGELENGTH:
154 td->td_imagelength = va_arg(ap, uint32);
155 break;
156 case TIFFTAG_BITSPERSAMPLE:
157 td->td_bitspersample = (uint16) va_arg(ap, int);
158 /*
159 * If the data require post-decoding processing to byte-swap
160 * samples, set it up here. Note that since tags are required
161 * to be ordered, compression code can override this behaviour
162 * in the setup method if it wants to roll the post decoding
163 * work in with its normal work.
164 */
165 if (tif->tif_flags & TIFF_SWAB) {
166 if (td->td_bitspersample == 16)
167 tif->tif_postdecode = _TIFFSwab16BitData;
168 else if (td->td_bitspersample == 24)
169 tif->tif_postdecode = _TIFFSwab24BitData;
170 else if (td->td_bitspersample == 32)
171 tif->tif_postdecode = _TIFFSwab32BitData;
172 else if (td->td_bitspersample == 64)
173 tif->tif_postdecode = _TIFFSwab64BitData;
174 else if (td->td_bitspersample == 128) /* two 64's */
175 tif->tif_postdecode = _TIFFSwab64BitData;
176 }
177 break;
178 case TIFFTAG_COMPRESSION:
179 v = va_arg(ap, uint32) & 0xffff;
180 /*
181 * If we're changing the compression scheme, the notify the
182 * previous module so that it can cleanup any state it's
183 * setup.
184 */
185 if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
186 if (td->td_compression == v)
187 break;
188 (*tif->tif_cleanup)(tif);
189 tif->tif_flags &= ~TIFF_CODERSETUP;
190 }
191 /*
192 * Setup new compression routine state.
193 */
194 if( (status = TIFFSetCompressionScheme(tif, v)) != 0 )
195 td->td_compression = (uint16) v;
196 else
197 status = 0;
198 break;
199 case TIFFTAG_PHOTOMETRIC:
200 td->td_photometric = (uint16) va_arg(ap, int);
201 break;
202 case TIFFTAG_THRESHHOLDING:
203 td->td_threshholding = (uint16) va_arg(ap, int);
204 break;
205 case TIFFTAG_FILLORDER:
206 v = va_arg(ap, uint32);
207 if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
208 goto badvalue;
209 td->td_fillorder = (uint16) v;
210 break;
211 case TIFFTAG_ORIENTATION:
212 v = va_arg(ap, uint32);
213 if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v)
214 goto badvalue;
215 else
216 td->td_orientation = (uint16) v;
217 break;
218 case TIFFTAG_SAMPLESPERPIXEL:
219 /* XXX should cross check -- e.g. if pallette, then 1 */
220 v = va_arg(ap, uint32);
221 if (v == 0)
222 goto badvalue;
223 td->td_samplesperpixel = (uint16) v;
224 break;
225 case TIFFTAG_ROWSPERSTRIP:
226 v32 = va_arg(ap, uint32);
227 if (v32 == 0)
228 goto badvalue32;
229 td->td_rowsperstrip = v32;
230 if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
231 td->td_tilelength = v32;
232 td->td_tilewidth = td->td_imagewidth;
233 }
234 break;
235 case TIFFTAG_MINSAMPLEVALUE:
236 td->td_minsamplevalue = (uint16) va_arg(ap, int);
237 break;
238 case TIFFTAG_MAXSAMPLEVALUE:
239 td->td_maxsamplevalue = (uint16) va_arg(ap, int);
240 break;
241 case TIFFTAG_SMINSAMPLEVALUE:
242 td->td_sminsamplevalue = va_arg(ap, double);
243 break;
244 case TIFFTAG_SMAXSAMPLEVALUE:
245 td->td_smaxsamplevalue = va_arg(ap, double);
246 break;
247 case TIFFTAG_XRESOLUTION:
248 td->td_xresolution = (float) va_arg(ap, double);
249 break;
250 case TIFFTAG_YRESOLUTION:
251 td->td_yresolution = (float) va_arg(ap, double);
252 break;
253 case TIFFTAG_PLANARCONFIG:
254 v = va_arg(ap, uint32);
255 if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
256 goto badvalue;
257 td->td_planarconfig = (uint16) v;
258 break;
259 case TIFFTAG_XPOSITION:
260 td->td_xposition = (float) va_arg(ap, double);
261 break;
262 case TIFFTAG_YPOSITION:
263 td->td_yposition = (float) va_arg(ap, double);
264 break;
265 case TIFFTAG_RESOLUTIONUNIT:
266 v = va_arg(ap, uint32);
267 if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
268 goto badvalue;
269 td->td_resolutionunit = (uint16) v;
270 break;
271 case TIFFTAG_PAGENUMBER:
272 td->td_pagenumber[0] = (uint16) va_arg(ap, int);
273 td->td_pagenumber[1] = (uint16) va_arg(ap, int);
274 break;
275 case TIFFTAG_HALFTONEHINTS:
276 td->td_halftonehints[0] = (uint16) va_arg(ap, int);
277 td->td_halftonehints[1] = (uint16) va_arg(ap, int);
278 break;
279 case TIFFTAG_COLORMAP:
280 v32 = (uint32)(1L<<td->td_bitspersample);
281 _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);
282 _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);
283 _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
284 break;
285 case TIFFTAG_EXTRASAMPLES:
286 if (!setExtraSamples(td, ap, &v))
287 goto badvalue;
288 break;
289 case TIFFTAG_MATTEING:
290 td->td_extrasamples = (uint16) (va_arg(ap, int) != 0);
291 if (td->td_extrasamples) {
292 uint16 sv = EXTRASAMPLE_ASSOCALPHA;
293 _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1);
294 }
295 break;
296 case TIFFTAG_TILEWIDTH:
297 v32 = va_arg(ap, uint32);
298 if (v32 % 16) {
299 if (tif->tif_mode != O_RDONLY)
300 goto badvalue32;
301 TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
302 "Nonstandard tile width %d, convert file", v32);
303 }
304 td->td_tilewidth = v32;
305 tif->tif_flags |= TIFF_ISTILED;
306 break;
307 case TIFFTAG_TILELENGTH:
308 v32 = va_arg(ap, uint32);
309 if (v32 % 16) {
310 if (tif->tif_mode != O_RDONLY)
311 goto badvalue32;
312 TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
313 "Nonstandard tile length %d, convert file", v32);
314 }
315 td->td_tilelength = v32;
316 tif->tif_flags |= TIFF_ISTILED;
317 break;
318 case TIFFTAG_TILEDEPTH:
319 v32 = va_arg(ap, uint32);
320 if (v32 == 0)
321 goto badvalue32;
322 td->td_tiledepth = v32;
323 break;
324 case TIFFTAG_DATATYPE:
325 v = va_arg(ap, uint32);
326 switch (v) {
327 case DATATYPE_VOID: v = SAMPLEFORMAT_VOID; break;
328 case DATATYPE_INT: v = SAMPLEFORMAT_INT; break;
329 case DATATYPE_UINT: v = SAMPLEFORMAT_UINT; break;
330 case DATATYPE_IEEEFP: v = SAMPLEFORMAT_IEEEFP;break;
331 default: goto badvalue;
332 }
333 td->td_sampleformat = (uint16) v;
334 break;
335 case TIFFTAG_SAMPLEFORMAT:
336 v = va_arg(ap, uint32);
337 if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_COMPLEXIEEEFP < v)
338 goto badvalue;
339 td->td_sampleformat = (uint16) v;
340
341 /* Try to fix up the SWAB function for complex data. */
342 if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
343 && td->td_bitspersample == 32
344 && tif->tif_postdecode == _TIFFSwab32BitData )
345 tif->tif_postdecode = _TIFFSwab16BitData;
346 else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
347 || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP)
348 && td->td_bitspersample == 64
349 && tif->tif_postdecode == _TIFFSwab64BitData )
350 tif->tif_postdecode = _TIFFSwab32BitData;
351 break;
352 case TIFFTAG_IMAGEDEPTH:
353 td->td_imagedepth = va_arg(ap, uint32);
354 break;
355 case TIFFTAG_SUBIFD:
356 if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {
357 td->td_nsubifd = (uint16) va_arg(ap, int);
358 _TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*),
359 (long) td->td_nsubifd);
360 } else {
361 TIFFErrorExt(tif->tif_clientdata, module,
362 "%s: Sorry, cannot nest SubIFDs",
363 tif->tif_name);
364 status = 0;
365 }
366 break;
367 case TIFFTAG_YCBCRPOSITIONING:
368 td->td_ycbcrpositioning = (uint16) va_arg(ap, int);
369 break;
370 case TIFFTAG_YCBCRSUBSAMPLING:
371 td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int);
372 td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int);
373 break;
374 case TIFFTAG_TRANSFERFUNCTION:
375 v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
376 for (i = 0; i < v; i++)
377 _TIFFsetShortArray(&td->td_transferfunction[i],
378 va_arg(ap, uint16*), 1L<<td->td_bitspersample);
379 break;
380 case TIFFTAG_REFERENCEBLACKWHITE:
381 /* XXX should check for null range */
382 _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6);
383 break;
384 case TIFFTAG_INKNAMES:
385 v = va_arg(ap, uint32);
386 s = va_arg(ap, char*);
387 v = checkInkNamesString(tif, v, s);
388 status = v > 0;
389 if( v > 0 ) {
390 _TIFFsetNString(&td->td_inknames, s, v);
391 td->td_inknameslen = v;
392 }
393 break;
394 default: {
395 TIFFTagValue *tv;
396 int tv_size, iCustom;
397 const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
398
399 /*
400 * This can happen if multiple images are open with different
401 * codecs which have private tags. The global tag information
402 * table may then have tags that are valid for one file but not
403 * the other. If the client tries to set a tag that is not valid
404 * for the image's codec then we'll arrive here. This
405 * happens, for example, when tiffcp is used to convert between
406 * compression schemes and codec-specific tags are blindly copied.
407 */
408 if(fip == NULL || fip->field_bit != FIELD_CUSTOM) {
409 TIFFErrorExt(tif->tif_clientdata, module,
410 "%s: Invalid %stag \"%s\" (not supported by codec)",
411 tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
412 fip ? fip->field_name : "Unknown");
413 status = 0;
414 break;
415 }
416
417 /*
418 * Find the existing entry for this custom value.
419 */
420 tv = NULL;
421 for (iCustom = 0; iCustom < td->td_customValueCount; iCustom++) {
422 if (td->td_customValues[iCustom].info->field_tag == tag) {
423 tv = td->td_customValues + iCustom;
424 if (tv->value != NULL) {
425 _TIFFfree(tv->value);
426 tv->value = NULL;
427 }
428 break;
429 }
430 }
431
432 /*
433 * Grow the custom list if the entry was not found.
434 */
435 if(tv == NULL) {
436 TIFFTagValue *new_customValues;
437
438 td->td_customValueCount++;
439 new_customValues = (TIFFTagValue *)
440 _TIFFrealloc(td->td_customValues,
441 sizeof(TIFFTagValue) * td->td_customValueCount);
442 if (!new_customValues) {
443 TIFFErrorExt(tif->tif_clientdata, module,
444 "%s: Failed to allocate space for list of custom values",
445 tif->tif_name);
446 status = 0;
447 goto end;
448 }
449
450 td->td_customValues = new_customValues;
451
452 tv = td->td_customValues + (td->td_customValueCount - 1);
453 tv->info = fip;
454 tv->value = NULL;
455 tv->count = 0;
456 }
457
458 /*
459 * Set custom value ... save a copy of the custom tag value.
460 */
461 tv_size = _TIFFDataSize(fip->field_type);
462 if (tv_size == 0) {
463 status = 0;
464 TIFFErrorExt(tif->tif_clientdata, module,
465 "%s: Bad field type %d for \"%s\"",
466 tif->tif_name, fip->field_type,
467 fip->field_name);
468 goto end;
469 }
470
471 if(fip->field_passcount) {
472 if (fip->field_writecount == TIFF_VARIABLE2)
473 tv->count = (uint32) va_arg(ap, uint32);
474 else
475 tv->count = (int) va_arg(ap, int);
476 } else if (fip->field_writecount == TIFF_VARIABLE
477 || fip->field_writecount == TIFF_VARIABLE2)
478 tv->count = 1;
479 else if (fip->field_writecount == TIFF_SPP)
480 tv->count = td->td_samplesperpixel;
481 else
482 tv->count = fip->field_writecount;
483
484
485 if (fip->field_type == TIFF_ASCII)
486 _TIFFsetString((char **)&tv->value, va_arg(ap, char *));
487 else {
488 tv->value = _TIFFCheckMalloc(tif, tv_size, tv->count,
489 "Tag Value");
490 if (!tv->value) {
491 status = 0;
492 goto end;
493 }
494
495 if ((fip->field_passcount
496 || fip->field_writecount == TIFF_VARIABLE
497 || fip->field_writecount == TIFF_VARIABLE2
498 || fip->field_writecount == TIFF_SPP
499 || tv->count > 1)
500 && fip->field_tag != TIFFTAG_PAGENUMBER
501 && fip->field_tag != TIFFTAG_HALFTONEHINTS
502 && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
503 && fip->field_tag != TIFFTAG_DOTRANGE) {
504 _TIFFmemcpy(tv->value, va_arg(ap, void *),
505 tv->count * tv_size);
506 } else {
507 /*
508 * XXX: The following loop required to handle
509 * TIFFTAG_PAGENUMBER, TIFFTAG_HALFTONEHINTS,
510 * TIFFTAG_YCBCRSUBSAMPLING and TIFFTAG_DOTRANGE tags.
511 * These tags are actually arrays and should be passed as
512 * array pointers to TIFFSetField() function, but actually
513 * passed as a list of separate values. This behaviour
514 * must be changed in the future!
515 */
516 int i;
517 char *val = (char *)tv->value;
518
519 for (i = 0; i < tv->count; i++, val += tv_size) {
520 switch (fip->field_type) {
521 case TIFF_BYTE:
522 case TIFF_UNDEFINED:
523 {
524 uint8 v = (uint8)va_arg(ap, int);
525 _TIFFmemcpy(val, &v, tv_size);
526 }
527 break;
528 case TIFF_SBYTE:
529 {
530 int8 v = (int8)va_arg(ap, int);
531 _TIFFmemcpy(val, &v, tv_size);
532 }
533 break;
534 case TIFF_SHORT:
535 {
536 uint16 v = (uint16)va_arg(ap, int);
537 _TIFFmemcpy(val, &v, tv_size);
538 }
539 break;
540 case TIFF_SSHORT:
541 {
542 int16 v = (int16)va_arg(ap, int);
543 _TIFFmemcpy(val, &v, tv_size);
544 }
545 break;
546 case TIFF_LONG:
547 case TIFF_IFD:
548 {
549 uint32 v = va_arg(ap, uint32);
550 _TIFFmemcpy(val, &v, tv_size);
551 }
552 break;
553 case TIFF_SLONG:
554 {
555 int32 v = va_arg(ap, int32);
556 _TIFFmemcpy(val, &v, tv_size);
557 }
558 break;
559 case TIFF_RATIONAL:
560 case TIFF_SRATIONAL:
561 case TIFF_FLOAT:
562 {
563 float v = (float)va_arg(ap, double);
564 _TIFFmemcpy(val, &v, tv_size);
565 }
566 break;
567 case TIFF_DOUBLE:
568 {
569 double v = va_arg(ap, double);
570 _TIFFmemcpy(val, &v, tv_size);
571 }
572 break;
573 default:
574 _TIFFmemset(val, 0, tv_size);
575 status = 0;
576 break;
577 }
578 }
579 }
580 }
581 }
582 }
583 if (status) {
584 TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
585 tif->tif_flags |= TIFF_DIRTYDIRECT;
586 }
587
588 end:
589 va_end(ap);
590 return (status);
591 badvalue:
592 TIFFErrorExt(tif->tif_clientdata, module,
593 "%s: Bad value %d for \"%s\" tag",
594 tif->tif_name, v,
595 _TIFFFieldWithTag(tif, tag)->field_name);
596 va_end(ap);
597 return (0);
598 badvalue32:
599 TIFFErrorExt(tif->tif_clientdata, module,
600 "%s: Bad value %u for \"%s\" tag",
601 tif->tif_name, v32,
602 _TIFFFieldWithTag(tif, tag)->field_name);
603 va_end(ap);
604 return (0);
605 }
606
607 /*
608 * Return 1/0 according to whether or not
609 * it is permissible to set the tag's value.
610 * Note that we allow ImageLength to be changed
611 * so that we can append and extend to images.
612 * Any other tag may not be altered once writing
613 * has commenced, unless its value has no effect
614 * on the format of the data that is written.
615 */
616 static int
617 OkToChangeTag(TIFF* tif, ttag_t tag)
618 {
619 const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
620 if (!fip) { /* unknown tag */
621 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", "%s: Unknown %stag %u",
622 tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag);
623 return (0);
624 }
625 if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) &&
626 !fip->field_oktochange) {
627 /*
628 * Consult info table to see if tag can be changed
629 * after we've started writing. We only allow changes
630 * to those tags that don't/shouldn't affect the
631 * compression and/or format of the data.
632 */
633 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",
634 "%s: Cannot modify tag \"%s\" while writing",
635 tif->tif_name, fip->field_name);
636 return (0);
637 }
638 return (1);
639 }
640
641 /*
642 * Record the value of a field in the
643 * internal directory structure. The
644 * field will be written to the file
645 * when/if the directory structure is
646 * updated.
647 */
648 int
649 TIFFSetField(TIFF* tif, ttag_t tag, ...)
650 {
651 va_list ap;
652 int status;
653
654 va_start(ap, tag);
655 status = TIFFVSetField(tif, tag, ap);
656 va_end(ap);
657 return (status);
658 }
659
660 /*
661 * Like TIFFSetField, but taking a varargs
662 * parameter list. This routine is useful
663 * for building higher-level interfaces on
664 * top of the library.
665 */
666 int
667 TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
668 {
669 return OkToChangeTag(tif, tag) ?
670 (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0;
671 }
672
673 static int
674 _TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
675 {
676 TIFFDirectory* td = &tif->tif_dir;
677 int ret_val = 1;
678
679 switch (tag) {
680 case TIFFTAG_SUBFILETYPE:
681 *va_arg(ap, uint32*) = td->td_subfiletype;
682 break;
683 case TIFFTAG_IMAGEWIDTH:
684 *va_arg(ap, uint32*) = td->td_imagewidth;
685 break;
686 case TIFFTAG_IMAGELENGTH:
687 *va_arg(ap, uint32*) = td->td_imagelength;
688 break;
689 case TIFFTAG_BITSPERSAMPLE:
690 *va_arg(ap, uint16*) = td->td_bitspersample;
691 break;
692 case TIFFTAG_COMPRESSION:
693 *va_arg(ap, uint16*) = td->td_compression;
694 break;
695 case TIFFTAG_PHOTOMETRIC:
696 *va_arg(ap, uint16*) = td->td_photometric;
697 break;
698 case TIFFTAG_THRESHHOLDING:
699 *va_arg(ap, uint16*) = td->td_threshholding;
700 break;
701 case TIFFTAG_FILLORDER:
702 *va_arg(ap, uint16*) = td->td_fillorder;
703 break;
704 case TIFFTAG_ORIENTATION:
705 *va_arg(ap, uint16*) = td->td_orientation;
706 break;
707 case TIFFTAG_SAMPLESPERPIXEL:
708 *va_arg(ap, uint16*) = td->td_samplesperpixel;
709 break;
710 case TIFFTAG_ROWSPERSTRIP:
711 *va_arg(ap, uint32*) = td->td_rowsperstrip;
712 break;
713 case TIFFTAG_MINSAMPLEVALUE:
714 *va_arg(ap, uint16*) = td->td_minsamplevalue;
715 break;
716 case TIFFTAG_MAXSAMPLEVALUE:
717 *va_arg(ap, uint16*) = td->td_maxsamplevalue;
718 break;
719 case TIFFTAG_SMINSAMPLEVALUE:
720 *va_arg(ap, double*) = td->td_sminsamplevalue;
721 break;
722 case TIFFTAG_SMAXSAMPLEVALUE:
723 *va_arg(ap, double*) = td->td_smaxsamplevalue;
724 break;
725 case TIFFTAG_XRESOLUTION:
726 *va_arg(ap, float*) = td->td_xresolution;
727 break;
728 case TIFFTAG_YRESOLUTION:
729 *va_arg(ap, float*) = td->td_yresolution;
730 break;
731 case TIFFTAG_PLANARCONFIG:
732 *va_arg(ap, uint16*) = td->td_planarconfig;
733 break;
734 case TIFFTAG_XPOSITION:
735 *va_arg(ap, float*) = td->td_xposition;
736 break;
737 case TIFFTAG_YPOSITION:
738 *va_arg(ap, float*) = td->td_yposition;
739 break;
740 case TIFFTAG_RESOLUTIONUNIT:
741 *va_arg(ap, uint16*) = td->td_resolutionunit;
742 break;
743 case TIFFTAG_PAGENUMBER:
744 *va_arg(ap, uint16*) = td->td_pagenumber[0];
745 *va_arg(ap, uint16*) = td->td_pagenumber[1];
746 break;
747 case TIFFTAG_HALFTONEHINTS:
748 *va_arg(ap, uint16*) = td->td_halftonehints[0];
749 *va_arg(ap, uint16*) = td->td_halftonehints[1];
750 break;
751 case TIFFTAG_COLORMAP:
752 *va_arg(ap, uint16**) = td->td_colormap[0];
753 *va_arg(ap, uint16**) = td->td_colormap[1];
754 *va_arg(ap, uint16**) = td->td_colormap[2];
755 break;
756 case TIFFTAG_STRIPOFFSETS:
757 case TIFFTAG_TILEOFFSETS:
758 *va_arg(ap, uint32**) = td->td_stripoffset;
759 break;
760 case TIFFTAG_STRIPBYTECOUNTS:
761 case TIFFTAG_TILEBYTECOUNTS:
762 *va_arg(ap, uint32**) = td->td_stripbytecount;
763 break;
764 case TIFFTAG_MATTEING:
765 *va_arg(ap, uint16*) =
766 (td->td_extrasamples == 1 &&
767 td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
768 break;
769 case TIFFTAG_EXTRASAMPLES:
770 *va_arg(ap, uint16*) = td->td_extrasamples;
771 *va_arg(ap, uint16**) = td->td_sampleinfo;
772 break;
773 case TIFFTAG_TILEWIDTH:
774 *va_arg(ap, uint32*) = td->td_tilewidth;
775 break;
776 case TIFFTAG_TILELENGTH:
777 *va_arg(ap, uint32*) = td->td_tilelength;
778 break;
779 case TIFFTAG_TILEDEPTH:
780 *va_arg(ap, uint32*) = td->td_tiledepth;
781 break;
782 case TIFFTAG_DATATYPE:
783 switch (td->td_sampleformat) {
784 case SAMPLEFORMAT_UINT:
785 *va_arg(ap, uint16*) = DATATYPE_UINT;
786 break;
787 case SAMPLEFORMAT_INT:
788 *va_arg(ap, uint16*) = DATATYPE_INT;
789 break;
790 case SAMPLEFORMAT_IEEEFP:
791 *va_arg(ap, uint16*) = DATATYPE_IEEEFP;
792 break;
793 case SAMPLEFORMAT_VOID:
794 *va_arg(ap, uint16*) = DATATYPE_VOID;
795 break;
796 }
797 break;
798 case TIFFTAG_SAMPLEFORMAT:
799 *va_arg(ap, uint16*) = td->td_sampleformat;
800 break;
801 case TIFFTAG_IMAGEDEPTH:
802 *va_arg(ap, uint32*) = td->td_imagedepth;
803 break;
804 case TIFFTAG_SUBIFD:
805 *va_arg(ap, uint16*) = td->td_nsubifd;
806 *va_arg(ap, uint32**) = td->td_subifd;
807 break;
808 case TIFFTAG_YCBCRPOSITIONING:
809 *va_arg(ap, uint16*) = td->td_ycbcrpositioning;
810 break;
811 case TIFFTAG_YCBCRSUBSAMPLING:
812 *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];
813 *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];
814 break;
815 case TIFFTAG_TRANSFERFUNCTION:
816 *va_arg(ap, uint16**) = td->td_transferfunction[0];
817 if (td->td_samplesperpixel - td->td_extrasamples > 1) {
818 *va_arg(ap, uint16**) = td->td_transferfunction[1];
819 *va_arg(ap, uint16**) = td->td_transferfunction[2];
820 }
821 break;
822 case TIFFTAG_REFERENCEBLACKWHITE:
823 *va_arg(ap, float**) = td->td_refblackwhite;
824 break;
825 case TIFFTAG_INKNAMES:
826 *va_arg(ap, char**) = td->td_inknames;
827 break;
828 default:
829 {
830 const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
831 int i;
832
833 /*
834 * This can happen if multiple images are open with different
835 * codecs which have private tags. The global tag information
836 * table may then have tags that are valid for one file but not
837 * the other. If the client tries to get a tag that is not valid
838 * for the image's codec then we'll arrive here.
839 */
840 if( fip == NULL || fip->field_bit != FIELD_CUSTOM )
841 {
842 TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField",
843 "%s: Invalid %stag \"%s\" "
844 "(not supported by codec)",
845 tif->tif_name,
846 isPseudoTag(tag) ? "pseudo-" : "",
847 fip ? fip->field_name : "Unknown");
848 ret_val = 0;
849 break;
850 }
851
852 /*
853 * Do we have a custom value?
854 */
855 ret_val = 0;
856 for (i = 0; i < td->td_customValueCount; i++) {
857 TIFFTagValue *tv = td->td_customValues + i;
858
859 if (tv->info->field_tag != tag)
860 continue;
861
862 if (fip->field_passcount) {
863 if (fip->field_readcount == TIFF_VARIABLE2)
864 *va_arg(ap, uint32*) = (uint32)tv->count;
865 else /* Assume TIFF_VARIABLE */
866 *va_arg(ap, uint16*) = (uint16)tv->count;
867 *va_arg(ap, void **) = tv->value;
868 ret_val = 1;
869 } else {
870 if ((fip->field_type == TIFF_ASCII
871 || fip->field_readcount == TIFF_VARIABLE
872 || fip->field_readcount == TIFF_VARIABLE2
873 || fip->field_readcount == TIFF_SPP
874 || tv->count > 1)
875 && fip->field_tag != TIFFTAG_PAGENUMBER
876 && fip->field_tag != TIFFTAG_HALFTONEHINTS
877 && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
878 && fip->field_tag != TIFFTAG_DOTRANGE) {
879 *va_arg(ap, void **) = tv->value;
880 ret_val = 1;
881 } else {
882 int j;
883 char *val = (char *)tv->value;
884
885 for (j = 0; j < tv->count;
886 j++, val += _TIFFDataSize(tv->info->field_type)) {
887 switch (fip->field_type) {
888 case TIFF_BYTE:
889 case TIFF_UNDEFINED:
890 *va_arg(ap, uint8*) =
891 *(uint8 *)val;
892 ret_val = 1;
893 break;
894 case TIFF_SBYTE:
895 *va_arg(ap, int8*) =
896 *(int8 *)val;
897 ret_val = 1;
898 break;
899 case TIFF_SHORT:
900 *va_arg(ap, uint16*) =
901 *(uint16 *)val;
902 ret_val = 1;
903 break;
904 case TIFF_SSHORT:
905 *va_arg(ap, int16*) =
906 *(int16 *)val;
907 ret_val = 1;
908 break;
909 case TIFF_LONG:
910 case TIFF_IFD:
911 *va_arg(ap, uint32*) =
912 *(uint32 *)val;
913 ret_val = 1;
914 break;
915 case TIFF_SLONG:
916 *va_arg(ap, int32*) =
917 *(int32 *)val;
918 ret_val = 1;
919 break;
920 case TIFF_RATIONAL:
921 case TIFF_SRATIONAL:
922 case TIFF_FLOAT:
923 *va_arg(ap, float*) =
924 *(float *)val;
925 ret_val = 1;
926 break;
927 case TIFF_DOUBLE:
928 *va_arg(ap, double*) =
929 *(double *)val;
930 ret_val = 1;
931 break;
932 default:
933 ret_val = 0;
934 break;
935 }
936 }
937 }
938 }
939 break;
940 }
941 }
942 }
943 return(ret_val);
944 }
945
946 /*
947 * Return the value of a field in the
948 * internal directory structure.
949 */
950 int
951 TIFFGetField(TIFF* tif, ttag_t tag, ...)
952 {
953 int status;
954 va_list ap;
955
956 va_start(ap, tag);
957 status = TIFFVGetField(tif, tag, ap);
958 va_end(ap);
959 return (status);
960 }
961
962 /*
963 * Like TIFFGetField, but taking a varargs
964 * parameter list. This routine is useful
965 * for building higher-level interfaces on
966 * top of the library.
967 */
968 int
969 TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
970 {
971 const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
972 return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ?
973 (*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0);
974 }
975
976 #define CleanupField(member) { \
977 if (td->member) { \
978 _TIFFfree(td->member); \
979 td->member = 0; \
980 } \
981 }
982
983 /*
984 * Release storage associated with a directory.
985 */
986 void
987 TIFFFreeDirectory(TIFF* tif)
988 {
989 TIFFDirectory *td = &tif->tif_dir;
990 int i;
991
992 _TIFFmemset(td->td_fieldsset, 0, FIELD_SETLONGS);
993 CleanupField(td_colormap[0]);
994 CleanupField(td_colormap[1]);
995 CleanupField(td_colormap[2]);
996 CleanupField(td_sampleinfo);
997 CleanupField(td_subifd);
998 CleanupField(td_inknames);
999 CleanupField(td_refblackwhite);
1000 CleanupField(td_transferfunction[0]);
1001 CleanupField(td_transferfunction[1]);
1002 CleanupField(td_transferfunction[2]);
1003 CleanupField(td_stripoffset);
1004 CleanupField(td_stripbytecount);
1005 TIFFClrFieldBit(tif, FIELD_YCBCRSUBSAMPLING);
1006 TIFFClrFieldBit(tif, FIELD_YCBCRPOSITIONING);
1007
1008 /* Cleanup custom tag values */
1009 for( i = 0; i < td->td_customValueCount; i++ ) {
1010 if (td->td_customValues[i].value)
1011 _TIFFfree(td->td_customValues[i].value);
1012 }
1013
1014 td->td_customValueCount = 0;
1015 CleanupField(td_customValues);
1016 }
1017 #undef CleanupField
1018
1019 /*
1020 * Client Tag extension support (from Niles Ritter).
1021 */
1022 static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL;
1023
1024 TIFFExtendProc
1025 TIFFSetTagExtender(TIFFExtendProc extender)
1026 {
1027 TIFFExtendProc prev = _TIFFextender;
1028 _TIFFextender = extender;
1029 return (prev);
1030 }
1031
1032 /*
1033 * Setup for a new directory. Should we automatically call
1034 * TIFFWriteDirectory() if the current one is dirty?
1035 *
1036 * The newly created directory will not exist on the file till
1037 * TIFFWriteDirectory(), TIFFFlush() or TIFFClose() is called.
1038 */
1039 int
1040 TIFFCreateDirectory(TIFF* tif)
1041 {
1042 TIFFDefaultDirectory(tif);
1043 tif->tif_diroff = 0;
1044 tif->tif_nextdiroff = 0;
1045 tif->tif_curoff = 0;
1046 tif->tif_row = (uint32) -1;
1047 tif->tif_curstrip = (tstrip_t) -1;
1048
1049 return 0;
1050 }
1051
1052 /*
1053 * Setup a default directory structure.
1054 */
1055 int
1056 TIFFDefaultDirectory(TIFF* tif)
1057 {
1058 register TIFFDirectory* td = &tif->tif_dir;
1059
1060 size_t tiffFieldInfoCount;
1061 const TIFFFieldInfo *tiffFieldInfo =
1062 _TIFFGetFieldInfo(&tiffFieldInfoCount);
1063 _TIFFSetupFieldInfo(tif, tiffFieldInfo, tiffFieldInfoCount);
1064
1065 _TIFFmemset(td, 0, sizeof (*td));
1066 td->td_fillorder = FILLORDER_MSB2LSB;
1067 td->td_bitspersample = 1;
1068 td->td_threshholding = THRESHHOLD_BILEVEL;
1069 td->td_orientation = ORIENTATION_TOPLEFT;
1070 td->td_samplesperpixel = 1;
1071 td->td_rowsperstrip = (uint32) -1;
1072 td->td_tilewidth = 0;
1073 td->td_tilelength = 0;
1074 td->td_tiledepth = 1;
1075 td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */
1076 td->td_resolutionunit = RESUNIT_INCH;
1077 td->td_sampleformat = SAMPLEFORMAT_UINT;
1078 td->td_imagedepth = 1;
1079 td->td_ycbcrsubsampling[0] = 2;
1080 td->td_ycbcrsubsampling[1] = 2;
1081 td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
1082 tif->tif_postdecode = _TIFFNoPostDecode;
1083 tif->tif_foundfield = NULL;
1084 tif->tif_tagmethods.vsetfield = _TIFFVSetField;
1085 tif->tif_tagmethods.vgetfield = _TIFFVGetField;
1086 tif->tif_tagmethods.printdir = NULL;
1087 /*
1088 * Give client code a chance to install their own
1089 * tag extensions & methods, prior to compression overloads.
1090 */
1091 if (_TIFFextender)
1092 (*_TIFFextender)(tif);
1093 (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
1094 /*
1095 * NB: The directory is marked dirty as a result of setting
1096 * up the default compression scheme. However, this really
1097 * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
1098 * if the user does something. We could just do the setup
1099 * by hand, but it seems better to use the normal mechanism
1100 * (i.e. TIFFSetField).
1101 */
1102 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
1103
1104 /*
1105 * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
1106 * we clear the ISTILED flag when setting up a new directory.
1107 * Should we also be clearing stuff like INSUBIFD?
1108 */
1109 tif->tif_flags &= ~TIFF_ISTILED;
1110 /*
1111 * Clear other directory-specific fields.
1112 */
1113 tif->tif_tilesize = -1;
1114 tif->tif_scanlinesize = -1;
1115
1116 return (1);
1117 }
1118
1119 static int
1120 TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off)
1121 {
1122 static const char module[] = "TIFFAdvanceDirectory";
1123 uint16 dircount;
1124 if (isMapped(tif))
1125 {
1126 toff_t poff=*nextdir;
1127 if (poff+sizeof(uint16) > tif->tif_size)
1128 {
1129 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
1130 tif->tif_name);
1131 return (0);
1132 }
1133 _TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16));
1134 if (tif->tif_flags & TIFF_SWAB)
1135 TIFFSwabShort(&dircount);
1136 poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry);
1137 if (off != NULL)
1138 *off = poff;
1139 if (((toff_t) (poff+sizeof (uint32))) > tif->tif_size)
1140 {
1141 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
1142 tif->tif_name);
1143 return (0);
1144 }
1145 _TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32));
1146 if (tif->tif_flags & TIFF_SWAB)
1147 TIFFSwabLong(nextdir);
1148 return (1);
1149 }
1150 else
1151 {
1152 if (!SeekOK(tif, *nextdir) ||
1153 !ReadOK(tif, &dircount, sizeof (uint16))) {
1154 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
1155 tif->tif_name);
1156 return (0);
1157 }
1158 if (tif->tif_flags & TIFF_SWAB)
1159 TIFFSwabShort(&dircount);
1160 if (off != NULL)
1161 *off = TIFFSeekFile(tif,
1162 dircount*sizeof (TIFFDirEntry), SEEK_CUR);
1163 else
1164 (void) TIFFSeekFile(tif,
1165 dircount*sizeof (TIFFDirEntry), SEEK_CUR);
1166 if (!ReadOK(tif, nextdir, sizeof (uint32))) {
1167 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
1168 tif->tif_name);
1169 return (0);
1170 }
1171 if (tif->tif_flags & TIFF_SWAB)
1172 TIFFSwabLong(nextdir);
1173 return (1);
1174 }
1175 }
1176
1177 /*
1178 * Count the number of directories in a file.
1179 */
1180 tdir_t
1181 TIFFNumberOfDirectories(TIFF* tif)
1182 {
1183 toff_t nextdir = tif->tif_header.tiff_diroff;
1184 tdir_t n = 0;
1185
1186 while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL))
1187 n++;
1188 return (n);
1189 }
1190
1191 /*
1192 * Set the n-th directory as the current directory.
1193 * NB: Directories are numbered starting at 0.
1194 */
1195 int
1196 TIFFSetDirectory(TIFF* tif, tdir_t dirn)
1197 {
1198 toff_t nextdir;
1199 tdir_t n;
1200
1201 nextdir = tif->tif_header.tiff_diroff;
1202 for (n = dirn; n > 0 && nextdir != 0; n--)
1203 if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
1204 return (0);
1205 tif->tif_nextdiroff = nextdir;
1206 /*
1207 * Set curdir to the actual directory index. The
1208 * -1 is because TIFFReadDirectory will increment
1209 * tif_curdir after successfully reading the directory.
1210 */
1211 tif->tif_curdir = (dirn - n) - 1;
1212 /*
1213 * Reset tif_dirnumber counter and start new list of seen directories.
1214 * We need this to prevent IFD loops.
1215 */
1216 tif->tif_dirnumber = 0;
1217 return (TIFFReadDirectory(tif));
1218 }
1219
1220 /*
1221 * Set the current directory to be the directory
1222 * located at the specified file offset. This interface
1223 * is used mainly to access directories linked with
1224 * the SubIFD tag (e.g. thumbnail images).
1225 */
1226 int
1227 TIFFSetSubDirectory(TIFF* tif, uint32 diroff)
1228 {
1229 tif->tif_nextdiroff = diroff;
1230 /*
1231 * Reset tif_dirnumber counter and start new list of seen directories.
1232 * We need this to prevent IFD loops.
1233 */
1234 tif->tif_dirnumber = 0;
1235 return (TIFFReadDirectory(tif));
1236 }
1237
1238 /*
1239 * Return file offset of the current directory.
1240 */
1241 uint32
1242 TIFFCurrentDirOffset(TIFF* tif)
1243 {
1244 return (tif->tif_diroff);
1245 }
1246
1247 /*
1248 * Return an indication of whether or not we are
1249 * at the last directory in the file.
1250 */
1251 int
1252 TIFFLastDirectory(TIFF* tif)
1253 {
1254 return (tif->tif_nextdiroff == 0);
1255 }
1256
1257 /*
1258 * Unlink the specified directory from the directory chain.
1259 */
1260 int
1261 TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn)
1262 {
1263 static const char module[] = "TIFFUnlinkDirectory";
1264 toff_t nextdir;
1265 toff_t off;
1266 tdir_t n;
1267
1268 if (tif->tif_mode == O_RDONLY) {
1269 TIFFErrorExt(tif->tif_clientdata, module,
1270 "Can not unlink directory in read-only file");
1271 return (0);
1272 }
1273 /*
1274 * Go to the directory before the one we want
1275 * to unlink and nab the offset of the link
1276 * field we'll need to patch.
1277 */
1278 nextdir = tif->tif_header.tiff_diroff;
1279 off = sizeof (uint16) + sizeof (uint16);
1280 for (n = dirn-1; n > 0; n--) {
1281 if (nextdir == 0) {
1282 TIFFErrorExt(tif->tif_clientdata, module, "Directory %d does not exist", dirn);
1283 return (0);
1284 }
1285 if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
1286 return (0);
1287 }
1288 /*
1289 * Advance to the directory to be unlinked and fetch
1290 * the offset of the directory that follows.
1291 */
1292 if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
1293 return (0);
1294 /*
1295 * Go back and patch the link field of the preceding
1296 * directory to point to the offset of the directory
1297 * that follows.
1298 */
1299 (void) TIFFSeekFile(tif, off, SEEK_SET);
1300 if (tif->tif_flags & TIFF_SWAB)
1301 TIFFSwabLong(&nextdir);
1302 if (!WriteOK(tif, &nextdir, sizeof (uint32))) {
1303 TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
1304 return (0);
1305 }
1306 /*
1307 * Leave directory state setup safely. We don't have
1308 * facilities for doing inserting and removing directories,
1309 * so it's safest to just invalidate everything. This
1310 * means that the caller can only append to the directory
1311 * chain.
1312 */
1313 (*tif->tif_cleanup)(tif);
1314 if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
1315 _TIFFfree(tif->tif_rawdata);
1316 tif->tif_rawdata = NULL;
1317 tif->tif_rawcc = 0;
1318 }
1319 tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE);
1320 TIFFFreeDirectory(tif);
1321 TIFFDefaultDirectory(tif);
1322 tif->tif_diroff = 0; /* force link on next write */
1323 tif->tif_nextdiroff = 0; /* next write must be at end */
1324 tif->tif_curoff = 0;
1325 tif->tif_row = (uint32) -1;
1326 tif->tif_curstrip = (tstrip_t) -1;
1327 return (1);
1328 }
1329
1330 /* [BFC]
1331 *
1332 * Author: Bruce Cameron <cameron@petris.com>
1333 *
1334 * Set a table of tags that are to be replaced during directory process by the
1335 * 'IGNORE' state - or return TRUE/FALSE for the requested tag such that
1336 * 'ReadDirectory' can use the stored information.
1337 *
1338 * FIXME: this is never used properly. Should be removed in the future.
1339 */
1340 int
1341 TIFFReassignTagToIgnore (enum TIFFIgnoreSense task, int TIFFtagID)
1342 {
1343 static int TIFFignoretags [FIELD_LAST];
1344 static int tagcount = 0 ;
1345 int i; /* Loop index */
1346 int j; /* Loop index */
1347
1348 switch (task)
1349 {
1350 case TIS_STORE:
1351 if ( tagcount < (FIELD_LAST - 1) )
1352 {
1353 for ( j = 0 ; j < tagcount ; ++j )
1354 { /* Do not add duplicate tag */
1355 if ( TIFFignoretags [j] == TIFFtagID )
1356 return (TRUE) ;
1357 }
1358 TIFFignoretags [tagcount++] = TIFFtagID ;
1359 return (TRUE) ;
1360 }
1361 break ;
1362
1363 case TIS_EXTRACT:
1364 for ( i = 0 ; i < tagcount ; ++i )
1365 {
1366 if ( TIFFignoretags [i] == TIFFtagID )
1367 return (TRUE) ;
1368 }
1369 break;
1370
1371 case TIS_EMPTY:
1372 tagcount = 0 ; /* Clear the list */
1373 return (TRUE) ;
1374
1375 default:
1376 break;
1377 }
1378
1379 return (FALSE);
1380 }
1381
1382 /* vim: set ts=8 sts=8 sw=8 noet: */
1383 /*
1384 * Local Variables:
1385 * mode: c
1386 * c-basic-offset: 8
1387 * fill-column: 78
1388 * End:
1389 */
A free Windows-compatible Operating System