]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/tif_dirwrite.c
projects / wxWidgets.git / blob
? search:


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