projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[AMSTREAM] Sync with Wine Staging 3.9. CORE-14656
[reactos.git] / dll / 3rdparty / libtiff / tif_dirwrite.c
1 /* $Id: tif_dirwrite.c,v 1.89 2017-08-23 13:33:42 erouault 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 <precomp.h>
33 #include <float.h>
34
35 #ifdef HAVE_IEEEFP
36 #define TIFFCvtNativeToIEEEFloat(tif, n, fp)
37 #define TIFFCvtNativeToIEEEDouble(tif, n, dp)
38 #else
39 extern void TIFFCvtNativeToIEEEFloat(TIFF* tif, uint32 n, float* fp);
40 extern void TIFFCvtNativeToIEEEDouble(TIFF* tif, uint32 n, double* dp);
41 #endif
42
43 static int TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff);
44
45 static int TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value);
46 #if 0
47 static int TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);
48 #endif
49
50 static int TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value);
51 static int TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);
52 #ifdef notdef
53 static int TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value);
54 #endif
55 static int TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);
56 #if 0
57 static int TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value);
58 #endif
59 #ifdef notdef
60 static int TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value);
61 #endif
62 static int TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value);
63 #if 0
64 static int TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value);
65 #endif
66 static int TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value);
67 static int TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value);
68 static int TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value);
69 #ifdef notdef
70 static int TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value);
71 #endif
72 static int TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value);
73 #if 0
74 static int TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value);
75 #endif
76 static int TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);
77 static int TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);
78 #if 0
79 static int TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);
80 #endif
81 #ifdef notdef
82 static int TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value);
83 #endif
84 static int TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value);
85 #if 0
86 static int TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value);
87 #endif
88 #ifdef notdef
89 static int TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value);
90 #endif
91 static int TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
92 #ifdef notdef
93 static int TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value);
94 #endif
95 static int TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value);
96 static int TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);
97 static int TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);
98 static int TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);
99 #ifdef notdef
100 static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value);
101 #endif
102 static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);
103 #if 0
104 static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value);
105 #endif
106 #ifdef notdef
107 static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);
108 #endif
109 static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value);
110 #if 0
111 static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);
112 #endif
113 static int TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);
114 #ifdef notdef
115 static int TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
116 #endif
117 static int TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);
118 static int TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
119 static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
120 #ifdef notdef
121 static int TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
122 #endif
123 static int TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir);
124 static int TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir);
125 static int TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir);
126
127 static int TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value);
128 static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);
129 #ifdef notdef
130 static int TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value);
131 #endif
132 static int TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);
133 #ifdef notdef
134 static int TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value);
135 #endif
136 static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value);
137 static int TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value);
138 static int TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value);
139 #ifdef notdef
140 static int TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value);
141 #endif
142 static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value);
143 static int TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);
144 static int TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);
145 #ifdef notdef
146 static int TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value);
147 #endif
148 static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value);
149 #ifdef notdef
150 static int TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value);
151 #endif
152 static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
153 #ifdef notdef
154 static int TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value);
155 #endif
156 static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value);
157 static int TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);
158 static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);
159 static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);
160 #ifdef notdef
161 static int TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value);
162 #endif
163 static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);
164 #ifdef notdef
165 static int TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);
166 #endif
167 static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value);
168 static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);
169 static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);
170
171 static int TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data);
172
173 static int TIFFLinkDirectory(TIFF*);
174
175 /*
176 * Write the contents of the current directory
177 * to the specified file. This routine doesn't
178 * handle overwriting a directory with auxiliary
179 * storage that's been changed.
180 */
181 int
182 TIFFWriteDirectory(TIFF* tif)
183 {
184 return TIFFWriteDirectorySec(tif,TRUE,TRUE,NULL);
185 }
186
187 /*
188 * Similar to TIFFWriteDirectory(), writes the directory out
189 * but leaves all data structures in memory so that it can be
190 * written again. This will make a partially written TIFF file
191 * readable before it is successfully completed/closed.
192 */
193 int
194 TIFFCheckpointDirectory(TIFF* tif)
195 {
196 int rc;
197 /* Setup the strips arrays, if they haven't already been. */
198 if (tif->tif_dir.td_stripoffset == NULL)
199 (void) TIFFSetupStrips(tif);
200 rc = TIFFWriteDirectorySec(tif,TRUE,FALSE,NULL);
201 (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));
202 return rc;
203 }
204
205 int
206 TIFFWriteCustomDirectory(TIFF* tif, uint64* pdiroff)
207 {
208 return TIFFWriteDirectorySec(tif,FALSE,FALSE,pdiroff);
209 }
210
211 /*
212 * Similar to TIFFWriteDirectory(), but if the directory has already
213 * been written once, it is relocated to the end of the file, in case it
214 * has changed in size. Note that this will result in the loss of the
215 * previously used directory space.
216 */
217 int
218 TIFFRewriteDirectory( TIFF *tif )
219 {
220 static const char module[] = "TIFFRewriteDirectory";
221
222 /* We don't need to do anything special if it hasn't been written. */
223 if( tif->tif_diroff == 0 )
224 return TIFFWriteDirectory( tif );
225
226 /*
227 * Find and zero the pointer to this directory, so that TIFFLinkDirectory
228 * will cause it to be added after this directories current pre-link.
229 */
230
231 if (!(tif->tif_flags&TIFF_BIGTIFF))
232 {
233 if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff)
234 {
235 tif->tif_header.classic.tiff_diroff = 0;
236 tif->tif_diroff = 0;
237
238 TIFFSeekFile(tif,4,SEEK_SET);
239 if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4))
240 {
241 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
242 "Error updating TIFF header");
243 return (0);
244 }
245 }
246 else
247 {
248 uint32 nextdir;
249 nextdir = tif->tif_header.classic.tiff_diroff;
250 while(1) {
251 uint16 dircount;
252 uint32 nextnextdir;
253
254 if (!SeekOK(tif, nextdir) ||
255 !ReadOK(tif, &dircount, 2)) {
256 TIFFErrorExt(tif->tif_clientdata, module,
257 "Error fetching directory count");
258 return (0);
259 }
260 if (tif->tif_flags & TIFF_SWAB)
261 TIFFSwabShort(&dircount);
262 (void) TIFFSeekFile(tif,
263 nextdir+2+dircount*12, SEEK_SET);
264 if (!ReadOK(tif, &nextnextdir, 4)) {
265 TIFFErrorExt(tif->tif_clientdata, module,
266 "Error fetching directory link");
267 return (0);
268 }
269 if (tif->tif_flags & TIFF_SWAB)
270 TIFFSwabLong(&nextnextdir);
271 if (nextnextdir==tif->tif_diroff)
272 {
273 uint32 m;
274 m=0;
275 (void) TIFFSeekFile(tif,
276 nextdir+2+dircount*12, SEEK_SET);
277 if (!WriteOK(tif, &m, 4)) {
278 TIFFErrorExt(tif->tif_clientdata, module,
279 "Error writing directory link");
280 return (0);
281 }
282 tif->tif_diroff=0;
283 break;
284 }
285 nextdir=nextnextdir;
286 }
287 }
288 }
289 else
290 {
291 if (tif->tif_header.big.tiff_diroff == tif->tif_diroff)
292 {
293 tif->tif_header.big.tiff_diroff = 0;
294 tif->tif_diroff = 0;
295
296 TIFFSeekFile(tif,8,SEEK_SET);
297 if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8))
298 {
299 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
300 "Error updating TIFF header");
301 return (0);
302 }
303 }
304 else
305 {
306 uint64 nextdir;
307 nextdir = tif->tif_header.big.tiff_diroff;
308 while(1) {
309 uint64 dircount64;
310 uint16 dircount;
311 uint64 nextnextdir;
312
313 if (!SeekOK(tif, nextdir) ||
314 !ReadOK(tif, &dircount64, 8)) {
315 TIFFErrorExt(tif->tif_clientdata, module,
316 "Error fetching directory count");
317 return (0);
318 }
319 if (tif->tif_flags & TIFF_SWAB)
320 TIFFSwabLong8(&dircount64);
321 if (dircount64>0xFFFF)
322 {
323 TIFFErrorExt(tif->tif_clientdata, module,
324 "Sanity check on tag count failed, likely corrupt TIFF");
325 return (0);
326 }
327 dircount=(uint16)dircount64;
328 (void) TIFFSeekFile(tif,
329 nextdir+8+dircount*20, SEEK_SET);
330 if (!ReadOK(tif, &nextnextdir, 8)) {
331 TIFFErrorExt(tif->tif_clientdata, module,
332 "Error fetching directory link");
333 return (0);
334 }
335 if (tif->tif_flags & TIFF_SWAB)
336 TIFFSwabLong8(&nextnextdir);
337 if (nextnextdir==tif->tif_diroff)
338 {
339 uint64 m;
340 m=0;
341 (void) TIFFSeekFile(tif,
342 nextdir+8+dircount*20, SEEK_SET);
343 if (!WriteOK(tif, &m, 8)) {
344 TIFFErrorExt(tif->tif_clientdata, module,
345 "Error writing directory link");
346 return (0);
347 }
348 tif->tif_diroff=0;
349 break;
350 }
351 nextdir=nextnextdir;
352 }
353 }
354 }
355
356 /*
357 * Now use TIFFWriteDirectory() normally.
358 */
359
360 return TIFFWriteDirectory( tif );
361 }
362
363 static int
364 TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff)
365 {
366 static const char module[] = "TIFFWriteDirectorySec";
367 uint32 ndir;
368 TIFFDirEntry* dir;
369 uint32 dirsize;
370 void* dirmem;
371 uint32 m;
372 if (tif->tif_mode == O_RDONLY)
373 return (1);
374
375 _TIFFFillStriles( tif );
376
377 /*
378 * Clear write state so that subsequent images with
379 * different characteristics get the right buffers
380 * setup for them.
381 */
382 if (imagedone)
383 {
384 if (tif->tif_flags & TIFF_POSTENCODE)
385 {
386 tif->tif_flags &= ~TIFF_POSTENCODE;
387 if (!(*tif->tif_postencode)(tif))
388 {
389 TIFFErrorExt(tif->tif_clientdata,module,
390 "Error post-encoding before directory write");
391 return (0);
392 }
393 }
394 (*tif->tif_close)(tif); /* shutdown encoder */
395 /*
396 * Flush any data that might have been written
397 * by the compression close+cleanup routines. But
398 * be careful not to write stuff if we didn't add data
399 * in the previous steps as the "rawcc" data may well be
400 * a previously read tile/strip in mixed read/write mode.
401 */
402 if (tif->tif_rawcc > 0
403 && (tif->tif_flags & TIFF_BEENWRITING) != 0 )
404 {
405 if( !TIFFFlushData1(tif) )
406 {
407 TIFFErrorExt(tif->tif_clientdata, module,
408 "Error flushing data before directory write");
409 return (0);
410 }
411 }
412 if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
413 {
414 _TIFFfree(tif->tif_rawdata);
415 tif->tif_rawdata = NULL;
416 tif->tif_rawcc = 0;
417 tif->tif_rawdatasize = 0;
418 tif->tif_rawdataoff = 0;
419 tif->tif_rawdataloaded = 0;
420 }
421 tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
422 }
423 dir=NULL;
424 dirmem=NULL;
425 dirsize=0;
426 while (1)
427 {
428 ndir=0;
429 if (isimage)
430 {
431 if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS))
432 {
433 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH,tif->tif_dir.td_imagewidth))
434 goto bad;
435 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH,tif->tif_dir.td_imagelength))
436 goto bad;
437 }
438 if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS))
439 {
440 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILEWIDTH,tif->tif_dir.td_tilewidth))
441 goto bad;
442 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH,tif->tif_dir.td_tilelength))
443 goto bad;
444 }
445 if (TIFFFieldSet(tif,FIELD_RESOLUTION))
446 {
447 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION,tif->tif_dir.td_xresolution))
448 goto bad;
449 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION,tif->tif_dir.td_yresolution))
450 goto bad;
451 }
452 if (TIFFFieldSet(tif,FIELD_POSITION))
453 {
454 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XPOSITION,tif->tif_dir.td_xposition))
455 goto bad;
456 if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YPOSITION,tif->tif_dir.td_yposition))
457 goto bad;
458 }
459 if (TIFFFieldSet(tif,FIELD_SUBFILETYPE))
460 {
461 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_SUBFILETYPE,tif->tif_dir.td_subfiletype))
462 goto bad;
463 }
464 if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
465 {
466 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE,tif->tif_dir.td_bitspersample))
467 goto bad;
468 }
469 if (TIFFFieldSet(tif,FIELD_COMPRESSION))
470 {
471 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_COMPRESSION,tif->tif_dir.td_compression))
472 goto bad;
473 }
474 if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC))
475 {
476 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PHOTOMETRIC,tif->tif_dir.td_photometric))
477 goto bad;
478 }
479 if (TIFFFieldSet(tif,FIELD_THRESHHOLDING))
480 {
481 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING,tif->tif_dir.td_threshholding))
482 goto bad;
483 }
484 if (TIFFFieldSet(tif,FIELD_FILLORDER))
485 {
486 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_FILLORDER,tif->tif_dir.td_fillorder))
487 goto bad;
488 }
489 if (TIFFFieldSet(tif,FIELD_ORIENTATION))
490 {
491 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_ORIENTATION,tif->tif_dir.td_orientation))
492 goto bad;
493 }
494 if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
495 {
496 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL,tif->tif_dir.td_samplesperpixel))
497 goto bad;
498 }
499 if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP))
500 {
501 if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP,tif->tif_dir.td_rowsperstrip))
502 goto bad;
503 }
504 if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
505 {
506 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE,tif->tif_dir.td_minsamplevalue))
507 goto bad;
508 }
509 if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
510 {
511 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE,tif->tif_dir.td_maxsamplevalue))
512 goto bad;
513 }
514 if (TIFFFieldSet(tif,FIELD_PLANARCONFIG))
515 {
516 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG,tif->tif_dir.td_planarconfig))
517 goto bad;
518 }
519 if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT))
520 {
521 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT,tif->tif_dir.td_resolutionunit))
522 goto bad;
523 }
524 if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
525 {
526 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER,2,&tif->tif_dir.td_pagenumber[0]))
527 goto bad;
528 }
529 if (TIFFFieldSet(tif,FIELD_STRIPBYTECOUNTS))
530 {
531 if (!isTiled(tif))
532 {
533 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount))
534 goto bad;
535 }
536 else
537 {
538 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount))
539 goto bad;
540 }
541 }
542 if (TIFFFieldSet(tif,FIELD_STRIPOFFSETS))
543 {
544 if (!isTiled(tif))
545 {
546 /* td_stripoffset might be NULL in an odd OJPEG case. See
547 * tif_dirread.c around line 3634.
548 * XXX: OJPEG hack.
549 * If a) compression is OJPEG, b) it's not a tiled TIFF,
550 * and c) the number of strips is 1,
551 * then we tolerate the absence of stripoffsets tag,
552 * because, presumably, all required data is in the
553 * JpegInterchangeFormat stream.
554 * We can get here when using tiffset on such a file.
555 * See http://bugzilla.maptools.org/show_bug.cgi?id=2500
556 */
557 if (tif->tif_dir.td_stripoffset != NULL &&
558 !TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset))
559 goto bad;
560 }
561 else
562 {
563 if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset))
564 goto bad;
565 }
566 }
567 if (TIFFFieldSet(tif,FIELD_COLORMAP))
568 {
569 if (!TIFFWriteDirectoryTagColormap(tif,&ndir,dir))
570 goto bad;
571 }
572 if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES))
573 {
574 if (tif->tif_dir.td_extrasamples)
575 {
576 uint16 na;
577 uint16* nb;
578 TIFFGetFieldDefaulted(tif,TIFFTAG_EXTRASAMPLES,&na,&nb);
579 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_EXTRASAMPLES,na,nb))
580 goto bad;
581 }
582 }
583 if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT))
584 {
585 if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT,tif->tif_dir.td_sampleformat))
586 goto bad;
587 }
588 if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))
589 {
590 if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue))
591 goto bad;
592 }
593 if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))
594 {
595 if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue))
596 goto bad;
597 }
598 if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
599 {
600 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_IMAGEDEPTH,tif->tif_dir.td_imagedepth))
601 goto bad;
602 }
603 if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
604 {
605 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_TILEDEPTH,tif->tif_dir.td_tiledepth))
606 goto bad;
607 }
608 if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
609 {
610 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS,2,&tif->tif_dir.td_halftonehints[0]))
611 goto bad;
612 }
613 if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
614 {
615 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING,2,&tif->tif_dir.td_ycbcrsubsampling[0]))
616 goto bad;
617 }
618 if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING))
619 {
620 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING,tif->tif_dir.td_ycbcrpositioning))
621 goto bad;
622 }
623 if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE))
624 {
625 if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE,6,tif->tif_dir.td_refblackwhite))
626 goto bad;
627 }
628 if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION))
629 {
630 if (!TIFFWriteDirectoryTagTransferfunction(tif,&ndir,dir))
631 goto bad;
632 }
633 if (TIFFFieldSet(tif,FIELD_INKNAMES))
634 {
635 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames))
636 goto bad;
637 }
638 if (TIFFFieldSet(tif,FIELD_SUBIFD))
639 {
640 if (!TIFFWriteDirectoryTagSubifd(tif,&ndir,dir))
641 goto bad;
642 }
643 {
644 uint32 n;
645 for (n=0; n<tif->tif_nfields; n++) {
646 const TIFFField* o;
647 o = tif->tif_fields[n];
648 if ((o->field_bit>=FIELD_CODEC)&&(TIFFFieldSet(tif,o->field_bit)))
649 {
650 switch (o->get_field_type)
651 {
652 case TIFF_SETGET_ASCII:
653 {
654 uint32 pa;
655 char* pb;
656 assert(o->field_type==TIFF_ASCII);
657 assert(o->field_readcount==TIFF_VARIABLE);
658 assert(o->field_passcount==0);
659 TIFFGetField(tif,o->field_tag,&pb);
660 pa=(uint32)(strlen(pb));
661 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,(uint16)o->field_tag,pa,pb))
662 goto bad;
663 }
664 break;
665 case TIFF_SETGET_UINT16:
666 {
667 uint16 p;
668 assert(o->field_type==TIFF_SHORT);
669 assert(o->field_readcount==1);
670 assert(o->field_passcount==0);
671 TIFFGetField(tif,o->field_tag,&p);
672 if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,(uint16)o->field_tag,p))
673 goto bad;
674 }
675 break;
676 case TIFF_SETGET_UINT32:
677 {
678 uint32 p;
679 assert(o->field_type==TIFF_LONG);
680 assert(o->field_readcount==1);
681 assert(o->field_passcount==0);
682 TIFFGetField(tif,o->field_tag,&p);
683 if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,(uint16)o->field_tag,p))
684 goto bad;
685 }
686 break;
687 case TIFF_SETGET_C32_UINT8:
688 {
689 uint32 pa;
690 void* pb;
691 assert(o->field_type==TIFF_UNDEFINED);
692 assert(o->field_readcount==TIFF_VARIABLE2);
693 assert(o->field_passcount==1);
694 TIFFGetField(tif,o->field_tag,&pa,&pb);
695 if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,(uint16)o->field_tag,pa,pb))
696 goto bad;
697 }
698 break;
699 default:
700 assert(0); /* we should never get here */
701 break;
702 }
703 }
704 }
705 }
706 }
707 for (m=0; m<(uint32)(tif->tif_dir.td_customValueCount); m++)
708 {
709 uint16 tag = (uint16)tif->tif_dir.td_customValues[m].info->field_tag;
710 uint32 count = tif->tif_dir.td_customValues[m].count;
711 switch (tif->tif_dir.td_customValues[m].info->field_type)
712 {
713 case TIFF_ASCII:
714 if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
715 goto bad;
716 break;
717 case TIFF_UNDEFINED:
718 if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
719 goto bad;
720 break;
721 case TIFF_BYTE:
722 if (!TIFFWriteDirectoryTagByteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
723 goto bad;
724 break;
725 case TIFF_SBYTE:
726 if (!TIFFWriteDirectoryTagSbyteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
727 goto bad;
728 break;
729 case TIFF_SHORT:
730 if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
731 goto bad;
732 break;
733 case TIFF_SSHORT:
734 if (!TIFFWriteDirectoryTagSshortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
735 goto bad;
736 break;
737 case TIFF_LONG:
738 if (!TIFFWriteDirectoryTagLongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
739 goto bad;
740 break;
741 case TIFF_SLONG:
742 if (!TIFFWriteDirectoryTagSlongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
743 goto bad;
744 break;
745 case TIFF_LONG8:
746 if (!TIFFWriteDirectoryTagLong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
747 goto bad;
748 break;
749 case TIFF_SLONG8:
750 if (!TIFFWriteDirectoryTagSlong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
751 goto bad;
752 break;
753 case TIFF_RATIONAL:
754 if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
755 goto bad;
756 break;
757 case TIFF_SRATIONAL:
758 if (!TIFFWriteDirectoryTagSrationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
759 goto bad;
760 break;
761 case TIFF_FLOAT:
762 if (!TIFFWriteDirectoryTagFloatArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
763 goto bad;
764 break;
765 case TIFF_DOUBLE:
766 if (!TIFFWriteDirectoryTagDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
767 goto bad;
768 break;
769 case TIFF_IFD:
770 if (!TIFFWriteDirectoryTagIfdArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
771 goto bad;
772 break;
773 case TIFF_IFD8:
774 if (!TIFFWriteDirectoryTagIfdIfd8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))
775 goto bad;
776 break;
777 default:
778 assert(0); /* we should never get here */
779 break;
780 }
781 }
782 if (dir!=NULL)
783 break;
784 dir=_TIFFmalloc(ndir*sizeof(TIFFDirEntry));
785 if (dir==NULL)
786 {
787 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
788 goto bad;
789 }
790 if (isimage)
791 {
792 if ((tif->tif_diroff==0)&&(!TIFFLinkDirectory(tif)))
793 goto bad;
794 }
795 else
796 tif->tif_diroff=(TIFFSeekFile(tif,0,SEEK_END)+1)&(~((toff_t)1));
797 if (pdiroff!=NULL)
798 *pdiroff=tif->tif_diroff;
799 if (!(tif->tif_flags&TIFF_BIGTIFF))
800 dirsize=2+ndir*12+4;
801 else
802 dirsize=8+ndir*20+8;
803 tif->tif_dataoff=tif->tif_diroff+dirsize;
804 if (!(tif->tif_flags&TIFF_BIGTIFF))
805 tif->tif_dataoff=(uint32)tif->tif_dataoff;
806 if ((tif->tif_dataoff<tif->tif_diroff)||(tif->tif_dataoff<(uint64)dirsize))
807 {
808 TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded");
809 goto bad;
810 }
811 if (tif->tif_dataoff&1)
812 tif->tif_dataoff++;
813 if (isimage)
814 tif->tif_curdir++;
815 }
816 if (isimage)
817 {
818 if (TIFFFieldSet(tif,FIELD_SUBIFD)&&(tif->tif_subifdoff==0))
819 {
820 uint32 na;
821 TIFFDirEntry* nb;
822 for (na=0, nb=dir; ; na++, nb++)
823 {
824 if( na == ndir )
825 {
826 TIFFErrorExt(tif->tif_clientdata,module,
827 "Cannot find SubIFD tag");
828 goto bad;
829 }
830 if (nb->tdir_tag==TIFFTAG_SUBIFD)
831 break;
832 }
833 if (!(tif->tif_flags&TIFF_BIGTIFF))
834 tif->tif_subifdoff=tif->tif_diroff+2+na*12+8;
835 else
836 tif->tif_subifdoff=tif->tif_diroff+8+na*20+12;
837 }
838 }
839 dirmem=_TIFFmalloc(dirsize);
840 if (dirmem==NULL)
841 {
842 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
843 goto bad;
844 }
845 if (!(tif->tif_flags&TIFF_BIGTIFF))
846 {
847 uint8* n;
848 uint32 nTmp;
849 TIFFDirEntry* o;
850 n=dirmem;
851 *(uint16*)n=(uint16)ndir;
852 if (tif->tif_flags&TIFF_SWAB)
853 TIFFSwabShort((uint16*)n);
854 n+=2;
855 o=dir;
856 for (m=0; m<ndir; m++)
857 {
858 *(uint16*)n=o->tdir_tag;
859 if (tif->tif_flags&TIFF_SWAB)
860 TIFFSwabShort((uint16*)n);
861 n+=2;
862 *(uint16*)n=o->tdir_type;
863 if (tif->tif_flags&TIFF_SWAB)
864 TIFFSwabShort((uint16*)n);
865 n+=2;
866 nTmp = (uint32)o->tdir_count;
867 _TIFFmemcpy(n,&nTmp,4);
868 if (tif->tif_flags&TIFF_SWAB)
869 TIFFSwabLong((uint32*)n);
870 n+=4;
871 /* This is correct. The data has been */
872 /* swabbed previously in TIFFWriteDirectoryTagData */
873 _TIFFmemcpy(n,&o->tdir_offset,4);
874 n+=4;
875 o++;
876 }
877 nTmp = (uint32)tif->tif_nextdiroff;
878 if (tif->tif_flags&TIFF_SWAB)
879 TIFFSwabLong(&nTmp);
880 _TIFFmemcpy(n,&nTmp,4);
881 }
882 else
883 {
884 uint8* n;
885 TIFFDirEntry* o;
886 n=dirmem;
887 *(uint64*)n=ndir;
888 if (tif->tif_flags&TIFF_SWAB)
889 TIFFSwabLong8((uint64*)n);
890 n+=8;
891 o=dir;
892 for (m=0; m<ndir; m++)
893 {
894 *(uint16*)n=o->tdir_tag;
895 if (tif->tif_flags&TIFF_SWAB)
896 TIFFSwabShort((uint16*)n);
897 n+=2;
898 *(uint16*)n=o->tdir_type;
899 if (tif->tif_flags&TIFF_SWAB)
900 TIFFSwabShort((uint16*)n);
901 n+=2;
902 _TIFFmemcpy(n,&o->tdir_count,8);
903 if (tif->tif_flags&TIFF_SWAB)
904 TIFFSwabLong8((uint64*)n);
905 n+=8;
906 _TIFFmemcpy(n,&o->tdir_offset,8);
907 n+=8;
908 o++;
909 }
910 _TIFFmemcpy(n,&tif->tif_nextdiroff,8);
911 if (tif->tif_flags&TIFF_SWAB)
912 TIFFSwabLong8((uint64*)n);
913 }
914 _TIFFfree(dir);
915 dir=NULL;
916 if (!SeekOK(tif,tif->tif_diroff))
917 {
918 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory");
919 goto bad;
920 }
921 if (!WriteOK(tif,dirmem,(tmsize_t)dirsize))
922 {
923 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory");
924 goto bad;
925 }
926 _TIFFfree(dirmem);
927 if (imagedone)
928 {
929 TIFFFreeDirectory(tif);
930 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
931 tif->tif_flags &= ~TIFF_DIRTYSTRIP;
932 (*tif->tif_cleanup)(tif);
933 /*
934 * Reset directory-related state for subsequent
935 * directories.
936 */
937 TIFFCreateDirectory(tif);
938 }
939 return(1);
940 bad:
941 if (dir!=NULL)
942 _TIFFfree(dir);
943 if (dirmem!=NULL)
944 _TIFFfree(dirmem);
945 return(0);
946 }
947
948 static float TIFFClampDoubleToFloat( double val )
949 {
950 if( val > FLT_MAX )
951 return FLT_MAX;
952 if( val < -FLT_MAX )
953 return -FLT_MAX;
954 return (float)val;
955 }
956
957 static int8 TIFFClampDoubleToInt8( double val )
958 {
959 if( val > 127 )
960 return 127;
961 if( val < -128 || val != val )
962 return -128;
963 return (int8)val;
964 }
965
966 static int16 TIFFClampDoubleToInt16( double val )
967 {
968 if( val > 32767 )
969 return 32767;
970 if( val < -32768 || val != val )
971 return -32768;
972 return (int16)val;
973 }
974
975 static int32 TIFFClampDoubleToInt32( double val )
976 {
977 if( val > 0x7FFFFFFF )
978 return 0x7FFFFFFF;
979 if( val < -0x7FFFFFFF-1 || val != val )
980 return -0x7FFFFFFF-1;
981 return (int32)val;
982 }
983
984 static uint8 TIFFClampDoubleToUInt8( double val )
985 {
986 if( val < 0 )
987 return 0;
988 if( val > 255 || val != val )
989 return 255;
990 return (uint8)val;
991 }
992
993 static uint16 TIFFClampDoubleToUInt16( double val )
994 {
995 if( val < 0 )
996 return 0;
997 if( val > 65535 || val != val )
998 return 65535;
999 return (uint16)val;
1000 }
1001
1002 static uint32 TIFFClampDoubleToUInt32( double val )
1003 {
1004 if( val < 0 )
1005 return 0;
1006 if( val > 0xFFFFFFFFU || val != val )
1007 return 0xFFFFFFFFU;
1008 return (uint32)val;
1009 }
1010
1011 static int
1012 TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value)
1013 {
1014 static const char module[] = "TIFFWriteDirectoryTagSampleformatArray";
1015 void* conv;
1016 uint32 i;
1017 int ok;
1018 conv = _TIFFmalloc(count*sizeof(double));
1019 if (conv == NULL)
1020 {
1021 TIFFErrorExt(tif->tif_clientdata, module, "Out of memory");
1022 return (0);
1023 }
1024
1025 switch (tif->tif_dir.td_sampleformat)
1026 {
1027 case SAMPLEFORMAT_IEEEFP:
1028 if (tif->tif_dir.td_bitspersample<=32)
1029 {
1030 for (i = 0; i < count; ++i)
1031 ((float*)conv)[i] = TIFFClampDoubleToFloat(value[i]);
1032 ok = TIFFWriteDirectoryTagFloatArray(tif,ndir,dir,tag,count,(float*)conv);
1033 }
1034 else
1035 {
1036 ok = TIFFWriteDirectoryTagDoubleArray(tif,ndir,dir,tag,count,value);
1037 }
1038 break;
1039 case SAMPLEFORMAT_INT:
1040 if (tif->tif_dir.td_bitspersample<=8)
1041 {
1042 for (i = 0; i < count; ++i)
1043 ((int8*)conv)[i] = TIFFClampDoubleToInt8(value[i]);
1044 ok = TIFFWriteDirectoryTagSbyteArray(tif,ndir,dir,tag,count,(int8*)conv);
1045 }
1046 else if (tif->tif_dir.td_bitspersample<=16)
1047 {
1048 for (i = 0; i < count; ++i)
1049 ((int16*)conv)[i] = TIFFClampDoubleToInt16(value[i]);
1050 ok = TIFFWriteDirectoryTagSshortArray(tif,ndir,dir,tag,count,(int16*)conv);
1051 }
1052 else
1053 {
1054 for (i = 0; i < count; ++i)
1055 ((int32*)conv)[i] = TIFFClampDoubleToInt32(value[i]);
1056 ok = TIFFWriteDirectoryTagSlongArray(tif,ndir,dir,tag,count,(int32*)conv);
1057 }
1058 break;
1059 case SAMPLEFORMAT_UINT:
1060 if (tif->tif_dir.td_bitspersample<=8)
1061 {
1062 for (i = 0; i < count; ++i)
1063 ((uint8*)conv)[i] = TIFFClampDoubleToUInt8(value[i]);
1064 ok = TIFFWriteDirectoryTagByteArray(tif,ndir,dir,tag,count,(uint8*)conv);
1065 }
1066 else if (tif->tif_dir.td_bitspersample<=16)
1067 {
1068 for (i = 0; i < count; ++i)
1069 ((uint16*)conv)[i] = TIFFClampDoubleToUInt16(value[i]);
1070 ok = TIFFWriteDirectoryTagShortArray(tif,ndir,dir,tag,count,(uint16*)conv);
1071 }
1072 else
1073 {
1074 for (i = 0; i < count; ++i)
1075 ((uint32*)conv)[i] = TIFFClampDoubleToUInt32(value[i]);
1076 ok = TIFFWriteDirectoryTagLongArray(tif,ndir,dir,tag,count,(uint32*)conv);
1077 }
1078 break;
1079 default:
1080 ok = 0;
1081 }
1082
1083 _TIFFfree(conv);
1084 return (ok);
1085 }
1086
1087 #if 0
1088 static int
1089 TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
1090 {
1091 switch (tif->tif_dir.td_sampleformat)
1092 {
1093 case SAMPLEFORMAT_IEEEFP:
1094 if (tif->tif_dir.td_bitspersample<=32)
1095 return(TIFFWriteDirectoryTagFloatPerSample(tif,ndir,dir,tag,(float)value));
1096 else
1097 return(TIFFWriteDirectoryTagDoublePerSample(tif,ndir,dir,tag,value));
1098 case SAMPLEFORMAT_INT:
1099 if (tif->tif_dir.td_bitspersample<=8)
1100 return(TIFFWriteDirectoryTagSbytePerSample(tif,ndir,dir,tag,(int8)value));
1101 else if (tif->tif_dir.td_bitspersample<=16)
1102 return(TIFFWriteDirectoryTagSshortPerSample(tif,ndir,dir,tag,(int16)value));
1103 else
1104 return(TIFFWriteDirectoryTagSlongPerSample(tif,ndir,dir,tag,(int32)value));
1105 case SAMPLEFORMAT_UINT:
1106 if (tif->tif_dir.td_bitspersample<=8)
1107 return(TIFFWriteDirectoryTagBytePerSample(tif,ndir,dir,tag,(uint8)value));
1108 else if (tif->tif_dir.td_bitspersample<=16)
1109 return(TIFFWriteDirectoryTagShortPerSample(tif,ndir,dir,tag,(uint16)value));
1110 else
1111 return(TIFFWriteDirectoryTagLongPerSample(tif,ndir,dir,tag,(uint32)value));
1112 default:
1113 return(1);
1114 }
1115 }
1116 #endif
1117
1118 static int
1119 TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value)
1120 {
1121 if (dir==NULL)
1122 {
1123 (*ndir)++;
1124 return(1);
1125 }
1126 return(TIFFWriteDirectoryTagCheckedAscii(tif,ndir,dir,tag,count,value));
1127 }
1128
1129 static int
1130 TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1131 {
1132 if (dir==NULL)
1133 {
1134 (*ndir)++;
1135 return(1);
1136 }
1137 return(TIFFWriteDirectoryTagCheckedUndefinedArray(tif,ndir,dir,tag,count,value));
1138 }
1139
1140 #ifdef notdef
1141 static int
1142 TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value)
1143 {
1144 if (dir==NULL)
1145 {
1146 (*ndir)++;
1147 return(1);
1148 }
1149 return(TIFFWriteDirectoryTagCheckedByte(tif,ndir,dir,tag,value));
1150 }
1151 #endif
1152
1153 static int
1154 TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1155 {
1156 if (dir==NULL)
1157 {
1158 (*ndir)++;
1159 return(1);
1160 }
1161 return(TIFFWriteDirectoryTagCheckedByteArray(tif,ndir,dir,tag,count,value));
1162 }
1163
1164 #if 0
1165 static int
1166 TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value)
1167 {
1168 static const char module[] = "TIFFWriteDirectoryTagBytePerSample";
1169 uint8* m;
1170 uint8* na;
1171 uint16 nb;
1172 int o;
1173 if (dir==NULL)
1174 {
1175 (*ndir)++;
1176 return(1);
1177 }
1178 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint8));
1179 if (m==NULL)
1180 {
1181 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1182 return(0);
1183 }
1184 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1185 *na=value;
1186 o=TIFFWriteDirectoryTagCheckedByteArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1187 _TIFFfree(m);
1188 return(o);
1189 }
1190 #endif
1191
1192 #ifdef notdef
1193 static int
1194 TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value)
1195 {
1196 if (dir==NULL)
1197 {
1198 (*ndir)++;
1199 return(1);
1200 }
1201 return(TIFFWriteDirectoryTagCheckedSbyte(tif,ndir,dir,tag,value));
1202 }
1203 #endif
1204
1205 static int
1206 TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value)
1207 {
1208 if (dir==NULL)
1209 {
1210 (*ndir)++;
1211 return(1);
1212 }
1213 return(TIFFWriteDirectoryTagCheckedSbyteArray(tif,ndir,dir,tag,count,value));
1214 }
1215
1216 #if 0
1217 static int
1218 TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value)
1219 {
1220 static const char module[] = "TIFFWriteDirectoryTagSbytePerSample";
1221 int8* m;
1222 int8* na;
1223 uint16 nb;
1224 int o;
1225 if (dir==NULL)
1226 {
1227 (*ndir)++;
1228 return(1);
1229 }
1230 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int8));
1231 if (m==NULL)
1232 {
1233 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1234 return(0);
1235 }
1236 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1237 *na=value;
1238 o=TIFFWriteDirectoryTagCheckedSbyteArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1239 _TIFFfree(m);
1240 return(o);
1241 }
1242 #endif
1243
1244 static int
1245 TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value)
1246 {
1247 if (dir==NULL)
1248 {
1249 (*ndir)++;
1250 return(1);
1251 }
1252 return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,value));
1253 }
1254
1255 static int
1256 TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value)
1257 {
1258 if (dir==NULL)
1259 {
1260 (*ndir)++;
1261 return(1);
1262 }
1263 return(TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,value));
1264 }
1265
1266 static int
1267 TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value)
1268 {
1269 static const char module[] = "TIFFWriteDirectoryTagShortPerSample";
1270 uint16* m;
1271 uint16* na;
1272 uint16 nb;
1273 int o;
1274 if (dir==NULL)
1275 {
1276 (*ndir)++;
1277 return(1);
1278 }
1279 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint16));
1280 if (m==NULL)
1281 {
1282 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1283 return(0);
1284 }
1285 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1286 *na=value;
1287 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1288 _TIFFfree(m);
1289 return(o);
1290 }
1291
1292 #ifdef notdef
1293 static int
1294 TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value)
1295 {
1296 if (dir==NULL)
1297 {
1298 (*ndir)++;
1299 return(1);
1300 }
1301 return(TIFFWriteDirectoryTagCheckedSshort(tif,ndir,dir,tag,value));
1302 }
1303 #endif
1304
1305 static int
1306 TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value)
1307 {
1308 if (dir==NULL)
1309 {
1310 (*ndir)++;
1311 return(1);
1312 }
1313 return(TIFFWriteDirectoryTagCheckedSshortArray(tif,ndir,dir,tag,count,value));
1314 }
1315
1316 #if 0
1317 static int
1318 TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value)
1319 {
1320 static const char module[] = "TIFFWriteDirectoryTagSshortPerSample";
1321 int16* m;
1322 int16* na;
1323 uint16 nb;
1324 int o;
1325 if (dir==NULL)
1326 {
1327 (*ndir)++;
1328 return(1);
1329 }
1330 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int16));
1331 if (m==NULL)
1332 {
1333 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1334 return(0);
1335 }
1336 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1337 *na=value;
1338 o=TIFFWriteDirectoryTagCheckedSshortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1339 _TIFFfree(m);
1340 return(o);
1341 }
1342 #endif
1343
1344 static int
1345 TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
1346 {
1347 if (dir==NULL)
1348 {
1349 (*ndir)++;
1350 return(1);
1351 }
1352 return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value));
1353 }
1354
1355 static int
1356 TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
1357 {
1358 if (dir==NULL)
1359 {
1360 (*ndir)++;
1361 return(1);
1362 }
1363 return(TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,value));
1364 }
1365
1366 #if 0
1367 static int
1368 TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
1369 {
1370 static const char module[] = "TIFFWriteDirectoryTagLongPerSample";
1371 uint32* m;
1372 uint32* na;
1373 uint16 nb;
1374 int o;
1375 if (dir==NULL)
1376 {
1377 (*ndir)++;
1378 return(1);
1379 }
1380 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint32));
1381 if (m==NULL)
1382 {
1383 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1384 return(0);
1385 }
1386 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1387 *na=value;
1388 o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1389 _TIFFfree(m);
1390 return(o);
1391 }
1392 #endif
1393
1394 #ifdef notdef
1395 static int
1396 TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value)
1397 {
1398 if (dir==NULL)
1399 {
1400 (*ndir)++;
1401 return(1);
1402 }
1403 return(TIFFWriteDirectoryTagCheckedSlong(tif,ndir,dir,tag,value));
1404 }
1405 #endif
1406
1407 static int
1408 TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value)
1409 {
1410 if (dir==NULL)
1411 {
1412 (*ndir)++;
1413 return(1);
1414 }
1415 return(TIFFWriteDirectoryTagCheckedSlongArray(tif,ndir,dir,tag,count,value));
1416 }
1417
1418 #if 0
1419 static int
1420 TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value)
1421 {
1422 static const char module[] = "TIFFWriteDirectoryTagSlongPerSample";
1423 int32* m;
1424 int32* na;
1425 uint16 nb;
1426 int o;
1427 if (dir==NULL)
1428 {
1429 (*ndir)++;
1430 return(1);
1431 }
1432 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int32));
1433 if (m==NULL)
1434 {
1435 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1436 return(0);
1437 }
1438 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1439 *na=value;
1440 o=TIFFWriteDirectoryTagCheckedSlongArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1441 _TIFFfree(m);
1442 return(o);
1443 }
1444 #endif
1445
1446 #ifdef notdef
1447 static int
1448 TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value)
1449 {
1450 if (dir==NULL)
1451 {
1452 (*ndir)++;
1453 return(1);
1454 }
1455 return(TIFFWriteDirectoryTagCheckedLong8(tif,ndir,dir,tag,value));
1456 }
1457 #endif
1458
1459 static int
1460 TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
1461 {
1462 if (dir==NULL)
1463 {
1464 (*ndir)++;
1465 return(1);
1466 }
1467 return(TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value));
1468 }
1469
1470 #ifdef notdef
1471 static int
1472 TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value)
1473 {
1474 if (dir==NULL)
1475 {
1476 (*ndir)++;
1477 return(1);
1478 }
1479 return(TIFFWriteDirectoryTagCheckedSlong8(tif,ndir,dir,tag,value));
1480 }
1481 #endif
1482
1483 static int
1484 TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value)
1485 {
1486 if (dir==NULL)
1487 {
1488 (*ndir)++;
1489 return(1);
1490 }
1491 return(TIFFWriteDirectoryTagCheckedSlong8Array(tif,ndir,dir,tag,count,value));
1492 }
1493
1494 static int
1495 TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
1496 {
1497 if (dir==NULL)
1498 {
1499 (*ndir)++;
1500 return(1);
1501 }
1502 return(TIFFWriteDirectoryTagCheckedRational(tif,ndir,dir,tag,value));
1503 }
1504
1505 static int
1506 TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
1507 {
1508 if (dir==NULL)
1509 {
1510 (*ndir)++;
1511 return(1);
1512 }
1513 return(TIFFWriteDirectoryTagCheckedRationalArray(tif,ndir,dir,tag,count,value));
1514 }
1515
1516 static int
1517 TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
1518 {
1519 if (dir==NULL)
1520 {
1521 (*ndir)++;
1522 return(1);
1523 }
1524 return(TIFFWriteDirectoryTagCheckedSrationalArray(tif,ndir,dir,tag,count,value));
1525 }
1526
1527 #ifdef notdef
1528 static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value)
1529 {
1530 if (dir==NULL)
1531 {
1532 (*ndir)++;
1533 return(1);
1534 }
1535 return(TIFFWriteDirectoryTagCheckedFloat(tif,ndir,dir,tag,value));
1536 }
1537 #endif
1538
1539 static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
1540 {
1541 if (dir==NULL)
1542 {
1543 (*ndir)++;
1544 return(1);
1545 }
1546 return(TIFFWriteDirectoryTagCheckedFloatArray(tif,ndir,dir,tag,count,value));
1547 }
1548
1549 #if 0
1550 static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value)
1551 {
1552 static const char module[] = "TIFFWriteDirectoryTagFloatPerSample";
1553 float* m;
1554 float* na;
1555 uint16 nb;
1556 int o;
1557 if (dir==NULL)
1558 {
1559 (*ndir)++;
1560 return(1);
1561 }
1562 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(float));
1563 if (m==NULL)
1564 {
1565 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1566 return(0);
1567 }
1568 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1569 *na=value;
1570 o=TIFFWriteDirectoryTagCheckedFloatArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1571 _TIFFfree(m);
1572 return(o);
1573 }
1574 #endif
1575
1576 #ifdef notdef
1577 static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
1578 {
1579 if (dir==NULL)
1580 {
1581 (*ndir)++;
1582 return(1);
1583 }
1584 return(TIFFWriteDirectoryTagCheckedDouble(tif,ndir,dir,tag,value));
1585 }
1586 #endif
1587
1588 static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value)
1589 {
1590 if (dir==NULL)
1591 {
1592 (*ndir)++;
1593 return(1);
1594 }
1595 return(TIFFWriteDirectoryTagCheckedDoubleArray(tif,ndir,dir,tag,count,value));
1596 }
1597
1598 #if 0
1599 static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
1600 {
1601 static const char module[] = "TIFFWriteDirectoryTagDoublePerSample";
1602 double* m;
1603 double* na;
1604 uint16 nb;
1605 int o;
1606 if (dir==NULL)
1607 {
1608 (*ndir)++;
1609 return(1);
1610 }
1611 m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(double));
1612 if (m==NULL)
1613 {
1614 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1615 return(0);
1616 }
1617 for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1618 *na=value;
1619 o=TIFFWriteDirectoryTagCheckedDoubleArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1620 _TIFFfree(m);
1621 return(o);
1622 }
1623 #endif
1624
1625 static int
1626 TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
1627 {
1628 if (dir==NULL)
1629 {
1630 (*ndir)++;
1631 return(1);
1632 }
1633 return(TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,value));
1634 }
1635
1636 #ifdef notdef
1637 static int
1638 TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
1639 {
1640 if (dir==NULL)
1641 {
1642 (*ndir)++;
1643 return(1);
1644 }
1645 return(TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,tag,count,value));
1646 }
1647 #endif
1648
1649 static int
1650 TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
1651 {
1652 if (dir==NULL)
1653 {
1654 (*ndir)++;
1655 return(1);
1656 }
1657 if (value<=0xFFFF)
1658 return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,(uint16)value));
1659 else
1660 return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value));
1661 }
1662
1663 /************************************************************************/
1664 /* TIFFWriteDirectoryTagLongLong8Array() */
1665 /* */
1666 /* Write out LONG8 array as LONG8 for BigTIFF or LONG for */
1667 /* Classic TIFF with some checking. */
1668 /************************************************************************/
1669
1670 static int
1671 TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
1672 {
1673 static const char module[] = "TIFFWriteDirectoryTagLongLong8Array";
1674 uint64* ma;
1675 uint32 mb;
1676 uint32* p;
1677 uint32* q;
1678 int o;
1679
1680 /* is this just a counting pass? */
1681 if (dir==NULL)
1682 {
1683 (*ndir)++;
1684 return(1);
1685 }
1686
1687 /* We always write LONG8 for BigTIFF, no checking needed. */
1688 if( tif->tif_flags&TIFF_BIGTIFF )
1689 return TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,
1690 tag,count,value);
1691
1692 /*
1693 ** For classic tiff we want to verify everything is in range for LONG
1694 ** and convert to long format.
1695 */
1696
1697 p = _TIFFmalloc(count*sizeof(uint32));
1698 if (p==NULL)
1699 {
1700 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1701 return(0);
1702 }
1703
1704 for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++)
1705 {
1706 if (*ma>0xFFFFFFFF)
1707 {
1708 TIFFErrorExt(tif->tif_clientdata,module,
1709 "Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file.");
1710 _TIFFfree(p);
1711 return(0);
1712 }
1713 *q= (uint32)(*ma);
1714 }
1715
1716 o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p);
1717 _TIFFfree(p);
1718
1719 return(o);
1720 }
1721
1722 /************************************************************************/
1723 /* TIFFWriteDirectoryTagIfdIfd8Array() */
1724 /* */
1725 /* Write either IFD8 or IFD array depending on file type. */
1726 /************************************************************************/
1727
1728 static int
1729 TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
1730 {
1731 static const char module[] = "TIFFWriteDirectoryTagIfdIfd8Array";
1732 uint64* ma;
1733 uint32 mb;
1734 uint32* p;
1735 uint32* q;
1736 int o;
1737
1738 /* is this just a counting pass? */
1739 if (dir==NULL)
1740 {
1741 (*ndir)++;
1742 return(1);
1743 }
1744
1745 /* We always write IFD8 for BigTIFF, no checking needed. */
1746 if( tif->tif_flags&TIFF_BIGTIFF )
1747 return TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,
1748 tag,count,value);
1749
1750 /*
1751 ** For classic tiff we want to verify everything is in range for IFD
1752 ** and convert to long format.
1753 */
1754
1755 p = _TIFFmalloc(count*sizeof(uint32));
1756 if (p==NULL)
1757 {
1758 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1759 return(0);
1760 }
1761
1762 for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++)
1763 {
1764 if (*ma>0xFFFFFFFF)
1765 {
1766 TIFFErrorExt(tif->tif_clientdata,module,
1767 "Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file.");
1768 _TIFFfree(p);
1769 return(0);
1770 }
1771 *q= (uint32)(*ma);
1772 }
1773
1774 o=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,p);
1775 _TIFFfree(p);
1776
1777 return(o);
1778 }
1779
1780 #ifdef notdef
1781 static int
1782 TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
1783 {
1784 static const char module[] = "TIFFWriteDirectoryTagShortLongLong8Array";
1785 uint64* ma;
1786 uint32 mb;
1787 uint8 n;
1788 int o;
1789 if (dir==NULL)
1790 {
1791 (*ndir)++;
1792 return(1);
1793 }
1794 n=0;
1795 for (ma=value, mb=0; mb<count; ma++, mb++)
1796 {
1797 if ((n==0)&&(*ma>0xFFFF))
1798 n=1;
1799 if ((n==1)&&(*ma>0xFFFFFFFF))
1800 {
1801 n=2;
1802 break;
1803 }
1804 }
1805 if (n==0)
1806 {
1807 uint16* p;
1808 uint16* q;
1809 p=_TIFFmalloc(count*sizeof(uint16));
1810 if (p==NULL)
1811 {
1812 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1813 return(0);
1814 }
1815 for (ma=value, mb=0, q=p; mb<count; ma++, mb++, q++)
1816 *q=(uint16)(*ma);
1817 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,p);
1818 _TIFFfree(p);
1819 }
1820 else if (n==1)
1821 {
1822 uint32* p;
1823 uint32* q;
1824 p=_TIFFmalloc(count*sizeof(uint32));
1825 if (p==NULL)
1826 {
1827 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1828 return(0);
1829 }
1830 for (ma=value, mb=0, q=p; mb<count; ma++, mb++, q++)
1831 *q=(uint32)(*ma);
1832 o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p);
1833 _TIFFfree(p);
1834 }
1835 else
1836 {
1837 assert(n==2);
1838 o=TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value);
1839 }
1840 return(o);
1841 }
1842 #endif
1843 static int
1844 TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir)
1845 {
1846 static const char module[] = "TIFFWriteDirectoryTagColormap";
1847 uint32 m;
1848 uint16* n;
1849 int o;
1850 if (dir==NULL)
1851 {
1852 (*ndir)++;
1853 return(1);
1854 }
1855 m=(1<<tif->tif_dir.td_bitspersample);
1856 n=_TIFFmalloc(3*m*sizeof(uint16));
1857 if (n==NULL)
1858 {
1859 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1860 return(0);
1861 }
1862 _TIFFmemcpy(&n[0],tif->tif_dir.td_colormap[0],m*sizeof(uint16));
1863 _TIFFmemcpy(&n[m],tif->tif_dir.td_colormap[1],m*sizeof(uint16));
1864 _TIFFmemcpy(&n[2*m],tif->tif_dir.td_colormap[2],m*sizeof(uint16));
1865 o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_COLORMAP,3*m,n);
1866 _TIFFfree(n);
1867 return(o);
1868 }
1869
1870 static int
1871 TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir)
1872 {
1873 static const char module[] = "TIFFWriteDirectoryTagTransferfunction";
1874 uint32 m;
1875 uint16 n;
1876 uint16* o;
1877 int p;
1878 if (dir==NULL)
1879 {
1880 (*ndir)++;
1881 return(1);
1882 }
1883 m=(1<<tif->tif_dir.td_bitspersample);
1884 n=tif->tif_dir.td_samplesperpixel-tif->tif_dir.td_extrasamples;
1885 /*
1886 * Check if the table can be written as a single column,
1887 * or if it must be written as 3 columns. Note that we
1888 * write a 3-column tag if there are 2 samples/pixel and
1889 * a single column of data won't suffice--hmm.
1890 */
1891 if (n>3)
1892 n=3;
1893 if (n==3)
1894 {
1895 if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)))
1896 n=2;
1897 }
1898 if (n==2)
1899 {
1900 if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)))
1901 n=1;
1902 }
1903 if (n==0)
1904 n=1;
1905 o=_TIFFmalloc(n*m*sizeof(uint16));
1906 if (o==NULL)
1907 {
1908 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1909 return(0);
1910 }
1911 _TIFFmemcpy(&o[0],tif->tif_dir.td_transferfunction[0],m*sizeof(uint16));
1912 if (n>1)
1913 _TIFFmemcpy(&o[m],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16));
1914 if (n>2)
1915 _TIFFmemcpy(&o[2*m],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16));
1916 p=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_TRANSFERFUNCTION,n*m,o);
1917 _TIFFfree(o);
1918 return(p);
1919 }
1920
1921 static int
1922 TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir)
1923 {
1924 static const char module[] = "TIFFWriteDirectoryTagSubifd";
1925 uint64 m;
1926 int n;
1927 if (tif->tif_dir.td_nsubifd==0)
1928 return(1);
1929 if (dir==NULL)
1930 {
1931 (*ndir)++;
1932 return(1);
1933 }
1934 m=tif->tif_dataoff;
1935 if (!(tif->tif_flags&TIFF_BIGTIFF))
1936 {
1937 uint32* o;
1938 uint64* pa;
1939 uint32* pb;
1940 uint16 p;
1941 o=_TIFFmalloc(tif->tif_dir.td_nsubifd*sizeof(uint32));
1942 if (o==NULL)
1943 {
1944 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1945 return(0);
1946 }
1947 pa=tif->tif_dir.td_subifd;
1948 pb=o;
1949 for (p=0; p < tif->tif_dir.td_nsubifd; p++)
1950 {
1951 assert(pa != 0);
1952
1953 /* Could happen if an classicTIFF has a SubIFD of type LONG8 (which is illegal) */
1954 if( *pa > 0xFFFFFFFFUL)
1955 {
1956 TIFFErrorExt(tif->tif_clientdata,module,"Illegal value for SubIFD tag");
1957 _TIFFfree(o);
1958 return(0);
1959 }
1960 *pb++=(uint32)(*pa++);
1961 }
1962 n=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,o);
1963 _TIFFfree(o);
1964 }
1965 else
1966 n=TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,tif->tif_dir.td_subifd);
1967 if (!n)
1968 return(0);
1969 /*
1970 * Total hack: if this directory includes a SubIFD
1971 * tag then force the next <n> directories to be
1972 * written as ``sub directories'' of this one. This
1973 * is used to write things like thumbnails and
1974 * image masks that one wants to keep out of the
1975 * normal directory linkage access mechanism.
1976 */
1977 tif->tif_flags|=TIFF_INSUBIFD;
1978 tif->tif_nsubifd=tif->tif_dir.td_nsubifd;
1979 if (tif->tif_dir.td_nsubifd==1)
1980 tif->tif_subifdoff=0;
1981 else
1982 tif->tif_subifdoff=m;
1983 return(1);
1984 }
1985
1986 static int
1987 TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value)
1988 {
1989 assert(sizeof(char)==1);
1990 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_ASCII,count,count,value));
1991 }
1992
1993 static int
1994 TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1995 {
1996 assert(sizeof(uint8)==1);
1997 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_UNDEFINED,count,count,value));
1998 }
1999
2000 #ifdef notdef
2001 static int
2002 TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value)
2003 {
2004 assert(sizeof(uint8)==1);
2005 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,1,1,&value));
2006 }
2007 #endif
2008
2009 static int
2010 TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
2011 {
2012 assert(sizeof(uint8)==1);
2013 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,count,count,value));
2014 }
2015
2016 #ifdef notdef
2017 static int
2018 TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value)
2019 {
2020 assert(sizeof(int8)==1);
2021 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,1,1,&value));
2022 }
2023 #endif
2024
2025 static int
2026 TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value)
2027 {
2028 assert(sizeof(int8)==1);
2029 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,count,count,value));
2030 }
2031
2032 static int
2033 TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value)
2034 {
2035 uint16 m;
2036 assert(sizeof(uint16)==2);
2037 m=value;
2038 if (tif->tif_flags&TIFF_SWAB)
2039 TIFFSwabShort(&m);
2040 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,1,2,&m));
2041 }
2042
2043 static int
2044 TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value)
2045 {
2046 assert(count<0x80000000);
2047 assert(sizeof(uint16)==2);
2048 if (tif->tif_flags&TIFF_SWAB)
2049 TIFFSwabArrayOfShort(value,count);
2050 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,count,count*2,value));
2051 }
2052
2053 #ifdef notdef
2054 static int
2055 TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value)
2056 {
2057 int16 m;
2058 assert(sizeof(int16)==2);
2059 m=value;
2060 if (tif->tif_flags&TIFF_SWAB)
2061 TIFFSwabShort((uint16*)(&m));
2062 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,1,2,&m));
2063 }
2064 #endif
2065
2066 static int
2067 TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value)
2068 {
2069 assert(count<0x80000000);
2070 assert(sizeof(int16)==2);
2071 if (tif->tif_flags&TIFF_SWAB)
2072 TIFFSwabArrayOfShort((uint16*)value,count);
2073 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,count,count*2,value));
2074 }
2075
2076 static int
2077 TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
2078 {
2079 uint32 m;
2080 assert(sizeof(uint32)==4);
2081 m=value;
2082 if (tif->tif_flags&TIFF_SWAB)
2083 TIFFSwabLong(&m);
2084 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,1,4,&m));
2085 }
2086
2087 static int
2088 TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
2089 {
2090 assert(count<0x40000000);
2091 assert(sizeof(uint32)==4);
2092 if (tif->tif_flags&TIFF_SWAB)
2093 TIFFSwabArrayOfLong(value,count);
2094 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,count,count*4,value));
2095 }
2096
2097 #ifdef notdef
2098 static int
2099 TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value)
2100 {
2101 int32 m;
2102 assert(sizeof(int32)==4);
2103 m=value;
2104 if (tif->tif_flags&TIFF_SWAB)
2105 TIFFSwabLong((uint32*)(&m));
2106 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,1,4,&m));
2107 }
2108 #endif
2109
2110 static int
2111 TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value)
2112 {
2113 assert(count<0x40000000);
2114 assert(sizeof(int32)==4);
2115 if (tif->tif_flags&TIFF_SWAB)
2116 TIFFSwabArrayOfLong((uint32*)value,count);
2117 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,count,count*4,value));
2118 }
2119
2120 #ifdef notdef
2121 static int
2122 TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value)
2123 {
2124 uint64 m;
2125 assert(sizeof(uint64)==8);
2126 if( !(tif->tif_flags&TIFF_BIGTIFF) ) {
2127 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedLong8","LONG8 not allowed for ClassicTIFF");
2128 return(0);
2129 }
2130 m=value;
2131 if (tif->tif_flags&TIFF_SWAB)
2132 TIFFSwabLong8(&m);
2133 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,1,8,&m));
2134 }
2135 #endif
2136
2137 static int
2138 TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
2139 {
2140 assert(count<0x20000000);
2141 assert(sizeof(uint64)==8);
2142 if( !(tif->tif_flags&TIFF_BIGTIFF) ) {
2143 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedLong8Array","LONG8 not allowed for ClassicTIFF");
2144 return(0);
2145 }
2146 if (tif->tif_flags&TIFF_SWAB)
2147 TIFFSwabArrayOfLong8(value,count);
2148 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,count,count*8,value));
2149 }
2150
2151 #ifdef notdef
2152 static int
2153 TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value)
2154 {
2155 int64 m;
2156 assert(sizeof(int64)==8);
2157 if( !(tif->tif_flags&TIFF_BIGTIFF) ) {
2158 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedSlong8","SLONG8 not allowed for ClassicTIFF");
2159 return(0);
2160 }
2161 m=value;
2162 if (tif->tif_flags&TIFF_SWAB)
2163 TIFFSwabLong8((uint64*)(&m));
2164 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,1,8,&m));
2165 }
2166 #endif
2167
2168 static int
2169 TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value)
2170 {
2171 assert(count<0x20000000);
2172 assert(sizeof(int64)==8);
2173 if( !(tif->tif_flags&TIFF_BIGTIFF) ) {
2174 TIFFErrorExt(tif->tif_clientdata,"TIFFWriteDirectoryTagCheckedSlong8Array","SLONG8 not allowed for ClassicTIFF");
2175 return(0);
2176 }
2177 if (tif->tif_flags&TIFF_SWAB)
2178 TIFFSwabArrayOfLong8((uint64*)value,count);
2179 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,count,count*8,value));
2180 }
2181
2182 static int
2183 TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
2184 {
2185 static const char module[] = "TIFFWriteDirectoryTagCheckedRational";
2186 uint32 m[2];
2187 assert(sizeof(uint32)==4);
2188 if( value < 0 )
2189 {
2190 TIFFErrorExt(tif->tif_clientdata,module,"Negative value is illegal");
2191 return 0;
2192 }
2193 else if( value != value )
2194 {
2195 TIFFErrorExt(tif->tif_clientdata,module,"Not-a-number value is illegal");
2196 return 0;
2197 }
2198 else if (value==0.0)
2199 {
2200 m[0]=0;
2201 m[1]=1;
2202 }
2203 else if (value <= 0xFFFFFFFFU && value==(double)(uint32)value)
2204 {
2205 m[0]=(uint32)value;
2206 m[1]=1;
2207 }
2208 else if (value<1.0)
2209 {
2210 m[0]=(uint32)(value*0xFFFFFFFF);
2211 m[1]=0xFFFFFFFF;
2212 }
2213 else
2214 {
2215 m[0]=0xFFFFFFFF;
2216 m[1]=(uint32)(0xFFFFFFFF/value);
2217 }
2218 if (tif->tif_flags&TIFF_SWAB)
2219 {
2220 TIFFSwabLong(&m[0]);
2221 TIFFSwabLong(&m[1]);
2222 }
2223 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,1,8,&m[0]));
2224 }
2225
2226 static int
2227 TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
2228 {
2229 static const char module[] = "TIFFWriteDirectoryTagCheckedRationalArray";
2230 uint32* m;
2231 float* na;
2232 uint32* nb;
2233 uint32 nc;
2234 int o;
2235 assert(sizeof(uint32)==4);
2236 m=_TIFFmalloc(count*2*sizeof(uint32));
2237 if (m==NULL)
2238 {
2239 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
2240 return(0);
2241 }
2242 for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++)
2243 {
2244 if (*na<=0.0 || *na != *na)
2245 {
2246 nb[0]=0;
2247 nb[1]=1;
2248 }
2249 else if (*na >= 0 && *na <= (float)0xFFFFFFFFU &&
2250 *na==(float)(uint32)(*na))
2251 {
2252 nb[0]=(uint32)(*na);
2253 nb[1]=1;
2254 }
2255 else if (*na<1.0)
2256 {
2257 nb[0]=(uint32)((double)(*na)*0xFFFFFFFF);
2258 nb[1]=0xFFFFFFFF;
2259 }
2260 else
2261 {
2262 nb[0]=0xFFFFFFFF;
2263 nb[1]=(uint32)((double)0xFFFFFFFF/(*na));
2264 }
2265 }
2266 if (tif->tif_flags&TIFF_SWAB)
2267 TIFFSwabArrayOfLong(m,count*2);
2268 o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,count,count*8,&m[0]);
2269 _TIFFfree(m);
2270 return(o);
2271 }
2272
2273 static int
2274 TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
2275 {
2276 static const char module[] = "TIFFWriteDirectoryTagCheckedSrationalArray";
2277 int32* m;
2278 float* na;
2279 int32* nb;
2280 uint32 nc;
2281 int o;
2282 assert(sizeof(int32)==4);
2283 m=_TIFFmalloc(count*2*sizeof(int32));
2284 if (m==NULL)
2285 {
2286 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
2287 return(0);
2288 }
2289 for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++)
2290 {
2291 if (*na<0.0)
2292 {
2293 if (*na==(int32)(*na))
2294 {
2295 nb[0]=(int32)(*na);
2296 nb[1]=1;
2297 }
2298 else if (*na>-1.0)
2299 {
2300 nb[0]=-(int32)((double)(-*na)*0x7FFFFFFF);
2301 nb[1]=0x7FFFFFFF;
2302 }
2303 else
2304 {
2305 nb[0]=-0x7FFFFFFF;
2306 nb[1]=(int32)((double)0x7FFFFFFF/(-*na));
2307 }
2308 }
2309 else
2310 {
2311 if (*na==(int32)(*na))
2312 {
2313 nb[0]=(int32)(*na);
2314 nb[1]=1;
2315 }
2316 else if (*na<1.0)
2317 {
2318 nb[0]=(int32)((double)(*na)*0x7FFFFFFF);
2319 nb[1]=0x7FFFFFFF;
2320 }
2321 else
2322 {
2323 nb[0]=0x7FFFFFFF;
2324 nb[1]=(int32)((double)0x7FFFFFFF/(*na));
2325 }
2326 }
2327 }
2328 if (tif->tif_flags&TIFF_SWAB)
2329 TIFFSwabArrayOfLong((uint32*)m,count*2);
2330 o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SRATIONAL,count,count*8,&m[0]);
2331 _TIFFfree(m);
2332 return(o);
2333 }
2334
2335 #ifdef notdef
2336 static int
2337 TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value)
2338 {
2339 float m;
2340 assert(sizeof(float)==4);
2341 m=value;
2342 TIFFCvtNativeToIEEEFloat(tif,1,&m);
2343 if (tif->tif_flags&TIFF_SWAB)
2344 TIFFSwabFloat(&m);
2345 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,1,4,&m));
2346 }
2347 #endif
2348
2349 static int
2350 TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
2351 {
2352 assert(count<0x40000000);
2353 assert(sizeof(float)==4);
2354 TIFFCvtNativeToIEEEFloat(tif,count,&value);
2355 if (tif->tif_flags&TIFF_SWAB)
2356 TIFFSwabArrayOfFloat(value,count);
2357 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,count,count*4,value));
2358 }
2359
2360 #ifdef notdef
2361 static int
2362 TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
2363 {
2364 double m;
2365 assert(sizeof(double)==8);
2366 m=value;
2367 TIFFCvtNativeToIEEEDouble(tif,1,&m);
2368 if (tif->tif_flags&TIFF_SWAB)
2369 TIFFSwabDouble(&m);
2370 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,1,8,&m));
2371 }
2372 #endif
2373
2374 static int
2375 TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value)
2376 {
2377 assert(count<0x20000000);
2378 assert(sizeof(double)==8);
2379 TIFFCvtNativeToIEEEDouble(tif,count,&value);
2380 if (tif->tif_flags&TIFF_SWAB)
2381 TIFFSwabArrayOfDouble(value,count);
2382 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,count,count*8,value));
2383 }
2384
2385 static int
2386 TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
2387 {
2388 assert(count<0x40000000);
2389 assert(sizeof(uint32)==4);
2390 if (tif->tif_flags&TIFF_SWAB)
2391 TIFFSwabArrayOfLong(value,count);
2392 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD,count,count*4,value));
2393 }
2394
2395 static int
2396 TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
2397 {
2398 assert(count<0x20000000);
2399 assert(sizeof(uint64)==8);
2400 assert(tif->tif_flags&TIFF_BIGTIFF);
2401 if (tif->tif_flags&TIFF_SWAB)
2402 TIFFSwabArrayOfLong8(value,count);
2403 return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD8,count,count*8,value));
2404 }
2405
2406 static int
2407 TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data)
2408 {
2409 static const char module[] = "TIFFWriteDirectoryTagData";
2410 uint32 m;
2411 m=0;
2412 while (m<(*ndir))
2413 {
2414 assert(dir[m].tdir_tag!=tag);
2415 if (dir[m].tdir_tag>tag)
2416 break;
2417 m++;
2418 }
2419 if (m<(*ndir))
2420 {
2421 uint32 n;
2422 for (n=*ndir; n>m; n--)
2423 dir[n]=dir[n-1];
2424 }
2425 dir[m].tdir_tag=tag;
2426 dir[m].tdir_type=datatype;
2427 dir[m].tdir_count=count;
2428 dir[m].tdir_offset.toff_long8 = 0;
2429 if (datalength<=((tif->tif_flags&TIFF_BIGTIFF)?0x8U:0x4U))
2430 _TIFFmemcpy(&dir[m].tdir_offset,data,datalength);
2431 else
2432 {
2433 uint64 na,nb;
2434 na=tif->tif_dataoff;
2435 nb=na+datalength;
2436 if (!(tif->tif_flags&TIFF_BIGTIFF))
2437 nb=(uint32)nb;
2438 if ((nb<na)||(nb<datalength))
2439 {
2440 TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded");
2441 return(0);
2442 }
2443 if (!SeekOK(tif,na))
2444 {
2445 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data");
2446 return(0);
2447 }
2448 assert(datalength<0x80000000UL);
2449 if (!WriteOK(tif,data,(tmsize_t)datalength))
2450 {
2451 TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data");
2452 return(0);
2453 }
2454 tif->tif_dataoff=nb;
2455 if (tif->tif_dataoff&1)
2456 tif->tif_dataoff++;
2457 if (!(tif->tif_flags&TIFF_BIGTIFF))
2458 {
2459 uint32 o;
2460 o=(uint32)na;
2461 if (tif->tif_flags&TIFF_SWAB)
2462 TIFFSwabLong(&o);
2463 _TIFFmemcpy(&dir[m].tdir_offset,&o,4);
2464 }
2465 else
2466 {
2467 dir[m].tdir_offset.toff_long8 = na;
2468 if (tif->tif_flags&TIFF_SWAB)
2469 TIFFSwabLong8(&dir[m].tdir_offset.toff_long8);
2470 }
2471 }
2472 (*ndir)++;
2473 return(1);
2474 }
2475
2476 /*
2477 * Link the current directory into the directory chain for the file.
2478 */
2479 static int
2480 TIFFLinkDirectory(TIFF* tif)
2481 {
2482 static const char module[] = "TIFFLinkDirectory";
2483
2484 tif->tif_diroff = (TIFFSeekFile(tif,0,SEEK_END)+1) & (~((toff_t)1));
2485
2486 /*
2487 * Handle SubIFDs
2488 */
2489 if (tif->tif_flags & TIFF_INSUBIFD)
2490 {
2491 if (!(tif->tif_flags&TIFF_BIGTIFF))
2492 {
2493 uint32 m;
2494 m = (uint32)tif->tif_diroff;
2495 if (tif->tif_flags & TIFF_SWAB)
2496 TIFFSwabLong(&m);
2497 (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
2498 if (!WriteOK(tif, &m, 4)) {
2499 TIFFErrorExt(tif->tif_clientdata, module,
2500 "Error writing SubIFD directory link");
2501 return (0);
2502 }
2503 /*
2504 * Advance to the next SubIFD or, if this is
2505 * the last one configured, revert back to the
2506 * normal directory linkage.
2507 */
2508 if (--tif->tif_nsubifd)
2509 tif->tif_subifdoff += 4;
2510 else
2511 tif->tif_flags &= ~TIFF_INSUBIFD;
2512 return (1);
2513 }
2514 else
2515 {
2516 uint64 m;
2517 m = tif->tif_diroff;
2518 if (tif->tif_flags & TIFF_SWAB)
2519 TIFFSwabLong8(&m);
2520 (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
2521 if (!WriteOK(tif, &m, 8)) {
2522 TIFFErrorExt(tif->tif_clientdata, module,
2523 "Error writing SubIFD directory link");
2524 return (0);
2525 }
2526 /*
2527 * Advance to the next SubIFD or, if this is
2528 * the last one configured, revert back to the
2529 * normal directory linkage.
2530 */
2531 if (--tif->tif_nsubifd)
2532 tif->tif_subifdoff += 8;
2533 else
2534 tif->tif_flags &= ~TIFF_INSUBIFD;
2535 return (1);
2536 }
2537 }
2538
2539 if (!(tif->tif_flags&TIFF_BIGTIFF))
2540 {
2541 uint32 m;
2542 uint32 nextdir;
2543 m = (uint32)(tif->tif_diroff);
2544 if (tif->tif_flags & TIFF_SWAB)
2545 TIFFSwabLong(&m);
2546 if (tif->tif_header.classic.tiff_diroff == 0) {
2547 /*
2548 * First directory, overwrite offset in header.
2549 */
2550 tif->tif_header.classic.tiff_diroff = (uint32) tif->tif_diroff;
2551 (void) TIFFSeekFile(tif,4, SEEK_SET);
2552 if (!WriteOK(tif, &m, 4)) {
2553 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
2554 "Error writing TIFF header");
2555 return (0);
2556 }
2557 return (1);
2558 }
2559 /*
2560 * Not the first directory, search to the last and append.
2561 */
2562 nextdir = tif->tif_header.classic.tiff_diroff;
2563 while(1) {
2564 uint16 dircount;
2565 uint32 nextnextdir;
2566
2567 if (!SeekOK(tif, nextdir) ||
2568 !ReadOK(tif, &dircount, 2)) {
2569 TIFFErrorExt(tif->tif_clientdata, module,
2570 "Error fetching directory count");
2571 return (0);
2572 }
2573 if (tif->tif_flags & TIFF_SWAB)
2574 TIFFSwabShort(&dircount);
2575 (void) TIFFSeekFile(tif,
2576 nextdir+2+dircount*12, SEEK_SET);
2577 if (!ReadOK(tif, &nextnextdir, 4)) {
2578 TIFFErrorExt(tif->tif_clientdata, module,
2579 "Error fetching directory link");
2580 return (0);
2581 }
2582 if (tif->tif_flags & TIFF_SWAB)
2583 TIFFSwabLong(&nextnextdir);
2584 if (nextnextdir==0)
2585 {
2586 (void) TIFFSeekFile(tif,
2587 nextdir+2+dircount*12, SEEK_SET);
2588 if (!WriteOK(tif, &m, 4)) {
2589 TIFFErrorExt(tif->tif_clientdata, module,
2590 "Error writing directory link");
2591 return (0);
2592 }
2593 break;
2594 }
2595 nextdir=nextnextdir;
2596 }
2597 }
2598 else
2599 {
2600 uint64 m;
2601 uint64 nextdir;
2602 m = tif->tif_diroff;
2603 if (tif->tif_flags & TIFF_SWAB)
2604 TIFFSwabLong8(&m);
2605 if (tif->tif_header.big.tiff_diroff == 0) {
2606 /*
2607 * First directory, overwrite offset in header.
2608 */
2609 tif->tif_header.big.tiff_diroff = tif->tif_diroff;
2610 (void) TIFFSeekFile(tif,8, SEEK_SET);
2611 if (!WriteOK(tif, &m, 8)) {
2612 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
2613 "Error writing TIFF header");
2614 return (0);
2615 }
2616 return (1);
2617 }
2618 /*
2619 * Not the first directory, search to the last and append.
2620 */
2621 nextdir = tif->tif_header.big.tiff_diroff;
2622 while(1) {
2623 uint64 dircount64;
2624 uint16 dircount;
2625 uint64 nextnextdir;
2626
2627 if (!SeekOK(tif, nextdir) ||
2628 !ReadOK(tif, &dircount64, 8)) {
2629 TIFFErrorExt(tif->tif_clientdata, module,
2630 "Error fetching directory count");
2631 return (0);
2632 }
2633 if (tif->tif_flags & TIFF_SWAB)
2634 TIFFSwabLong8(&dircount64);
2635 if (dircount64>0xFFFF)
2636 {
2637 TIFFErrorExt(tif->tif_clientdata, module,
2638 "Sanity check on tag count failed, likely corrupt TIFF");
2639 return (0);
2640 }
2641 dircount=(uint16)dircount64;
2642 (void) TIFFSeekFile(tif,
2643 nextdir+8+dircount*20, SEEK_SET);
2644 if (!ReadOK(tif, &nextnextdir, 8)) {
2645 TIFFErrorExt(tif->tif_clientdata, module,
2646 "Error fetching directory link");
2647 return (0);
2648 }
2649 if (tif->tif_flags & TIFF_SWAB)
2650 TIFFSwabLong8(&nextnextdir);
2651 if (nextnextdir==0)
2652 {
2653 (void) TIFFSeekFile(tif,
2654 nextdir+8+dircount*20, SEEK_SET);
2655 if (!WriteOK(tif, &m, 8)) {
2656 TIFFErrorExt(tif->tif_clientdata, module,
2657 "Error writing directory link");
2658 return (0);
2659 }
2660 break;
2661 }
2662 nextdir=nextnextdir;
2663 }
2664 }
2665 return (1);
2666 }
2667
2668 /************************************************************************/
2669 /* TIFFRewriteField() */
2670 /* */
2671 /* Rewrite a field in the directory on disk without regard to */
2672 /* updating the TIFF directory structure in memory. Currently */
2673 /* only supported for field that already exist in the on-disk */
2674 /* directory. Mainly used for updating stripoffset / */
2675 /* stripbytecount values after the directory is already on */
2676 /* disk. */
2677 /* */
2678 /* Returns zero on failure, and one on success. */
2679 /************************************************************************/
2680
2681 int
2682 _TIFFRewriteField(TIFF* tif, uint16 tag, TIFFDataType in_datatype,
2683 tmsize_t count, void* data)
2684 {
2685 static const char module[] = "TIFFResetField";
2686 /* const TIFFField* fip = NULL; */
2687 uint16 dircount;
2688 tmsize_t dirsize;
2689 uint8 direntry_raw[20];
2690 uint16 entry_tag = 0;
2691 uint16 entry_type = 0;
2692 uint64 entry_count = 0;
2693 uint64 entry_offset = 0;
2694 int value_in_entry = 0;
2695 uint64 read_offset;
2696 uint8 *buf_to_write = NULL;
2697 TIFFDataType datatype;
2698
2699 /* -------------------------------------------------------------------- */
2700 /* Find field definition. */
2701 /* -------------------------------------------------------------------- */
2702 /*fip =*/ TIFFFindField(tif, tag, TIFF_ANY);
2703
2704 /* -------------------------------------------------------------------- */
2705 /* Do some checking this is a straight forward case. */
2706 /* -------------------------------------------------------------------- */
2707 if( isMapped(tif) )
2708 {
2709 TIFFErrorExt( tif->tif_clientdata, module,
2710 "Memory mapped files not currently supported for this operation." );
2711 return 0;
2712 }
2713
2714 if( tif->tif_diroff == 0 )
2715 {
2716 TIFFErrorExt( tif->tif_clientdata, module,
2717 "Attempt to reset field on directory not already on disk." );
2718 return 0;
2719 }
2720
2721 /* -------------------------------------------------------------------- */
2722 /* Read the directory entry count. */
2723 /* -------------------------------------------------------------------- */
2724 if (!SeekOK(tif, tif->tif_diroff)) {
2725 TIFFErrorExt(tif->tif_clientdata, module,
2726 "%s: Seek error accessing TIFF directory",
2727 tif->tif_name);
2728 return 0;
2729 }
2730
2731 read_offset = tif->tif_diroff;
2732
2733 if (!(tif->tif_flags&TIFF_BIGTIFF))
2734 {
2735 if (!ReadOK(tif, &dircount, sizeof (uint16))) {
2736 TIFFErrorExt(tif->tif_clientdata, module,
2737 "%s: Can not read TIFF directory count",
2738 tif->tif_name);
2739 return 0;
2740 }
2741 if (tif->tif_flags & TIFF_SWAB)
2742 TIFFSwabShort(&dircount);
2743 dirsize = 12;
2744 read_offset += 2;
2745 } else {
2746 uint64 dircount64;
2747 if (!ReadOK(tif, &dircount64, sizeof (uint64))) {
2748 TIFFErrorExt(tif->tif_clientdata, module,
2749 "%s: Can not read TIFF directory count",
2750 tif->tif_name);
2751 return 0;
2752 }
2753 if (tif->tif_flags & TIFF_SWAB)
2754 TIFFSwabLong8(&dircount64);
2755 dircount = (uint16)dircount64;
2756 dirsize = 20;
2757 read_offset += 8;
2758 }
2759
2760 /* -------------------------------------------------------------------- */
2761 /* Read through directory to find target tag. */
2762 /* -------------------------------------------------------------------- */
2763 while( dircount > 0 )
2764 {
2765 if (!ReadOK(tif, direntry_raw, dirsize)) {
2766 TIFFErrorExt(tif->tif_clientdata, module,
2767 "%s: Can not read TIFF directory entry.",
2768 tif->tif_name);
2769 return 0;
2770 }
2771
2772 memcpy( &entry_tag, direntry_raw + 0, sizeof(uint16) );
2773 if (tif->tif_flags&TIFF_SWAB)
2774 TIFFSwabShort( &entry_tag );
2775
2776 if( entry_tag == tag )
2777 break;
2778
2779 read_offset += dirsize;
2780 }
2781
2782 if( entry_tag != tag )
2783 {
2784 TIFFErrorExt(tif->tif_clientdata, module,
2785 "%s: Could not find tag %d.",
2786 tif->tif_name, tag );
2787 return 0;
2788 }
2789
2790 /* -------------------------------------------------------------------- */
2791 /* Extract the type, count and offset for this entry. */
2792 /* -------------------------------------------------------------------- */
2793 memcpy( &entry_type, direntry_raw + 2, sizeof(uint16) );
2794 if (tif->tif_flags&TIFF_SWAB)
2795 TIFFSwabShort( &entry_type );
2796
2797 if (!(tif->tif_flags&TIFF_BIGTIFF))
2798 {
2799 uint32 value;
2800
2801 memcpy( &value, direntry_raw + 4, sizeof(uint32) );
2802 if (tif->tif_flags&TIFF_SWAB)
2803 TIFFSwabLong( &value );
2804 entry_count = value;
2805
2806 memcpy( &value, direntry_raw + 8, sizeof(uint32) );
2807 if (tif->tif_flags&TIFF_SWAB)
2808 TIFFSwabLong( &value );
2809 entry_offset = value;
2810 }
2811 else
2812 {
2813 memcpy( &entry_count, direntry_raw + 4, sizeof(uint64) );
2814 if (tif->tif_flags&TIFF_SWAB)
2815 TIFFSwabLong8( &entry_count );
2816
2817 memcpy( &entry_offset, direntry_raw + 12, sizeof(uint64) );
2818 if (tif->tif_flags&TIFF_SWAB)
2819 TIFFSwabLong8( &entry_offset );
2820 }
2821
2822 /* -------------------------------------------------------------------- */
2823 /* What data type do we want to write this as? */
2824 /* -------------------------------------------------------------------- */
2825 if( TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags&TIFF_BIGTIFF) )
2826 {
2827 if( in_datatype == TIFF_LONG8 )
2828 datatype = TIFF_LONG;
2829 else if( in_datatype == TIFF_SLONG8 )
2830 datatype = TIFF_SLONG;
2831 else if( in_datatype == TIFF_IFD8 )
2832 datatype = TIFF_IFD;
2833 else
2834 datatype = in_datatype;
2835 }
2836 else
2837 datatype = in_datatype;
2838
2839 /* -------------------------------------------------------------------- */
2840 /* Prepare buffer of actual data to write. This includes */
2841 /* swabbing as needed. */
2842 /* -------------------------------------------------------------------- */
2843 buf_to_write =
2844 (uint8 *)_TIFFCheckMalloc(tif, count, TIFFDataWidth(datatype),
2845 "for field buffer.");
2846 if (!buf_to_write)
2847 return 0;
2848
2849 if( datatype == in_datatype )
2850 memcpy( buf_to_write, data, count * TIFFDataWidth(datatype) );
2851 else if( datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8 )
2852 {
2853 tmsize_t i;
2854
2855 for( i = 0; i < count; i++ )
2856 {
2857 ((int32 *) buf_to_write)[i] =
2858 (int32) ((int64 *) data)[i];
2859 if( (int64) ((int32 *) buf_to_write)[i] != ((int64 *) data)[i] )
2860 {
2861 _TIFFfree( buf_to_write );
2862 TIFFErrorExt( tif->tif_clientdata, module,
2863 "Value exceeds 32bit range of output type." );
2864 return 0;
2865 }
2866 }
2867 }
2868 else if( (datatype == TIFF_LONG && in_datatype == TIFF_LONG8)
2869 || (datatype == TIFF_IFD && in_datatype == TIFF_IFD8) )
2870 {
2871 tmsize_t i;
2872
2873 for( i = 0; i < count; i++ )
2874 {
2875 ((uint32 *) buf_to_write)[i] =
2876 (uint32) ((uint64 *) data)[i];
2877 if( (uint64) ((uint32 *) buf_to_write)[i] != ((uint64 *) data)[i] )
2878 {
2879 _TIFFfree( buf_to_write );
2880 TIFFErrorExt( tif->tif_clientdata, module,
2881 "Value exceeds 32bit range of output type." );
2882 return 0;
2883 }
2884 }
2885 }
2886
2887 if( TIFFDataWidth(datatype) > 1 && (tif->tif_flags&TIFF_SWAB) )
2888 {
2889 if( TIFFDataWidth(datatype) == 2 )
2890 TIFFSwabArrayOfShort( (uint16 *) buf_to_write, count );
2891 else if( TIFFDataWidth(datatype) == 4 )
2892 TIFFSwabArrayOfLong( (uint32 *) buf_to_write, count );
2893 else if( TIFFDataWidth(datatype) == 8 )
2894 TIFFSwabArrayOfLong8( (uint64 *) buf_to_write, count );
2895 }
2896
2897 /* -------------------------------------------------------------------- */
2898 /* Is this a value that fits into the directory entry? */
2899 /* -------------------------------------------------------------------- */
2900 if (!(tif->tif_flags&TIFF_BIGTIFF))
2901 {
2902 if( TIFFDataWidth(datatype) * count <= 4 )
2903 {
2904 entry_offset = read_offset + 8;
2905 value_in_entry = 1;
2906 }
2907 }
2908 else
2909 {
2910 if( TIFFDataWidth(datatype) * count <= 8 )
2911 {
2912 entry_offset = read_offset + 12;
2913 value_in_entry = 1;
2914 }
2915 }
2916
2917 /* -------------------------------------------------------------------- */
2918 /* If the tag type, and count match, then we just write it out */
2919 /* over the old values without altering the directory entry at */
2920 /* all. */
2921 /* -------------------------------------------------------------------- */
2922 if( entry_count == (uint64)count && entry_type == (uint16) datatype )
2923 {
2924 if (!SeekOK(tif, entry_offset)) {
2925 _TIFFfree( buf_to_write );
2926 TIFFErrorExt(tif->tif_clientdata, module,
2927 "%s: Seek error accessing TIFF directory",
2928 tif->tif_name);
2929 return 0;
2930 }
2931 if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) {
2932 _TIFFfree( buf_to_write );
2933 TIFFErrorExt(tif->tif_clientdata, module,
2934 "Error writing directory link");
2935 return (0);
2936 }
2937
2938 _TIFFfree( buf_to_write );
2939 return 1;
2940 }
2941
2942 /* -------------------------------------------------------------------- */
2943 /* Otherwise, we write the new tag data at the end of the file. */
2944 /* -------------------------------------------------------------------- */
2945 if( !value_in_entry )
2946 {
2947 entry_offset = TIFFSeekFile(tif,0,SEEK_END);
2948
2949 if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) {
2950 _TIFFfree( buf_to_write );
2951 TIFFErrorExt(tif->tif_clientdata, module,
2952 "Error writing directory link");
2953 return (0);
2954 }
2955 }
2956 else
2957 {
2958 memcpy( &entry_offset, buf_to_write, count*TIFFDataWidth(datatype));
2959 }
2960
2961 _TIFFfree( buf_to_write );
2962 buf_to_write = 0;
2963
2964 /* -------------------------------------------------------------------- */
2965 /* Adjust the directory entry. */
2966 /* -------------------------------------------------------------------- */
2967 entry_type = datatype;
2968 memcpy( direntry_raw + 2, &entry_type, sizeof(uint16) );
2969 if (tif->tif_flags&TIFF_SWAB)
2970 TIFFSwabShort( (uint16 *) (direntry_raw + 2) );
2971
2972 if (!(tif->tif_flags&TIFF_BIGTIFF))
2973 {
2974 uint32 value;
2975
2976 value = (uint32) entry_count;
2977 memcpy( direntry_raw + 4, &value, sizeof(uint32) );
2978 if (tif->tif_flags&TIFF_SWAB)
2979 TIFFSwabLong( (uint32 *) (direntry_raw + 4) );
2980
2981 value = (uint32) entry_offset;
2982 memcpy( direntry_raw + 8, &value, sizeof(uint32) );
2983 if (tif->tif_flags&TIFF_SWAB)
2984 TIFFSwabLong( (uint32 *) (direntry_raw + 8) );
2985 }
2986 else
2987 {
2988 memcpy( direntry_raw + 4, &entry_count, sizeof(uint64) );
2989 if (tif->tif_flags&TIFF_SWAB)
2990 TIFFSwabLong8( (uint64 *) (direntry_raw + 4) );
2991
2992 memcpy( direntry_raw + 12, &entry_offset, sizeof(uint64) );
2993 if (tif->tif_flags&TIFF_SWAB)
2994 TIFFSwabLong8( (uint64 *) (direntry_raw + 12) );
2995 }
2996
2997 /* -------------------------------------------------------------------- */
2998 /* Write the directory entry out to disk. */
2999 /* -------------------------------------------------------------------- */
3000 if (!SeekOK(tif, read_offset )) {
3001 TIFFErrorExt(tif->tif_clientdata, module,
3002 "%s: Seek error accessing TIFF directory",
3003 tif->tif_name);
3004 return 0;
3005 }
3006
3007 if (!WriteOK(tif, direntry_raw,dirsize))
3008 {
3009 TIFFErrorExt(tif->tif_clientdata, module,
3010 "%s: Can not write TIFF directory entry.",
3011 tif->tif_name);
3012 return 0;
3013 }
3014
3015 return 1;
3016 }
3017 /* vim: set ts=8 sts=8 sw=8 noet: */
3018 /*
3019 * Local Variables:
3020 * mode: c
3021 * c-basic-offset: 8
3022 * fill-column: 78
3023 * End:
3024 */
A free Windows-compatible Operating System