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