| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

tif_dirwrite.c
Go to the documentation of this file.
1 /* $Id: tif_dirwrite.c,v 1.37.2.7 2010-06-08 18:50:42 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 Write Support Routines.
31 */
32 #include "tiffiop.h"
33
34 #ifdef HAVE_IEEEFP
35 # define TIFFCvtNativeToIEEEFloat(tif, n, fp)
36 # define TIFFCvtNativeToIEEEDouble(tif, n, dp)
37 #else
38 extern void TIFFCvtNativeToIEEEFloat(TIFF*, uint32, float*);
39 extern void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*);
40 #endif
41
42 static int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*);
43 static void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32);
44 static void TIFFSetupShort(TIFF*, ttag_t, TIFFDirEntry*, uint16);
45 static int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*);
46 static int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*);
47 static int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*);
48 static int TIFFWriteShortTable(TIFF*, ttag_t, TIFFDirEntry*, uint32, uint16**);
49 static int TIFFWriteShortArray(TIFF*, TIFFDirEntry*, uint16*);
50 static int TIFFWriteLongArray(TIFF *, TIFFDirEntry*, uint32*);
51 static int TIFFWriteRationalArray(TIFF *, TIFFDirEntry*, float*);
52 static int TIFFWriteFloatArray(TIFF *, TIFFDirEntry*, float*);
53 static int TIFFWriteDoubleArray(TIFF *, TIFFDirEntry*, double*);
54 static int TIFFWriteByteArray(TIFF*, TIFFDirEntry*, char*);
55 static int TIFFWriteAnyArray(TIFF*,
56 TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*);
57 static int TIFFWriteTransferFunction(TIFF*, TIFFDirEntry*);
58 static int TIFFWriteInkNames(TIFF*, TIFFDirEntry*);
59 static int TIFFWriteData(TIFF*, TIFFDirEntry*, char*);
60 static int TIFFLinkDirectory(TIFF*);
61
62 #define WriteRationalPair(type, tag1, v1, tag2, v2) { \
63 TIFFWriteRational((tif), (type), (tag1), (dir), (v1)) \
64 TIFFWriteRational((tif), (type), (tag2), (dir)+1, (v2)) \
65 (dir)++; \
66 }
67 #define TIFFWriteRational(tif, type, tag, dir, v) \
68 (dir)->tdir_tag = (tag); \
69 (dir)->tdir_type = (type); \
70 (dir)->tdir_count = 1; \
71 if (!TIFFWriteRationalArray((tif), (dir), &(v))) \
72 goto bad;
73
74 /*
75 * Write the contents of the current directory
76 * to the specified file. This routine doesn't
77 * handle overwriting a directory with auxiliary
78 * storage that's been changed.
79 */
80 static int
81 _TIFFWriteDirectory(TIFF* tif, int done)
82 {
83 uint16 dircount;
84 toff_t diroff;
85 ttag_t tag;
86 uint32 nfields;
87 tsize_t dirsize;
88 char* data;
89 TIFFDirEntry* dir;
90 TIFFDirectory* td;
91 unsigned long b, fields[FIELD_SETLONGS];
92 int fi, nfi;
93
94 if (tif->tif_mode == O_RDONLY)
95 return (1);
96 /*
97 * Clear write state so that subsequent images with
98 * different characteristics get the right buffers
99 * setup for them.
100 */
101 if (done)
102 {
103 if (tif->tif_flags & TIFF_POSTENCODE) {
104 tif->tif_flags &= ~TIFF_POSTENCODE;
105 if (!(*tif->tif_postencode)(tif)) {
106 TIFFErrorExt(tif->tif_clientdata,
107 tif->tif_name,
108 "Error post-encoding before directory write");
109 return (0);
110 }
111 }
112 (*tif->tif_close)(tif); /* shutdown encoder */
113 /*
114 * Flush any data that might have been written
115 * by the compression close+cleanup routines.
116 */
117 if (tif->tif_rawcc > 0
118 && (tif->tif_flags & TIFF_BEENWRITING) != 0
119 && !TIFFFlushData1(tif)) {
120 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
121 "Error flushing data before directory write");
122 return (0);
123 }
124 if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
125 _TIFFfree(tif->tif_rawdata);
126 tif->tif_rawdata = NULL;
127 tif->tif_rawcc = 0;
128 tif->tif_rawdatasize = 0;
129 }
130 tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
131 }
132
133 td = &tif->tif_dir;
134 /*
135 * Size the directory so that we can calculate
136 * offsets for the data items that aren't kept
137 * in-place in each field.
138 */
139 nfields = 0;
140 for (b = 0; b <= FIELD_LAST; b++)
141 if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
142 nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
143 nfields += td->td_customValueCount;
144 dirsize = nfields * sizeof (TIFFDirEntry);
145 data = (char*) _TIFFmalloc(dirsize);
146 if (data == NULL) {
147 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
148 "Cannot write directory, out of space");
149 return (0);
150 }
151 /*
152 * Directory hasn't been placed yet, put
153 * it at the end of the file and link it
154 * into the existing directory structure.
155 */
156 if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif))
157 goto bad;
158 tif->tif_dataoff = (toff_t)(
159 tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
160 if (tif->tif_dataoff & 1)
161 tif->tif_dataoff++;
162 (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
163 tif->tif_curdir++;
164 dir = (TIFFDirEntry*) data;
165 /*
166 * Setup external form of directory
167 * entries and write data items.
168 */
169 _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
170 /*
171 * Write out ExtraSamples tag only if
172 * extra samples are present in the data.
173 */
174 if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) {
175 ResetFieldBit(fields, FIELD_EXTRASAMPLES);
176 nfields--;
177 dirsize -= sizeof (TIFFDirEntry);
178 } /*XXX*/
179 for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
180 const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
181
182 /*
183 * For custom fields, we test to see if the custom field
184 * is set or not. For normal fields, we just use the
185 * FieldSet test.
186 */
187 if( fip->field_bit == FIELD_CUSTOM )
188 {
189 int ci, is_set = FALSE;
190
191 for( ci = 0; ci < td->td_customValueCount; ci++ )
192 is_set |= (td->td_customValues[ci].info == fip);
193
194 if( !is_set )
195 continue;
196 }
197 else if (!FieldSet(fields, fip->field_bit))
198 continue;
199
200 /*
201 * Handle other fields.
202 */
203 switch (fip->field_bit)
204 {
205 case FIELD_STRIPOFFSETS:
206 /*
207 * We use one field bit for both strip and tile
208
209 * offsets, and so must be careful in selecting
210 * the appropriate field descriptor (so that tags
211 * are written in sorted order).
212 */
213 tag = isTiled(tif) ?
214 TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS;
215 if (tag != fip->field_tag)
216 continue;
217
218 dir->tdir_tag = (uint16) tag;
219 dir->tdir_type = (uint16) TIFF_LONG;
220 dir->tdir_count = (uint32) td->td_nstrips;
221 if (!TIFFWriteLongArray(tif, dir, td->td_stripoffset))
222 goto bad;
223 break;
224 case FIELD_STRIPBYTECOUNTS:
225 /*
226 * We use one field bit for both strip and tile
227 * byte counts, and so must be careful in selecting
228 * the appropriate field descriptor (so that tags
229 * are written in sorted order).
230 */
231 tag = isTiled(tif) ?
232 TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS;
233 if (tag != fip->field_tag)
234 continue;
235
236 dir->tdir_tag = (uint16) tag;
237 dir->tdir_type = (uint16) TIFF_LONG;
238 dir->tdir_count = (uint32) td->td_nstrips;
239 if (!TIFFWriteLongArray(tif, dir, td->td_stripbytecount))
240 goto bad;
241 break;
242 case FIELD_ROWSPERSTRIP:
243 TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP,
244 dir, td->td_rowsperstrip);
245 break;
246 case FIELD_COLORMAP:
247 if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir,
248 3, td->td_colormap))
249 goto bad;
250 break;
251 case FIELD_IMAGEDIMENSIONS:
252 TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH,
253 dir++, td->td_imagewidth);
254 TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH,
255 dir, td->td_imagelength);
256 break;
257 case FIELD_TILEDIMENSIONS:
258 TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH,
259 dir++, td->td_tilewidth);
260 TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH,
261 dir, td->td_tilelength);
262 break;
263 case FIELD_COMPRESSION:
264 TIFFSetupShort(tif, TIFFTAG_COMPRESSION,
265 dir, td->td_compression);
266 break;
267 case FIELD_PHOTOMETRIC:
268 TIFFSetupShort(tif, TIFFTAG_PHOTOMETRIC,
269 dir, td->td_photometric);
270 break;
271 case FIELD_POSITION:
272 WriteRationalPair(TIFF_RATIONAL,
273 TIFFTAG_XPOSITION, td->td_xposition,
274 TIFFTAG_YPOSITION, td->td_yposition);
275 break;
276 case FIELD_RESOLUTION:
277 WriteRationalPair(TIFF_RATIONAL,
278 TIFFTAG_XRESOLUTION, td->td_xresolution,
279 TIFFTAG_YRESOLUTION, td->td_yresolution);
280 break;
281 case FIELD_BITSPERSAMPLE:
282 case FIELD_MINSAMPLEVALUE:
283 case FIELD_MAXSAMPLEVALUE:
284 case FIELD_SAMPLEFORMAT:
285 if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir))
286 goto bad;
287 break;
288 case FIELD_SMINSAMPLEVALUE:
289 case FIELD_SMAXSAMPLEVALUE:
290 if (!TIFFWritePerSampleAnys(tif,
291 _TIFFSampleToTagType(tif), fip->field_tag, dir))
292 goto bad;
293 break;
294 case FIELD_PAGENUMBER:
295 case FIELD_HALFTONEHINTS:
296 case FIELD_YCBCRSUBSAMPLING:
297 if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
298 goto bad;
299 break;
300 case FIELD_INKNAMES:
301 if (!TIFFWriteInkNames(tif, dir))
302 goto bad;
303 break;
304 case FIELD_TRANSFERFUNCTION:
305 if (!TIFFWriteTransferFunction(tif, dir))
306 goto bad;
307 break;
308 case FIELD_SUBIFD:
309 /*
310 * XXX: Always write this field using LONG type
311 * for backward compatibility.
312 */
313 dir->tdir_tag = (uint16) fip->field_tag;
314 dir->tdir_type = (uint16) TIFF_LONG;
315 dir->tdir_count = (uint32) td->td_nsubifd;
316 if (!TIFFWriteLongArray(tif, dir, td->td_subifd))
317 goto bad;
318 /*
319 * Total hack: if this directory includes a SubIFD
320 * tag then force the next <n> directories to be
321 * written as ``sub directories'' of this one. This
322 * is used to write things like thumbnails and
323 * image masks that one wants to keep out of the
324 * normal directory linkage access mechanism.
325 */
326 if (dir->tdir_count > 0) {
327 tif->tif_flags |= TIFF_INSUBIFD;
328 tif->tif_nsubifd = (uint16) dir->tdir_count;
329 if (dir->tdir_count > 1)
330 tif->tif_subifdoff = dir->tdir_offset;
331 else
332 tif->tif_subifdoff = (uint32)(
333 tif->tif_diroff
334 + sizeof (uint16)
335 + ((char*)&dir->tdir_offset-data));
336 }
337 break;
338 default:
339 /* XXX: Should be fixed and removed. */
340 if (fip->field_tag == TIFFTAG_DOTRANGE) {
341 if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
342 goto bad;
343 }
344 else if (!TIFFWriteNormalTag(tif, dir, fip))
345 goto bad;
346 break;
347 }
348 dir++;
349
350 if( fip->field_bit != FIELD_CUSTOM )
351 ResetFieldBit(fields, fip->field_bit);
352 }
353
354 /*
355 * Write directory.
356 */
357 dircount = (uint16) nfields;
358 diroff = (uint32) tif->tif_nextdiroff;
359 if (tif->tif_flags & TIFF_SWAB) {
360 /*
361 * The file's byte order is opposite to the
362 * native machine architecture. We overwrite
363 * the directory information with impunity
364 * because it'll be released below after we
365 * write it to the file. Note that all the
366 * other tag construction routines assume that
367 * we do this byte-swapping; i.e. they only
368 * byte-swap indirect data.
369 */
370 for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
371 TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
372 TIFFSwabArrayOfLong(&dir->tdir_count, 2);
373 }
374 dircount = (uint16) nfields;
375 TIFFSwabShort(&dircount);
376 TIFFSwabLong(&diroff);
377 }
378 (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
379 if (!WriteOK(tif, &dircount, sizeof (dircount))) {
380 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
381 "Error writing directory count");
382 goto bad;
383 }
384 if (!WriteOK(tif, data, dirsize)) {
385 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
386 "Error writing directory contents");
387 goto bad;
388 }
389 if (!WriteOK(tif, &diroff, sizeof (uint32))) {
390 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
391 "Error writing directory link");
392 goto bad;
393 }
394 if (done) {
395 TIFFFreeDirectory(tif);
396 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
397 (*tif->tif_cleanup)(tif);
398
399 /*
400 * Reset directory-related state for subsequent
401 * directories.
402 */
403 TIFFCreateDirectory(tif);
404 }
405 _TIFFfree(data);
406 return (1);
407 bad:
408 _TIFFfree(data);
409 return (0);
410 }
411 #undef WriteRationalPair
412
413 int
414 TIFFWriteDirectory(TIFF* tif)
415 {
416 return _TIFFWriteDirectory(tif, TRUE);
417 }
418
419 /*
420 * Similar to TIFFWriteDirectory(), writes the directory out
421 * but leaves all data structures in memory so that it can be
422 * written again. This will make a partially written TIFF file
423 * readable before it is successfully completed/closed.
424 */
425 int
426 TIFFCheckpointDirectory(TIFF* tif)
427 {
428 int rc;
429 /* Setup the strips arrays, if they haven't already been. */
430 if (tif->tif_dir.td_stripoffset == NULL)
431 (void) TIFFSetupStrips(tif);
432 rc = _TIFFWriteDirectory(tif, FALSE);
433 (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));
434 return rc;
435 }
436
437 static int
438 _TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)
439 {
440 uint16 dircount;
441 uint32 nfields;
442 tsize_t dirsize;
443 char* data;
444 TIFFDirEntry* dir;
445 TIFFDirectory* td;
446 unsigned long b, fields[FIELD_SETLONGS];
447 int fi, nfi;
448
449 if (tif->tif_mode == O_RDONLY)
450 return (1);
451
452 td = &tif->tif_dir;
453 /*
454 * Size the directory so that we can calculate
455 * offsets for the data items that aren't kept
456 * in-place in each field.
457 */
458 nfields = 0;
459 for (b = 0; b <= FIELD_LAST; b++)
460 if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
461 nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
462 nfields += td->td_customValueCount;
463 dirsize = nfields * sizeof (TIFFDirEntry);
464 data = (char*) _TIFFmalloc(dirsize);
465 if (data == NULL) {
466 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
467 "Cannot write directory, out of space");
468 return (0);
469 }
470 /*
471 * Put the directory at the end of the file.
472 */
473 tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
474 tif->tif_dataoff = (toff_t)(
475 tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
476 if (tif->tif_dataoff & 1)
477 tif->tif_dataoff++;
478 (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
479 dir = (TIFFDirEntry*) data;
480 /*
481 * Setup external form of directory
482 * entries and write data items.
483 */
484 _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
485
486 for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
487 const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
488
489 /*
490 * For custom fields, we test to see if the custom field
491 * is set or not. For normal fields, we just use the
492 * FieldSet test.
493 */
494 if( fip->field_bit == FIELD_CUSTOM )
495 {
496 int ci, is_set = FALSE;
497
498 for( ci = 0; ci < td->td_customValueCount; ci++ )
499 is_set |= (td->td_customValues[ci].info == fip);
500
501 if( !is_set )
502 continue;
503 }
504 else if (!FieldSet(fields, fip->field_bit))
505 continue;
506
507 if( fip->field_bit != FIELD_CUSTOM )
508 ResetFieldBit(fields, fip->field_bit);
509 }
510
511 /*
512 * Write directory.
513 */
514 dircount = (uint16) nfields;
515 *pdiroff = (uint32) tif->tif_nextdiroff;
516 if (tif->tif_flags & TIFF_SWAB) {
517 /*
518 * The file's byte order is opposite to the
519 * native machine architecture. We overwrite
520 * the directory information with impunity
521 * because it'll be released below after we
522 * write it to the file. Note that all the
523 * other tag construction routines assume that
524 * we do this byte-swapping; i.e. they only
525 * byte-swap indirect data.
526 */
527 for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
528 TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
529 TIFFSwabArrayOfLong(&dir->tdir_count, 2);
530 }
531 dircount = (uint16) nfields;
532 TIFFSwabShort(&dircount);
533 TIFFSwabLong(pdiroff);
534 }
535 (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
536 if (!WriteOK(tif, &dircount, sizeof (dircount))) {
537 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
538 "Error writing directory count");
539 goto bad;
540 }
541 if (!WriteOK(tif, data, dirsize)) {
542 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
543 "Error writing directory contents");
544 goto bad;
545 }
546 if (!WriteOK(tif, pdiroff, sizeof (uint32))) {
547 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
548 "Error writing directory link");
549 goto bad;
550 }
551 _TIFFfree(data);
552 return (1);
553 bad:
554 _TIFFfree(data);
555 return (0);
556 }
557
558 int
559 TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)
560 {
561 return _TIFFWriteCustomDirectory(tif, pdiroff);
562 }
563
564 /*
565 * Process tags that are not special cased.
566 */
567 static int
568 TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)
569 {
570 uint16 wc = (uint16) fip->field_writecount;
571 uint32 wc2;
572
573 dir->tdir_tag = (uint16) fip->field_tag;
574 dir->tdir_type = (uint16) fip->field_type;
575 dir->tdir_count = wc;
576
577 switch (fip->field_type) {
578 case TIFF_SHORT:
579 case TIFF_SSHORT:
580 if (fip->field_passcount) {
581 uint16* wp;
582 if (wc == (uint16) TIFF_VARIABLE2) {
583 TIFFGetField(tif, fip->field_tag, &wc2, &wp);
584 dir->tdir_count = wc2;
585 } else { /* Assume TIFF_VARIABLE */
586 TIFFGetField(tif, fip->field_tag, &wc, &wp);
587 dir->tdir_count = wc;
588 }
589 if (!TIFFWriteShortArray(tif, dir, wp))
590 return 0;
591 } else {
592 if (wc == 1) {
593 uint16 sv;
594 TIFFGetField(tif, fip->field_tag, &sv);
595 dir->tdir_offset =
596 TIFFInsertData(tif, dir->tdir_type, sv);
597 } else {
598 uint16* wp;
599 TIFFGetField(tif, fip->field_tag, &wp);
600 if (!TIFFWriteShortArray(tif, dir, wp))
601 return 0;
602 }
603 }
604 break;
605 case TIFF_LONG:
606 case TIFF_SLONG:
607 case TIFF_IFD:
608 if (fip->field_passcount) {
609 uint32* lp;
610 if (wc == (uint16) TIFF_VARIABLE2) {
611 TIFFGetField(tif, fip->field_tag, &wc2, &lp);
612 dir->tdir_count = wc2;
613 } else { /* Assume TIFF_VARIABLE */
614 TIFFGetField(tif, fip->field_tag, &wc, &lp);
615 dir->tdir_count = wc;
616 }
617 if (!TIFFWriteLongArray(tif, dir, lp))
618 return 0;
619 } else {
620 if (wc == 1) {
621 /* XXX handle LONG->SHORT conversion */
622 TIFFGetField(tif, fip->field_tag,
623 &dir->tdir_offset);
624 } else {
625 uint32* lp;
626 TIFFGetField(tif, fip->field_tag, &lp);
627 if (!TIFFWriteLongArray(tif, dir, lp))
628 return 0;
629 }
630 }
631 break;
632 case TIFF_RATIONAL:
633 case TIFF_SRATIONAL:
634 if (fip->field_passcount) {
635 float* fp;
636 if (wc == (uint16) TIFF_VARIABLE2) {
637 TIFFGetField(tif, fip->field_tag, &wc2, &fp);
638 dir->tdir_count = wc2;
639 } else { /* Assume TIFF_VARIABLE */
640 TIFFGetField(tif, fip->field_tag, &wc, &fp);
641 dir->tdir_count = wc;
642 }
643 if (!TIFFWriteRationalArray(tif, dir, fp))
644 return 0;
645 } else {
646 if (wc == 1) {
647 float fv;
648 TIFFGetField(tif, fip->field_tag, &fv);
649 if (!TIFFWriteRationalArray(tif, dir, &fv))
650 return 0;
651 } else {
652 float* fp;
653 TIFFGetField(tif, fip->field_tag, &fp);
654 if (!TIFFWriteRationalArray(tif, dir, fp))
655 return 0;
656 }
657 }
658 break;
659 case TIFF_FLOAT:
660 if (fip->field_passcount) {
661 float* fp;
662 if (wc == (uint16) TIFF_VARIABLE2) {
663 TIFFGetField(tif, fip->field_tag, &wc2, &fp);
664 dir->tdir_count = wc2;
665 } else { /* Assume TIFF_VARIABLE */
666 TIFFGetField(tif, fip->field_tag, &wc, &fp);
667 dir->tdir_count = wc;
668 }
669 if (!TIFFWriteFloatArray(tif, dir, fp))
670 return 0;
671 } else {
672 if (wc == 1) {
673 float fv;
674 TIFFGetField(tif, fip->field_tag, &fv);
675 if (!TIFFWriteFloatArray(tif, dir, &fv))
676 return 0;
677 } else {
678 float* fp;
679 TIFFGetField(tif, fip->field_tag, &fp);
680 if (!TIFFWriteFloatArray(tif, dir, fp))
681 return 0;
682 }
683 }
684 break;
685 case TIFF_DOUBLE:
686 if (fip->field_passcount) {
687 double* dp;
688 if (wc == (uint16) TIFF_VARIABLE2) {
689 TIFFGetField(tif, fip->field_tag, &wc2, &dp);
690 dir->tdir_count = wc2;
691 } else { /* Assume TIFF_VARIABLE */
692 TIFFGetField(tif, fip->field_tag, &wc, &dp);
693 dir->tdir_count = wc;
694 }
695 if (!TIFFWriteDoubleArray(tif, dir, dp))
696 return 0;
697 } else {
698 if (wc == 1) {
699 double dv;
700 TIFFGetField(tif, fip->field_tag, &dv);
701 if (!TIFFWriteDoubleArray(tif, dir, &dv))
702 return 0;
703 } else {
704 double* dp;
705 TIFFGetField(tif, fip->field_tag, &dp);
706 if (!TIFFWriteDoubleArray(tif, dir, dp))
707 return 0;
708 }
709 }
710 break;
711 case TIFF_ASCII:
712 {
713 char* cp;
714 if (fip->field_passcount)
715 {
716 if( wc == (uint16) TIFF_VARIABLE2 )
717 TIFFGetField(tif, fip->field_tag, &wc2, &cp);
718 else
719 TIFFGetField(tif, fip->field_tag, &wc, &cp);
720 }
721 else
722 TIFFGetField(tif, fip->field_tag, &cp);
723
724 dir->tdir_count = (uint32) (strlen(cp) + 1);
725 if (!TIFFWriteByteArray(tif, dir, cp))
726 return (0);
727 }
728 break;
729
730 case TIFF_BYTE:
731 case TIFF_SBYTE:
732 if (fip->field_passcount) {
733 char* cp;
734 if (wc == (uint16) TIFF_VARIABLE2) {
735 TIFFGetField(tif, fip->field_tag, &wc2, &cp);
736 dir->tdir_count = wc2;
737 } else { /* Assume TIFF_VARIABLE */
738 TIFFGetField(tif, fip->field_tag, &wc, &cp);
739 dir->tdir_count = wc;
740 }
741 if (!TIFFWriteByteArray(tif, dir, cp))
742 return 0;
743 } else {
744 if (wc == 1) {
745 char cv;
746 TIFFGetField(tif, fip->field_tag, &cv);
747 if (!TIFFWriteByteArray(tif, dir, &cv))
748 return 0;
749 } else {
750 char* cp;
751 TIFFGetField(tif, fip->field_tag, &cp);
752 if (!TIFFWriteByteArray(tif, dir, cp))
753 return 0;
754 }
755 }
756 break;
757
758 case TIFF_UNDEFINED:
759 { char* cp;
760 if (wc == (unsigned short) TIFF_VARIABLE) {
761 TIFFGetField(tif, fip->field_tag, &wc, &cp);
762 dir->tdir_count = wc;
763 } else if (wc == (unsigned short) TIFF_VARIABLE2) {
764 TIFFGetField(tif, fip->field_tag, &wc2, &cp);
765 dir->tdir_count = wc2;
766 } else
767 TIFFGetField(tif, fip->field_tag, &cp);
768 if (!TIFFWriteByteArray(tif, dir, cp))
769 return (0);
770 }
771 break;
772
773 case TIFF_NOTYPE:
774 break;
775 }
776 return (1);
777 }
778
779 /*
780 * Setup a directory entry with either a SHORT
781 * or LONG type according to the value.
782 */
783 static void
784 TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v)
785 {
786 dir->tdir_tag = (uint16) tag;
787 dir->tdir_count = 1;
788 if (v > 0xffffL) {
789 dir->tdir_type = (short) TIFF_LONG;
790 dir->tdir_offset = v;
791 } else {
792 dir->tdir_type = (short) TIFF_SHORT;
793 dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);
794 }
795 }
796
797 /*
798 * Setup a SHORT directory entry
799 */
800 static void
801 TIFFSetupShort(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint16 v)
802 {
803 dir->tdir_tag = (uint16) tag;
804 dir->tdir_count = 1;
805 dir->tdir_type = (short) TIFF_SHORT;
806 dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);
807 }
808 #undef MakeShortDirent
809
810 #define NITEMS(x) (sizeof (x) / sizeof (x[0]))
811 /*
812 * Setup a directory entry that references a
813 * samples/pixel array of SHORT values and
814 * (potentially) write the associated indirect
815 * values.
816 */
817 static int
818 TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
819 {
820 uint16 buf[10], v;
821 uint16* w = buf;
822 uint16 i, samples = tif->tif_dir.td_samplesperpixel;
823 int status;
824
825 if (samples > NITEMS(buf)) {
826 w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
827 if (w == NULL) {
828 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
829 "No space to write per-sample shorts");
830 return (0);
831 }
832 }
833 TIFFGetField(tif, tag, &v);
834 for (i = 0; i < samples; i++)
835 w[i] = v;
836
837 dir->tdir_tag = (uint16) tag;
838 dir->tdir_type = (uint16) TIFF_SHORT;
839 dir->tdir_count = samples;
840 status = TIFFWriteShortArray(tif, dir, w);
841 if (w != buf)
842 _TIFFfree((char*) w);
843 return (status);
844 }
845
846 /*
847 * Setup a directory entry that references a samples/pixel array of ``type''
848 * values and (potentially) write the associated indirect values. The source
849 * data from TIFFGetField() for the specified tag must be returned as double.
850 */
851 static int
852 TIFFWritePerSampleAnys(TIFF* tif,
853 TIFFDataType type, ttag_t tag, TIFFDirEntry* dir)
854 {
855 double buf[10], v;
856 double* w = buf;
857 uint16 i, samples = tif->tif_dir.td_samplesperpixel;
858 int status;
859
860 if (samples > NITEMS(buf)) {
861 w = (double*) _TIFFmalloc(samples * sizeof (double));
862 if (w == NULL) {
863 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
864 "No space to write per-sample values");
865 return (0);
866 }
867 }
868 TIFFGetField(tif, tag, &v);
869 for (i = 0; i < samples; i++)
870 w[i] = v;
871 status = TIFFWriteAnyArray(tif, type, tag, dir, samples, w);
872 if (w != buf)
873 _TIFFfree(w);
874 return (status);
875 }
876 #undef NITEMS
877
878 /*
879 * Setup a pair of shorts that are returned by
880 * value, rather than as a reference to an array.
881 */
882 static int
883 TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
884 {
885 uint16 v[2];
886
887 TIFFGetField(tif, tag, &v[0], &v[1]);
888
889 dir->tdir_tag = (uint16) tag;
890 dir->tdir_type = (uint16) TIFF_SHORT;
891 dir->tdir_count = 2;
892 return (TIFFWriteShortArray(tif, dir, v));
893 }
894
895 /*
896 * Setup a directory entry for an NxM table of shorts,
897 * where M is known to be 2**bitspersample, and write
898 * the associated indirect data.
899 */
900 static int
901 TIFFWriteShortTable(TIFF* tif,
902 ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16** table)
903 {
904 uint32 i, off;
905
906 dir->tdir_tag = (uint16) tag;
907 dir->tdir_type = (short) TIFF_SHORT;
908 /* XXX -- yech, fool TIFFWriteData */
909 dir->tdir_count = (uint32) (1L<<tif->tif_dir.td_bitspersample);
910 off = tif->tif_dataoff;
911 for (i = 0; i < n; i++)
912 if (!TIFFWriteData(tif, dir, (char *)table[i]))
913 return (0);
914 dir->tdir_count *= n;
915 dir->tdir_offset = off;
916 return (1);
917 }
918
919 /*
920 * Write/copy data associated with an ASCII or opaque tag value.
921 */
922 static int
923 TIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp)
924 {
925 if (dir->tdir_count <= 4) {
926 if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
927 dir->tdir_offset = (uint32)cp[0] << 24;
928 if (dir->tdir_count >= 2)
929 dir->tdir_offset |= (uint32)cp[1] << 16;
930 if (dir->tdir_count >= 3)
931 dir->tdir_offset |= (uint32)cp[2] << 8;
932 if (dir->tdir_count == 4)
933 dir->tdir_offset |= cp[3];
934 } else {
935 dir->tdir_offset = cp[0];
936 if (dir->tdir_count >= 2)
937 dir->tdir_offset |= (uint32) cp[1] << 8;
938 if (dir->tdir_count >= 3)
939 dir->tdir_offset |= (uint32) cp[2] << 16;
940 if (dir->tdir_count == 4)
941 dir->tdir_offset |= (uint32) cp[3] << 24;
942 }
943 return 1;
944 } else
945 return TIFFWriteData(tif, dir, cp);
946 }
947
948 /*
949 * Setup a directory entry of an array of SHORT
950 * or SSHORT and write the associated indirect values.
951 */
952 static int
953 TIFFWriteShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
954 {
955 if (dir->tdir_count <= 2) {
956 if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
957 dir->tdir_offset = (uint32) v[0] << 16;
958 if (dir->tdir_count == 2)
959 dir->tdir_offset |= v[1] & 0xffff;
960 } else {
961 dir->tdir_offset = v[0] & 0xffff;
962 if (dir->tdir_count == 2)
963 dir->tdir_offset |= (uint32) v[1] << 16;
964 }
965 return (1);
966 } else
967 return (TIFFWriteData(tif, dir, (char*) v));
968 }
969
970 /*
971 * Setup a directory entry of an array of LONG
972 * or SLONG and write the associated indirect values.
973 */
974 static int
975 TIFFWriteLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
976 {
977 if (dir->tdir_count == 1) {
978 dir->tdir_offset = v[0];
979 return (1);
980 } else
981 return (TIFFWriteData(tif, dir, (char*) v));
982 }
983
984 /*
985 * Setup a directory entry of an array of RATIONAL
986 * or SRATIONAL and write the associated indirect values.
987 */
988 static int
989 TIFFWriteRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
990 {
991 uint32 i;
992 uint32* t;
993 int status;
994
995 t = (uint32*) _TIFFmalloc(2 * dir->tdir_count * sizeof (uint32));
996 if (t == NULL) {
997 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
998 "No space to write RATIONAL array");
999 return (0);
1000 }
1001 for (i = 0; i < dir->tdir_count; i++) {
1002 float fv = v[i];
1003 int sign = 1;
1004 uint32 den;
1005
1006 if (fv < 0) {
1007 if (dir->tdir_type == TIFF_RATIONAL) {
1008 TIFFWarningExt(tif->tif_clientdata,
1009 tif->tif_name,
1010 "\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL",
1011 _TIFFFieldWithTag(tif,dir->tdir_tag)->field_name,
1012 fv);
1013 fv = 0;
1014 } else
1015 fv = -fv, sign = -1;
1016 }
1017 den = 1L;
1018 if (fv > 0) {
1019 while (fv < 1L<<(31-3) && den < 1L<<(31-3))
1020 fv *= 1<<3, den *= 1L<<3;
1021 }
1022 t[2*i+0] = (uint32) (sign * (fv + 0.5));
1023 t[2*i+1] = den;
1024 }
1025 status = TIFFWriteData(tif, dir, (char *)t);
1026 _TIFFfree((char*) t);
1027 return (status);
1028 }
1029
1030 static int
1031 TIFFWriteFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
1032 {
1033 TIFFCvtNativeToIEEEFloat(tif, dir->tdir_count, v);
1034 if (dir->tdir_count == 1) {
1035 dir->tdir_offset = *(uint32*) &v[0];
1036 return (1);
1037 } else
1038 return (TIFFWriteData(tif, dir, (char*) v));
1039 }
1040
1041 static int
1042 TIFFWriteDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)
1043 {
1044 TIFFCvtNativeToIEEEDouble(tif, dir->tdir_count, v);
1045 return (TIFFWriteData(tif, dir, (char*) v));
1046 }
1047
1048 /*
1049 * Write an array of ``type'' values for a specified tag (i.e. this is a tag
1050 * which is allowed to have different types, e.g. SMaxSampleType).
1051 * Internally the data values are represented as double since a double can
1052 * hold any of the TIFF tag types (yes, this should really be an abstract
1053 * type tany_t for portability). The data is converted into the specified
1054 * type in a temporary buffer and then handed off to the appropriate array
1055 * writer.
1056 */
1057 static int
1058 TIFFWriteAnyArray(TIFF* tif,
1059 TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v)
1060 {
1061 char buf[10 * sizeof(double)];
1062 char* w = buf;
1063 int i, status = 0;
1064
1065 if (n * TIFFDataWidth(type) > sizeof buf) {
1066 w = (char*) _TIFFmalloc(n * TIFFDataWidth(type));
1067 if (w == NULL) {
1068 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
1069 "No space to write array");
1070 return (0);
1071 }
1072 }
1073
1074 dir->tdir_tag = (uint16) tag;
1075 dir->tdir_type = (uint16) type;
1076 dir->tdir_count = n;
1077
1078 switch (type) {
1079 case TIFF_BYTE:
1080 {
1081 uint8* bp = (uint8*) w;
1082 for (i = 0; i < (int) n; i++)
1083 bp[i] = (uint8) v[i];
1084 if (!TIFFWriteByteArray(tif, dir, (char*) bp))
1085 goto out;
1086 }
1087 break;
1088 case TIFF_SBYTE:
1089 {
1090 int8* bp = (int8*) w;
1091 for (i = 0; i < (int) n; i++)
1092 bp[i] = (int8) v[i];
1093 if (!TIFFWriteByteArray(tif, dir, (char*) bp))
1094 goto out;
1095 }
1096 break;
1097 case TIFF_SHORT:
1098 {
1099 uint16* bp = (uint16*) w;
1100 for (i = 0; i < (int) n; i++)
1101 bp[i] = (uint16) v[i];
1102 if (!TIFFWriteShortArray(tif, dir, (uint16*)bp))
1103 goto out;
1104 }
1105 break;
1106 case TIFF_SSHORT:
1107 {
1108 int16* bp = (int16*) w;
1109 for (i = 0; i < (int) n; i++)
1110 bp[i] = (int16) v[i];
1111 if (!TIFFWriteShortArray(tif, dir, (uint16*)bp))
1112 goto out;
1113 }
1114 break;
1115 case TIFF_LONG:
1116 {
1117 uint32* bp = (uint32*) w;
1118 for (i = 0; i < (int) n; i++)
1119 bp[i] = (uint32) v[i];
1120 if (!TIFFWriteLongArray(tif, dir, bp))
1121 goto out;
1122 }
1123 break;
1124 case TIFF_SLONG:
1125 {
1126 int32* bp = (int32*) w;
1127 for (i = 0; i < (int) n; i++)
1128 bp[i] = (int32) v[i];
1129 if (!TIFFWriteLongArray(tif, dir, (uint32*) bp))
1130 goto out;
1131 }
1132 break;
1133 case TIFF_FLOAT:
1134 {
1135 float* bp = (float*) w;
1136 for (i = 0; i < (int) n; i++)
1137 bp[i] = (float) v[i];
1138 if (!TIFFWriteFloatArray(tif, dir, bp))
1139 goto out;
1140 }
1141 break;
1142 case TIFF_DOUBLE:
1143 {
1144 if( !TIFFWriteDoubleArray(tif, dir, v))
1145 goto out;
1146 }
1147 break;
1148 default:
1149 /* TIFF_NOTYPE */
1150 /* TIFF_ASCII */
1151 /* TIFF_UNDEFINED */
1152 /* TIFF_RATIONAL */
1153 /* TIFF_SRATIONAL */
1154 goto out;
1155 }
1156 status = 1;
1157 out:
1158 if (w != buf)
1159 _TIFFfree(w);
1160 return (status);
1161 }
1162
1163 static int
1164 TIFFWriteTransferFunction(TIFF* tif, TIFFDirEntry* dir)
1165 {
1166 TIFFDirectory* td = &tif->tif_dir;
1167 tsize_t n = (1L<<td->td_bitspersample) * sizeof (uint16);
1168 uint16** tf = td->td_transferfunction;
1169 int ncols;
1170
1171 /*
1172 * Check if the table can be written as a single column,
1173 * or if it must be written as 3 columns. Note that we
1174 * write a 3-column tag if there are 2 samples/pixel and
1175 * a single column of data won't suffice--hmm.
1176 */
1177 switch (td->td_samplesperpixel - td->td_extrasamples) {
1178 default: if (_TIFFmemcmp(tf[0], tf[2], n)) { ncols = 3; break; }
1179 case 2: if (_TIFFmemcmp(tf[0], tf[1], n)) { ncols = 3; break; }
1180 case 1: case 0: ncols = 1;
1181 }
1182 return (TIFFWriteShortTable(tif,
1183 TIFFTAG_TRANSFERFUNCTION, dir, ncols, tf));
1184 }
1185
1186 static int
1187 TIFFWriteInkNames(TIFF* tif, TIFFDirEntry* dir)
1188 {
1189 TIFFDirectory* td = &tif->tif_dir;
1190
1191 dir->tdir_tag = TIFFTAG_INKNAMES;
1192 dir->tdir_type = (short) TIFF_ASCII;
1193 dir->tdir_count = td->td_inknameslen;
1194 return (TIFFWriteByteArray(tif, dir, td->td_inknames));
1195 }
1196
1197 /*
1198 * Write a contiguous directory item.
1199 */
1200 static int
1201 TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp)
1202 {
1203 tsize_t cc;
1204
1205 if (tif->tif_flags & TIFF_SWAB) {
1206 switch (dir->tdir_type) {
1207 case TIFF_SHORT:
1208 case TIFF_SSHORT:
1209 TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
1210 break;
1211 case TIFF_LONG:
1212 case TIFF_SLONG:
1213 case TIFF_FLOAT:
1214 TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
1215 break;
1216 case TIFF_RATIONAL:
1217 case TIFF_SRATIONAL:
1218 TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
1219 break;
1220 case TIFF_DOUBLE:
1221 TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
1222 break;
1223 }
1224 }
1225 dir->tdir_offset = tif->tif_dataoff;
1226 cc = dir->tdir_count * TIFFDataWidth((TIFFDataType) dir->tdir_type);
1227 if (SeekOK(tif, dir->tdir_offset) &&
1228 WriteOK(tif, cp, cc)) {
1229 tif->tif_dataoff += (cc + 1) & ~1;
1230 return (1);
1231 }
1232 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
1233 "Error writing data for field \"%s\"",
1234 _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
1235 return (0);
1236 }
1237
1238 /*
1239 * Similar to TIFFWriteDirectory(), but if the directory has already
1240 * been written once, it is relocated to the end of the file, in case it
1241 * has changed in size. Note that this will result in the loss of the
1242 * previously used directory space.
1243 */
1244
1245 int
1246 TIFFRewriteDirectory( TIFF *tif )
1247 {
1248 static const char module[] = "TIFFRewriteDirectory";
1249
1250 /* We don't need to do anything special if it hasn't been written. */
1251 if( tif->tif_diroff == 0 )
1252 return TIFFWriteDirectory( tif );
1253
1254 /*
1255 ** Find and zero the pointer to this directory, so that TIFFLinkDirectory
1256 ** will cause it to be added after this directories current pre-link.
1257 */
1258
1259 /* Is it the first directory in the file? */
1260 if (tif->tif_header.tiff_diroff == tif->tif_diroff)
1261 {
1262 tif->tif_header.tiff_diroff = 0;
1263 tif->tif_diroff = 0;
1264
1265 TIFFSeekFile(tif, (toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE),
1266 SEEK_SET);
1267 if (!WriteOK(tif, &(tif->tif_header.tiff_diroff),
1268 sizeof (tif->tif_diroff)))
1269 {
1270 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
1271 "Error updating TIFF header");
1272 return (0);
1273 }
1274 }
1275 else
1276 {
1277 toff_t nextdir, off;
1278
1279 nextdir = tif->tif_header.tiff_diroff;
1280 do {
1281 uint16 dircount;
1282
1283 if (!SeekOK(tif, nextdir) ||
1284 !ReadOK(tif, &dircount, sizeof (dircount))) {
1285 TIFFErrorExt(tif->tif_clientdata, module,
1286 "Error fetching directory count");
1287 return (0);
1288 }
1289 if (tif->tif_flags & TIFF_SWAB)
1290 TIFFSwabShort(&dircount);
1291 (void) TIFFSeekFile(tif,
1292 dircount * sizeof (TIFFDirEntry), SEEK_CUR);
1293 if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
1294 TIFFErrorExt(tif->tif_clientdata, module,
1295 "Error fetching directory link");
1296 return (0);
1297 }
1298 if (tif->tif_flags & TIFF_SWAB)
1299 TIFFSwabLong(&nextdir);
1300 } while (nextdir != tif->tif_diroff && nextdir != 0);
1301 off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
1302 (void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
1303 tif->tif_diroff = 0;
1304 if (!WriteOK(tif, &(tif->tif_diroff), sizeof (nextdir))) {
1305 TIFFErrorExt(tif->tif_clientdata, module,
1306 "Error writing directory link");
1307 return (0);
1308 }
1309 }
1310
1311 /*
1312 ** Now use TIFFWriteDirectory() normally.
1313 */
1314
1315 return TIFFWriteDirectory( tif );
1316 }
1317
1318
1319 /*
1320 * Link the current directory into the directory chain for the file.
1321 */
1322 static int
1323 TIFFLinkDirectory(TIFF* tif)
1324 {
1325 static const char module[] = "TIFFLinkDirectory";
1326 toff_t nextdir;
1327 toff_t diroff, off;
1328
1329 tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
1330 diroff = tif->tif_diroff;
1331 if (tif->tif_flags & TIFF_SWAB)
1332 TIFFSwabLong(&diroff);
1333
1334 /*
1335 * Handle SubIFDs
1336 */
1337 if (tif->tif_flags & TIFF_INSUBIFD) {
1338 (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
1339 if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1340 TIFFErrorExt(tif->tif_clientdata, module,
1341 "%s: Error writing SubIFD directory link",
1342 tif->tif_name);
1343 return (0);
1344 }
1345 /*
1346 * Advance to the next SubIFD or, if this is
1347 * the last one configured, revert back to the
1348 * normal directory linkage.
1349 */
1350 if (--tif->tif_nsubifd)
1351 tif->tif_subifdoff += sizeof (diroff);
1352 else
1353 tif->tif_flags &= ~TIFF_INSUBIFD;
1354 return (1);
1355 }
1356
1357 if (tif->tif_header.tiff_diroff == 0) {
1358 /*
1359 * First directory, overwrite offset in header.
1360 */
1361 tif->tif_header.tiff_diroff = tif->tif_diroff;
1362 (void) TIFFSeekFile(tif,
1363 (toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE),
1364 SEEK_SET);
1365 if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1366 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
1367 "Error writing TIFF header");
1368 return (0);
1369 }
1370 return (1);
1371 }
1372 /*
1373 * Not the first directory, search to the last and append.
1374 */
1375 nextdir = tif->tif_header.tiff_diroff;
1376 do {
1377 uint16 dircount;
1378
1379 if (!SeekOK(tif, nextdir) ||
1380 !ReadOK(tif, &dircount, sizeof (dircount))) {
1381 TIFFErrorExt(tif->tif_clientdata, module,
1382 "Error fetching directory count");
1383 return (0);
1384 }
1385 if (tif->tif_flags & TIFF_SWAB)
1386 TIFFSwabShort(&dircount);
1387 (void) TIFFSeekFile(tif,
1388 dircount * sizeof (TIFFDirEntry), SEEK_CUR);
1389 if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
1390 TIFFErrorExt(tif->tif_clientdata, module,
1391 "Error fetching directory link");
1392 return (0);
1393 }
1394 if (tif->tif_flags & TIFF_SWAB)
1395 TIFFSwabLong(&nextdir);
1396 } while (nextdir != 0);
1397 off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
1398 (void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
1399 if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1400 TIFFErrorExt(tif->tif_clientdata, module,
1401 "Error writing directory link");
1402 return (0);
1403 }
1404 return (1);
1405 }
1406
1407 /* vim: set ts=8 sts=8 sw=8 noet: */
1408 /*
1409 * Local Variables:
1410 * mode: c
1411 * c-basic-offset: 8
1412 * fill-column: 78
1413 * End:
1414 */
TRUE
#define TRUE
Definition: twiddle.c:33
tsize_t
int32 tsize_t
Definition: tiffio.h:67
ttag_t
uint32 ttag_t
Definition: tiffio.h:61
TIFF_BEENWRITING
#define TIFF_BEENWRITING
Definition: tiffiop.h:112
TIFF_UNDEFINED
Definition: tiff.h:145
TIFFDirectory::td_imagewidth
uint32 td_imagewidth
Definition: tif_dir.h:41
TIFFRewriteDirectory
int TIFFRewriteDirectory(TIFF *tif)
Definition: tif_dirwrite.c:1246
TIFF_VARIABLE
#define TIFF_VARIABLE
Definition: tiffio.h:297
FIELD_CUSTOM
#define FIELD_CUSTOM
Definition: tiffio.h:301
NITEMS
#define NITEMS(x)
Definition: tif_dirwrite.c:810
FIELD_MINSAMPLEVALUE
#define FIELD_MINSAMPLEVALUE
Definition: tif_dir.h:120
FIELD_RESOLUTION
#define FIELD_RESOLUTION
Definition: tif_dir.h:107
TIFFWarningExt
void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_warning.c:63
TIFFTAG_ROWSPERSTRIP
#define TIFFTAG_ROWSPERSTRIP
Definition: tiff.h:236
TIFFDirectory::td_bitspersample
uint16 td_bitspersample
Definition: tif_dir.h:44
TIFFSetupStrips
int TIFFSetupStrips(TIFF *tif)
Definition: tif_write.c:443
TIFFDirectory::td_nsubifd
uint16 td_nsubifd
Definition: tif_dir.h:72
FIELD_STRIPOFFSETS
#define FIELD_STRIPOFFSETS
Definition: tif_dir.h:126
TIFFTAG_STRIPBYTECOUNTS
#define TIFFTAG_STRIPBYTECOUNTS
Definition: tiff.h:237
SEEK_CUR
#define SEEK_CUR
Definition: zconf.h:389
TIFFTAG_COLORMAP
#define TIFFTAG_COLORMAP
Definition: tiff.h:287
TIFF_LONG
Definition: tiff.h:142
TIFFDirectory::td_xresolution
float td_xresolution
Definition: tif_dir.h:55
TIFFInsertData
#define TIFFInsertData(tif, type, v)
Definition: tif_dir.h:164
WriteOK
#define WriteOK(tif, buf, size)
Definition: tiffiop.h:234
FIELD_IMAGEDIMENSIONS
#define FIELD_IMAGEDIMENSIONS
Definition: tif_dir.h:105
TIFF_BYTE
Definition: tiff.h:139
TIFFSeekFile
#define TIFFSeekFile(tif, off, whence)
Definition: tiffiop.h:211
TIFFTAG_IMAGEWIDTH
#define TIFFTAG_IMAGEWIDTH
Definition: tiff.h:165
TIFFTAG_YRESOLUTION
#define TIFFTAG_YRESOLUTION
Definition: tiff.h:241
TIFFTAG_INKNAMES
#define TIFFTAG_INKNAMES
Definition: tiff.h:303
TIFF_ASCII
Definition: tiff.h:140
FIELD_LAST
#define FIELD_LAST
Definition: tif_dir.h:158
uint8
unsigned char uint8
Definition: tiff.h:67
TIFFDirectory::td_transferfunction
uint16 * td_transferfunction[3]
Definition: tif_dir.h:79
SEEK_END
#define SEEK_END
Definition: zconf.h:390
int8
signed char int8
Definition: tiff.h:65
FIELD_HALFTONEHINTS
#define FIELD_HALFTONEHINTS
Definition: tif_dir.h:134
tiff::tif_close
TIFFVoidMethod tif_close
Definition: tiffiop.h:165
TIFFDirectory::td_customValues
TIFFTagValue * td_customValues
Definition: tif_dir.h:85
TIFFTAG_DOTRANGE
#define TIFFTAG_DOTRANGE
Definition: tiff.h:305
tiff::tif_rawdata
tidata_t tif_rawdata
Definition: tiffiop.h:174
TIFFTAG_STRIPOFFSETS
#define TIFFTAG_STRIPOFFSETS
Definition: tiff.h:225
tiff::tif_clientdata
thandle_t tif_clientdata
Definition: tiffiop.h:185
TIFFSwabArrayOfShort
void TIFFSwabArrayOfShort(uint16 *wp, register unsigned long n)
Definition: tif_swab.c:59
TIFFTAG_YPOSITION
#define TIFFTAG_YPOSITION
Definition: tiff.h:247
tiffiop.h
TIFF_SRATIONAL
Definition: tiff.h:148
TIFFDirectory::td_xposition
float td_xposition
Definition: tif_dir.h:58
tiff::tif_name
char * tif_name
Definition: tiffiop.h:103
TIFF_DIRTYDIRECT
#define TIFF_DIRTYDIRECT
Definition: tiffiop.h:109
TIFFDirectory::td_inknameslen
int td_inknameslen
Definition: tif_dir.h:81
tiff
Definition: tiffiop.h:102
FIELD_YCBCRSUBSAMPLING
#define FIELD_YCBCRSUBSAMPLING
Definition: tif_dir.h:135
FIELD_SETLONGS
#define FIELD_SETLONGS
Definition: tif_dir.h:37
FIELD_SMAXSAMPLEVALUE
#define FIELD_SMAXSAMPLEVALUE
Definition: tif_dir.h:131
TIFFTAG_TILEBYTECOUNTS
#define TIFFTAG_TILEBYTECOUNTS
Definition: tiff.h:292
TIFFDirEntry
Definition: tiff.h:116
FIELD_SUBIFD
#define FIELD_SUBIFD
Definition: tif_dir.h:140
TIFFDirectory::td_extrasamples
uint16 td_extrasamples
Definition: tif_dir.h:62
FIELD_TRANSFERFUNCTION
#define FIELD_TRANSFERFUNCTION
Definition: tif_dir.h:138
TIFFDirectory::td_fieldsset
unsigned long td_fieldsset[FIELD_SETLONGS]
Definition: tif_dir.h:39
b
long b
Definition: jpegint.h:371
_TIFFmemcpy
void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
Definition: tif_acorn.c:485
FIELD_MAXSAMPLEVALUE
#define FIELD_MAXSAMPLEVALUE
Definition: tif_dir.h:121
FIELD_BITSPERSAMPLE
#define FIELD_BITSPERSAMPLE
Definition: tif_dir.h:112
_TIFFmemcmp
int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
Definition: tif_acorn.c:491
TIFFDirectory::td_customValueCount
int td_customValueCount
Definition: tif_dir.h:84
TIFF_SWAB
#define TIFF_SWAB
Definition: tiffiop.h:113
_TIFFTagValue::info
const TIFFFieldInfo * info
Definition: tiffio.h:315
TIFFTAG_TILEWIDTH
#define TIFFTAG_TILEWIDTH
Definition: tiff.h:289
tiff::tif_nsubifd
uint16 tif_nsubifd
Definition: tiffiop.h:145
FIELD_STRIPBYTECOUNTS
#define FIELD_STRIPBYTECOUNTS
Definition: tif_dir.h:125
TIFF_NOTYPE
Definition: tiff.h:138
_TIFFSampleToTagType
TIFFDataType _TIFFSampleToTagType(TIFF *)
Definition: tif_dirinfo.c:726
TIFFTAG_TILELENGTH
#define TIFFTAG_TILELENGTH
Definition: tiff.h:290
tiff::tif_mode
int tif_mode
Definition: tiffiop.h:105
TIFFFieldInfo::field_passcount
unsigned char field_passcount
Definition: tiffio.h:310
TIFFWriteDirectory
int TIFFWriteDirectory(TIFF *tif)
Definition: tif_dirwrite.c:414
tiff::tif_flags
uint32 tif_flags
Definition: tiffiop.h:106
TIFFDirectory::td_tilewidth
uint32 td_tilewidth
Definition: tif_dir.h:42
TIFFTAG_IMAGELENGTH
#define TIFFTAG_IMAGELENGTH
Definition: tiff.h:166
TIFF_SSHORT
Definition: tiff.h:146
TIFFTAG_TILEOFFSETS
#define TIFFTAG_TILEOFFSETS
Definition: tiff.h:291
tiff::tif_nfields
size_t tif_nfields
Definition: tiffiop.h:195
TIFF_MAGIC_SIZE
#define TIFF_MAGIC_SIZE
Definition: tiff.h:97
TIFFDirectory::td_tilelength
uint32 td_tilelength
Definition: tif_dir.h:42
FALSE
#define FALSE
Definition: twiddle.c:37
TIFF_POSTENCODE
#define TIFF_POSTENCODE
Definition: tiffiop.h:118
TIFFFreeDirectory
void TIFFFreeDirectory(TIFF *tif)
Definition: tif_dir.c:987
TIFF_VERSION_SIZE
#define TIFF_VERSION_SIZE
Definition: tiff.h:99
SEEK_SET
#define SEEK_SET
Definition: jmemansi.c:26
TIFFDirectory::td_stripoffset
toff_t * td_stripoffset
Definition: tif_dir.h:69
TIFFDirectory::td_nstrips
tstrile_t td_nstrips
Definition: tif_dir.h:68
tiff::tif_curdir
tdir_t tif_curdir
Definition: tiffiop.h:140
TIFFDirEntry::tdir_offset
uint32 tdir_offset
Definition: tiff.h:120
uint16
unsigned short uint16
Definition: tiff.h:71
TIFFSwabShort
void TIFFSwabShort(uint16 *wp)
Definition: tif_swab.c:36
tiff::tif_postencode
TIFFBoolMethod tif_postencode
Definition: tiffiop.h:158
TIFFFieldInfo
Definition: tiffio.h:303
TIFFDirectory::td_colormap
uint16 * td_colormap[3]
Definition: tif_dir.h:60
TIFF_BIGENDIAN
#define TIFF_BIGENDIAN
Definition: tiff.h:51
TIFFDirectory::td_imagelength
uint32 td_imagelength
Definition: tif_dir.h:41
TIFFTAG_XPOSITION
#define TIFFTAG_XPOSITION
Definition: tiff.h:246
TIFFWriteCustomDirectory
int TIFFWriteCustomDirectory(TIFF *tif, toff_t *pdiroff)
Definition: tif_dirwrite.c:559
TIFFDirectory::td_subifd
uint32 * td_subifd
Definition: tif_dir.h:73
TIFFDirectory::td_rowsperstrip
uint32 td_rowsperstrip
Definition: tif_dir.h:52
TIFFHeader::tiff_magic
uint16 tiff_magic
Definition: tiff.h:96
TIFFDirectory::td_yposition
float td_yposition
Definition: tif_dir.h:58
TIFFDirectory
Definition: tif_dir.h:36
FIELD_PHOTOMETRIC
#define FIELD_PHOTOMETRIC
Definition: tif_dir.h:114
ResetFieldBit
#define ResetFieldBit(fields, f)
Definition: tif_dir.h:177
TIFFErrorExt
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
TIFFTAG_PHOTOMETRIC
#define TIFFTAG_PHOTOMETRIC
Definition: tiff.h:199
tiff::tif_rawdatasize
tsize_t tif_rawdatasize
Definition: tiffiop.h:175
TIFFSwabArrayOfLong
void TIFFSwabArrayOfLong(register uint32 *lp, register unsigned long n)
Definition: tif_swab.c:91
TIFFFieldSet
#define TIFFFieldSet(tif, field)
Definition: tif_dir.h:172
tiff::tif_rawcc
tsize_t tif_rawcc
Definition: tiffiop.h:177
FIELD_COMPRESSION
#define FIELD_COMPRESSION
Definition: tif_dir.h:113
FIELD_SMINSAMPLEVALUE
#define FIELD_SMINSAMPLEVALUE
Definition: tif_dir.h:130
FIELD_ROWSPERSTRIP
#define FIELD_ROWSPERSTRIP
Definition: tif_dir.h:119
TIFFTAG_TRANSFERFUNCTION
#define TIFFTAG_TRANSFERFUNCTION
Definition: tiff.h:276
FIELD_INKNAMES
#define FIELD_INKNAMES
Definition: tif_dir.h:139
tiff::tif_fieldinfo
TIFFFieldInfo ** tif_fieldinfo
Definition: tiffiop.h:194
tiff::tif_header
TIFFHeader tif_header
Definition: tiffiop.h:136
TIFFTAG_COMPRESSION
#define TIFFTAG_COMPRESSION
Definition: tiff.h:168
TIFF_SBYTE
Definition: tiff.h:144
tiff::tif_cleanup
TIFFVoidMethod tif_cleanup
Definition: tiffiop.h:167
isTiled
#define isTiled(tif)
Definition: tiffiop.h:203
TIFFDirEntry::tdir_count
uint32 tdir_count
Definition: tiff.h:119
TIFF_RATIONAL
Definition: tiff.h:143
TIFF_BUFFERSETUP
#define TIFF_BUFFERSETUP
Definition: tiffiop.h:110
TIFFDirectory::td_samplesperpixel
uint16 td_samplesperpixel
Definition: tif_dir.h:51
TIFFDataWidth
int TIFFDataWidth(TIFFDataType type)
Definition: tif_dirinfo.c:662
TIFFDirectory::td_yresolution
float td_yresolution
Definition: tif_dir.h:55
FIELD_EXTRASAMPLES
#define FIELD_EXTRASAMPLES
Definition: tif_dir.h:128
TIFFSetWriteOffset
void TIFFSetWriteOffset(TIFF *tif, toff_t off)
Definition: tif_write.c:706
TIFFCvtNativeToIEEEDouble
#define TIFFCvtNativeToIEEEDouble(tif, n, dp)
Definition: tif_dirwrite.c:36
TIFFSwabArrayOfDouble
void TIFFSwabArrayOfDouble(double *dp, register unsigned long n)
Definition: tif_swab.c:120
TIFF_VARIABLE2
#define TIFF_VARIABLE2
Definition: tiffio.h:299
TIFFDirectory::td_inknames
char * td_inknames
Definition: tif_dir.h:82
_TIFFFieldWithTag
const TIFFFieldInfo * _TIFFFieldWithTag(TIFF *tif, ttag_t tag)
Definition: tif_dirinfo.c:804
TIFF_SLONG
Definition: tiff.h:147
int16
short int16
Definition: tiff.h:69
TIFFCheckpointDirectory
int TIFFCheckpointDirectory(TIFF *tif)
Definition: tif_dirwrite.c:426
TIFFSwabLong
void TIFFSwabLong(uint32 *lp)
Definition: tif_swab.c:47
TIFFTAG_XRESOLUTION
#define TIFFTAG_XRESOLUTION
Definition: tiff.h:240
FIELD_POSITION
#define FIELD_POSITION
Definition: tif_dir.h:108
TIFF_FLOAT
Definition: tiff.h:149
TIFF_DOUBLE
Definition: tiff.h:150
toff_t
uint32 toff_t
Definition: tiffio.h:69
tiff::tif_dir
TIFFDirectory tif_dir
Definition: tiffiop.h:133
FIELD_PAGENUMBER
#define FIELD_PAGENUMBER
Definition: tif_dir.h:124
FIELD_TILEDIMENSIONS
#define FIELD_TILEDIMENSIONS
Definition: tif_dir.h:106
SeekOK
#define SeekOK(tif, off)
Definition: tiffiop.h:230
TIFFDirEntry::tdir_type
uint16 tdir_type
Definition: tiff.h:118
TIFFFieldInfo::field_tag
ttag_t field_tag
Definition: tiffio.h:304
TIFFDirectory::td_compression
uint16 td_compression
Definition: tif_dir.h:46
FieldSet
#define FieldSet(fields, f)
Definition: tif_dir.h:176
TIFFDirEntry::tdir_tag
uint16 tdir_tag
Definition: tiff.h:117
_TIFFmalloc
void * _TIFFmalloc(tsize_t s)
Definition: tif_acorn.c:461
data
JSAMPIMAGE data
Definition: jpeglib.h:945
FIELD_COLORMAP
#define FIELD_COLORMAP
Definition: tif_dir.h:127
TIFFFieldInfo::field_name
char * field_name
Definition: tiffio.h:311
tiff::tif_nextdiroff
toff_t tif_nextdiroff
Definition: tiffiop.h:128
ReadOK
#define ReadOK(tif, buf, size)
Definition: tiffiop.h:226
TIFFGetField
int TIFFGetField(TIFF *tif, ttag_t tag,...)
Definition: tif_dir.c:951
TIFFFieldInfo::field_type
TIFFDataType field_type
Definition: tiffio.h:307
TIFF_SHORT
Definition: tiff.h:141
TIFFCvtNativeToIEEEFloat
#define TIFFCvtNativeToIEEEFloat(tif, n, fp)
Definition: tif_dirwrite.c:35
TIFFDirectory::td_stripbytecount
toff_t * td_stripbytecount
Definition: tif_dir.h:70
_TIFFfree
void _TIFFfree(tdata_t p)
Definition: tif_acorn.c:467
TIFF_IFD
Definition: tiff.h:151
TIFFCreateDirectory
int TIFFCreateDirectory(TIFF *tif)
Definition: tif_dir.c:1040
tiff::tif_subifdoff
toff_t tif_subifdoff
Definition: tiffiop.h:146
FIELD_SAMPLEFORMAT
#define FIELD_SAMPLEFORMAT
Definition: tif_dir.h:129
tiff::tif_dataoff
toff_t tif_dataoff
Definition: tiffiop.h:143
WriteRationalPair
#define WriteRationalPair(type, tag1, v1, tag2, v2)
Definition: tif_dirwrite.c:62
TIFFFieldInfo::field_bit
unsigned short field_bit
Definition: tiffio.h:308
TIFF_INSUBIFD
#define TIFF_INSUBIFD
Definition: tiffiop.h:119
TIFFFlushData1
int TIFFFlushData1(TIFF *tif)
Definition: tif_write.c:682
TIFF_MYBUFFER
#define TIFF_MYBUFFER
Definition: tiffiop.h:115
TIFFFieldInfo::field_writecount
short field_writecount
Definition: tiffio.h:306
TIFFDataType
TIFFDataType
Definition: tiff.h:137
TIFFHeader::tiff_diroff
uint32 tiff_diroff
Definition: tiff.h:100
FIELD_SUBFILETYPE
#define FIELD_SUBFILETYPE
Definition: tif_dir.h:111
tiff::tif_diroff
toff_t tif_diroff
Definition: tiffiop.h:127
TIFFDirectory::td_photometric
uint16 td_photometric
Definition: tif_dir.h:47