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