tif_dirwrite.c

Bug Summary

File:	libs/tiff-4.0.2/libtiff/tif_dirwrite.c
Location:	line 2589, column 5
Description:	Value stored to 'fip' is never read

Annotated Source Code

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_IEEEFP1
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	TIFFWriteDirectory(TIFF* tif)
182	{
183	return TIFFWriteDirectorySec(tif,TRUE1,TRUE1,NULL((void*)0));
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	TIFFCheckpointDirectory(TIFF* tif)
194	{
195	int rc;
196	/* Setup the strips arrays, if they haven't already been. */
197	if (tif->tif_dir.td_stripoffset == NULL((void*)0))
198	(void) TIFFSetupStrips(tif);
199	rc = TIFFWriteDirectorySec(tif,TRUE1,FALSE0,NULL((void*)0));
200	(void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(0),(2))));
201	return rc;
202	}
203
204	int
205	TIFFWriteCustomDirectory(TIFF* tif, uint64* pdiroff)
206	{
207	return TIFFWriteDirectorySec(tif,FALSE0,FALSE0,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	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	if( tif->tif_diroff == 0 )
223	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	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
231	{
232	if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff)
233	{
234	tif->tif_header.classic.tiff_diroff = 0;
235	tif->tif_diroff = 0;
236
237	TIFFSeekFile(tif,4,SEEK_SET)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(4),(0)));
238	if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& (tif->tif_header.classic.tiff_diroff))),((4))))==(4)))
239	{
240	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
241	"Error updating TIFF header");
242	return (0);
243	}
244	}
245	else
246	{
247	uint32 nextdir;
248	nextdir = tif->tif_header.classic.tiff_diroff;
249	while(1) {
250	uint16 dircount;
251	uint32 nextnextdir;
252
253	if (!SeekOK(tif, nextdir)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((nextdir )),(0)))==(nextdir)) \|\|
254	!ReadOK(tif, &dircount, 2)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& dircount)),((2))))==(2))) {
255	TIFFErrorExt(tif->tif_clientdata, module,
256	"Error fetching directory count");
257	return (0);
258	}
259	if (tif->tif_flags & TIFF_SWAB0x00080)
260	TIFFSwabShort(&dircount);
261	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount12),(0)))
262	nextdir+2+dircount12, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount*12),(0)));
263	if (!ReadOK(tif, &nextnextdir, 4)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& nextnextdir)),((4))))==(4))) {
264	TIFFErrorExt(tif->tif_clientdata, module,
265	"Error fetching directory link");
266	return (0);
267	}
268	if (tif->tif_flags & TIFF_SWAB0x00080)
269	TIFFSwabLong(&nextnextdir);
270	if (nextnextdir==tif->tif_diroff)
271	{
272	uint32 m;
273	m=0;
274	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount12),(0)))
275	nextdir+2+dircount12, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount*12),(0)));
276	if (!WriteOK(tif, &m, 4)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((4))))==(4))) {
277	TIFFErrorExt(tif->tif_clientdata, module,
278	"Error writing directory link");
279	return (0);
280	}
281	tif->tif_diroff=0;
282	break;
283	}
284	nextdir=nextnextdir;
285	}
286	}
287	}
288	else
289	{
290	if (tif->tif_header.big.tiff_diroff == tif->tif_diroff)
291	{
292	tif->tif_header.big.tiff_diroff = 0;
293	tif->tif_diroff = 0;
294
295	TIFFSeekFile(tif,8,SEEK_SET)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(8),(0)));
296	if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& (tif->tif_header.big.tiff_diroff))),((8))))==(8)))
297	{
298	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
299	"Error updating TIFF header");
300	return (0);
301	}
302	}
303	else
304	{
305	uint64 nextdir;
306	nextdir = tif->tif_header.big.tiff_diroff;
307	while(1) {
308	uint64 dircount64;
309	uint16 dircount;
310	uint64 nextnextdir;
311
312	if (!SeekOK(tif, nextdir)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((nextdir )),(0)))==(nextdir)) \|\|
313	!ReadOK(tif, &dircount64, 8)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& dircount64)),((8))))==(8))) {
314	TIFFErrorExt(tif->tif_clientdata, module,
315	"Error fetching directory count");
316	return (0);
317	}
318	if (tif->tif_flags & TIFF_SWAB0x00080)
319	TIFFSwabLong8(&dircount64);
320	if (dircount64>0xFFFF)
321	{
322	TIFFErrorExt(tif->tif_clientdata, module,
323	"Sanity check on tag count failed, likely corrupt TIFF");
324	return (0);
325	}
326	dircount=(uint16)dircount64;
327	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount20),(0)))
328	nextdir+8+dircount20, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount*20),(0)));
329	if (!ReadOK(tif, &nextnextdir, 8)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& nextnextdir)),((8))))==(8))) {
330	TIFFErrorExt(tif->tif_clientdata, module,
331	"Error fetching directory link");
332	return (0);
333	}
334	if (tif->tif_flags & TIFF_SWAB0x00080)
335	TIFFSwabLong8(&nextnextdir);
336	if (nextnextdir==tif->tif_diroff)
337	{
338	uint64 m;
339	m=0;
340	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount20),(0)))
341	nextdir+8+dircount20, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount*20),(0)));
342	if (!WriteOK(tif, &m, 8)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((8))))==(8))) {
343	TIFFErrorExt(tif->tif_clientdata, module,
344	"Error writing directory link");
345	return (0);
346	}
347	tif->tif_diroff=0;
348	break;
349	}
350	nextdir=nextnextdir;
351	}
352	}
353	}
354
355	/*
356	* Now use TIFFWriteDirectory() normally.
357	*/
358
359	return TIFFWriteDirectory( tif );
360	}
361
362	static int
363	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	if (tif->tif_mode == O_RDONLY00)
372	return (1);
373
374	_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	if (imagedone)
382	{
383	if (tif->tif_flags & TIFF_POSTENCODE0x01000)
384	{
385	tif->tif_flags &= ~TIFF_POSTENCODE0x01000;
386	if (!(*tif->tif_postencode)(tif))
387	{
388	TIFFErrorExt(tif->tif_clientdata,module,
389	"Error post-encoding before directory write");
390	return (0);
391	}
392	}
393	(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	if (tif->tif_rawcc > 0
402	&& (tif->tif_flags & TIFF_BEENWRITING0x00040) != 0 )
403	{
404	if( !TIFFFlushData1(tif) )
405	{
406	TIFFErrorExt(tif->tif_clientdata, module,
407	"Error flushing data before directory write");
408	return (0);
409	}
410	}
411	if ((tif->tif_flags & TIFF_MYBUFFER0x00200) && tif->tif_rawdata)
412	{
413	_TIFFfree(tif->tif_rawdata);
414	tif->tif_rawdata = NULL((void*)0);
415	tif->tif_rawcc = 0;
416	tif->tif_rawdatasize = 0;
417	tif->tif_rawdataoff = 0;
418	tif->tif_rawdataloaded = 0;
419	}
420	tif->tif_flags &= ~(TIFF_BEENWRITING0x00040\|TIFF_BUFFERSETUP0x00010);
421	}
422	dir=NULL((void*)0);
423	dirmem=NULL((void*)0);
424	dirsize=0;
425	while (1)
426	{
427	ndir=0;
428	if (isimage)
429	{
430	if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)(((tif)->tif_dir.td_fieldsset[(1)/32]) & (((unsigned long )1L)<<((1)&0x1f))))
431	{
432	if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH256,tif->tif_dir.td_imagewidth))
433	goto bad;
434	if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH257,tif->tif_dir.td_imagelength))
435	goto bad;
436	}
437	if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)(((tif)->tif_dir.td_fieldsset[(2)/32]) & (((unsigned long )1L)<<((2)&0x1f))))
438	{
439	if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILEWIDTH322,tif->tif_dir.td_tilewidth))
440	goto bad;
441	if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH323,tif->tif_dir.td_tilelength))
442	goto bad;
443	}
444	if (TIFFFieldSet(tif,FIELD_RESOLUTION)(((tif)->tif_dir.td_fieldsset[(3)/32]) & (((unsigned long )1L)<<((3)&0x1f))))
445	{
446	if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION282,tif->tif_dir.td_xresolution))
447	goto bad;
448	if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION283,tif->tif_dir.td_yresolution))
449	goto bad;
450	}
451	if (TIFFFieldSet(tif,FIELD_POSITION)(((tif)->tif_dir.td_fieldsset[(4)/32]) & (((unsigned long )1L)<<((4)&0x1f))))
452	{
453	if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XPOSITION286,tif->tif_dir.td_xposition))
454	goto bad;
455	if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YPOSITION287,tif->tif_dir.td_yposition))
456	goto bad;
457	}
458	if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)(((tif)->tif_dir.td_fieldsset[(5)/32]) & (((unsigned long )1L)<<((5)&0x1f))))
459	{
460	if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_SUBFILETYPE254,tif->tif_dir.td_subfiletype))
461	goto bad;
462	}
463	if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE)(((tif)->tif_dir.td_fieldsset[(6)/32]) & (((unsigned long )1L)<<((6)&0x1f))))
464	{
465	if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE258,tif->tif_dir.td_bitspersample))
466	goto bad;
467	}
468	if (TIFFFieldSet(tif,FIELD_COMPRESSION)(((tif)->tif_dir.td_fieldsset[(7)/32]) & (((unsigned long )1L)<<((7)&0x1f))))
469	{
470	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_COMPRESSION259,tif->tif_dir.td_compression))
471	goto bad;
472	}
473	if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)(((tif)->tif_dir.td_fieldsset[(8)/32]) & (((unsigned long )1L)<<((8)&0x1f))))
474	{
475	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PHOTOMETRIC262,tif->tif_dir.td_photometric))
476	goto bad;
477	}
478	if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)(((tif)->tif_dir.td_fieldsset[(9)/32]) & (((unsigned long )1L)<<((9)&0x1f))))
479	{
480	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING263,tif->tif_dir.td_threshholding))
481	goto bad;
482	}
483	if (TIFFFieldSet(tif,FIELD_FILLORDER)(((tif)->tif_dir.td_fieldsset[(10)/32]) & (((unsigned long )1L)<<((10)&0x1f))))
484	{
485	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_FILLORDER266,tif->tif_dir.td_fillorder))
486	goto bad;
487	}
488	if (TIFFFieldSet(tif,FIELD_ORIENTATION)(((tif)->tif_dir.td_fieldsset[(15)/32]) & (((unsigned long )1L)<<((15)&0x1f))))
489	{
490	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_ORIENTATION274,tif->tif_dir.td_orientation))
491	goto bad;
492	}
493	if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL)(((tif)->tif_dir.td_fieldsset[(16)/32]) & (((unsigned long )1L)<<((16)&0x1f))))
494	{
495	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL277,tif->tif_dir.td_samplesperpixel))
496	goto bad;
497	}
498	if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)(((tif)->tif_dir.td_fieldsset[(17)/32]) & (((unsigned long )1L)<<((17)&0x1f))))
499	{
500	if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP278,tif->tif_dir.td_rowsperstrip))
501	goto bad;
502	}
503	if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE)(((tif)->tif_dir.td_fieldsset[(18)/32]) & (((unsigned long )1L)<<((18)&0x1f))))
504	{
505	if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE280,tif->tif_dir.td_minsamplevalue))
506	goto bad;
507	}
508	if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE)(((tif)->tif_dir.td_fieldsset[(19)/32]) & (((unsigned long )1L)<<((19)&0x1f))))
509	{
510	if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE281,tif->tif_dir.td_maxsamplevalue))
511	goto bad;
512	}
513	if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)(((tif)->tif_dir.td_fieldsset[(20)/32]) & (((unsigned long )1L)<<((20)&0x1f))))
514	{
515	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG284,tif->tif_dir.td_planarconfig))
516	goto bad;
517	}
518	if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)(((tif)->tif_dir.td_fieldsset[(22)/32]) & (((unsigned long )1L)<<((22)&0x1f))))
519	{
520	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT296,tif->tif_dir.td_resolutionunit))
521	goto bad;
522	}
523	if (TIFFFieldSet(tif,FIELD_PAGENUMBER)(((tif)->tif_dir.td_fieldsset[(23)/32]) & (((unsigned long )1L)<<((23)&0x1f))))
524	{
525	if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER297,2,&tif->tif_dir.td_pagenumber[0]))
526	goto bad;
527	}
528	if (TIFFFieldSet(tif,FIELD_STRIPBYTECOUNTS)(((tif)->tif_dir.td_fieldsset[(24)/32]) & (((unsigned long )1L)<<((24)&0x1f))))
529	{
530	if (!isTiled(tif)(((tif)->tif_flags & 0x00400) != 0))
531	{
532	if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS279,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount))
533	goto bad;
534	}
535	else
536	{
537	if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS325,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount))
538	goto bad;
539	}
540	}
541	if (TIFFFieldSet(tif,FIELD_STRIPOFFSETS)(((tif)->tif_dir.td_fieldsset[(25)/32]) & (((unsigned long )1L)<<((25)&0x1f))))
542	{
543	if (!isTiled(tif)(((tif)->tif_flags & 0x00400) != 0))
544	{
545	if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS273,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset))
546	goto bad;
547	}
548	else
549	{
550	if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS324,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset))
551	goto bad;
552	}
553	}
554	if (TIFFFieldSet(tif,FIELD_COLORMAP)(((tif)->tif_dir.td_fieldsset[(26)/32]) & (((unsigned long )1L)<<((26)&0x1f))))
555	{
556	if (!TIFFWriteDirectoryTagColormap(tif,&ndir,dir))
557	goto bad;
558	}
559	if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES)(((tif)->tif_dir.td_fieldsset[(31)/32]) & (((unsigned long )1L)<<((31)&0x1f))))
560	{
561	if (tif->tif_dir.td_extrasamples)
562	{
563	uint16 na;
564	uint16* nb;
565	TIFFGetFieldDefaulted(tif,TIFFTAG_EXTRASAMPLES338,&na,&nb);
566	if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_EXTRASAMPLES338,na,nb))
567	goto bad;
568	}
569	}
570	if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)(((tif)->tif_dir.td_fieldsset[(32)/32]) & (((unsigned long )1L)<<((32)&0x1f))))
571	{
572	if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT339,tif->tif_dir.td_sampleformat))
573	goto bad;
574	}
575	if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)(((tif)->tif_dir.td_fieldsset[(33)/32]) & (((unsigned long )1L)<<((33)&0x1f))))
576	{
577	if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE340,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue))
578	goto bad;
579	}
580	if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)(((tif)->tif_dir.td_fieldsset[(34)/32]) & (((unsigned long )1L)<<((34)&0x1f))))
581	{
582	if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE341,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue))
583	goto bad;
584	}
585	if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH)(((tif)->tif_dir.td_fieldsset[(35)/32]) & (((unsigned long )1L)<<((35)&0x1f))))
586	{
587	if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_IMAGEDEPTH32997,tif->tif_dir.td_imagedepth))
588	goto bad;
589	}
590	if (TIFFFieldSet(tif,FIELD_TILEDEPTH)(((tif)->tif_dir.td_fieldsset[(36)/32]) & (((unsigned long )1L)<<((36)&0x1f))))
591	{
592	if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_TILEDEPTH32998,tif->tif_dir.td_tiledepth))
593	goto bad;
594	}
595	if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS)(((tif)->tif_dir.td_fieldsset[(37)/32]) & (((unsigned long )1L)<<((37)&0x1f))))
596	{
597	if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS321,2,&tif->tif_dir.td_halftonehints[0]))
598	goto bad;
599	}
600	if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING)(((tif)->tif_dir.td_fieldsset[(39)/32]) & (((unsigned long )1L)<<((39)&0x1f))))
601	{
602	if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING530,2,&tif->tif_dir.td_ycbcrsubsampling[0]))
603	goto bad;
604	}
605	if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)(((tif)->tif_dir.td_fieldsset[(40)/32]) & (((unsigned long )1L)<<((40)&0x1f))))
606	{
607	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING531,tif->tif_dir.td_ycbcrpositioning))
608	goto bad;
609	}
610	if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)(((tif)->tif_dir.td_fieldsset[(41)/32]) & (((unsigned long )1L)<<((41)&0x1f))))
611	{
612	if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE532,6,tif->tif_dir.td_refblackwhite))
613	goto bad;
614	}
615	if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)(((tif)->tif_dir.td_fieldsset[(44)/32]) & (((unsigned long )1L)<<((44)&0x1f))))
616	{
617	if (!TIFFWriteDirectoryTagTransferfunction(tif,&ndir,dir))
618	goto bad;
619	}
620	if (TIFFFieldSet(tif,FIELD_INKNAMES)(((tif)->tif_dir.td_fieldsset[(46)/32]) & (((unsigned long )1L)<<((46)&0x1f))))
621	{
622	if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES333,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames))
623	goto bad;
624	}
625	if (TIFFFieldSet(tif,FIELD_SUBIFD)(((tif)->tif_dir.td_fieldsset[(49)/32]) & (((unsigned long )1L)<<((49)&0x1f))))
626	{
627	if (!TIFFWriteDirectoryTagSubifd(tif,&ndir,dir))
628	goto bad;
629	}
630	{
631	uint32 n;
632	for (n=0; n<tif->tif_nfields; n++) {
633	const TIFFField* o;
634	o = tif->tif_fields[n];
635	if ((o->field_bit>=FIELD_CODEC66)&&(TIFFFieldSet(tif,o->field_bit)(((tif)->tif_dir.td_fieldsset[(o->field_bit)/32]) & (((unsigned long)1L)<<((o->field_bit)&0x1f)))))
636	{
637	switch (o->get_field_type)
638	{
639	case TIFF_SETGET_ASCII:
640	{
641	uint32 pa;
642	char* pb;
643	assert(o->field_type==TIFF_ASCII)((o->field_type==TIFF_ASCII) ? (void) (0) : __assert_fail ( "o->field_type==TIFF_ASCII", "tif_dirwrite.c", 643, __PRETTY_FUNCTION__ ));
644	assert(o->field_readcount==TIFF_VARIABLE)((o->field_readcount==-1) ? (void) (0) : __assert_fail ("o->field_readcount==-1" , "tif_dirwrite.c", 644, __PRETTY_FUNCTION__));
645	assert(o->field_passcount==0)((o->field_passcount==0) ? (void) (0) : __assert_fail ("o->field_passcount==0" , "tif_dirwrite.c", 645, __PRETTY_FUNCTION__));
646	TIFFGetField(tif,o->field_tag,&pb);
647	pa=(uint32)(strlen(pb));
648	if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,o->field_tag,pa,pb))
649	goto bad;
650	}
651	break;
652	case TIFF_SETGET_UINT16:
653	{
654	uint16 p;
655	assert(o->field_type==TIFF_SHORT)((o->field_type==TIFF_SHORT) ? (void) (0) : __assert_fail ( "o->field_type==TIFF_SHORT", "tif_dirwrite.c", 655, __PRETTY_FUNCTION__ ));
656	assert(o->field_readcount==1)((o->field_readcount==1) ? (void) (0) : __assert_fail ("o->field_readcount==1" , "tif_dirwrite.c", 656, __PRETTY_FUNCTION__));
657	assert(o->field_passcount==0)((o->field_passcount==0) ? (void) (0) : __assert_fail ("o->field_passcount==0" , "tif_dirwrite.c", 657, __PRETTY_FUNCTION__));
658	TIFFGetField(tif,o->field_tag,&p);
659	if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,o->field_tag,p))
660	goto bad;
661	}
662	break;
663	case TIFF_SETGET_UINT32:
664	{
665	uint32 p;
666	assert(o->field_type==TIFF_LONG)((o->field_type==TIFF_LONG) ? (void) (0) : __assert_fail ( "o->field_type==TIFF_LONG", "tif_dirwrite.c", 666, __PRETTY_FUNCTION__ ));
667	assert(o->field_readcount==1)((o->field_readcount==1) ? (void) (0) : __assert_fail ("o->field_readcount==1" , "tif_dirwrite.c", 667, __PRETTY_FUNCTION__));
668	assert(o->field_passcount==0)((o->field_passcount==0) ? (void) (0) : __assert_fail ("o->field_passcount==0" , "tif_dirwrite.c", 668, __PRETTY_FUNCTION__));
669	TIFFGetField(tif,o->field_tag,&p);
670	if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,o->field_tag,p))
671	goto bad;
672	}
673	break;
674	case TIFF_SETGET_C32_UINT8:
675	{
676	uint32 pa;
677	void* pb;
678	assert(o->field_type==TIFF_UNDEFINED)((o->field_type==TIFF_UNDEFINED) ? (void) (0) : __assert_fail ("o->field_type==TIFF_UNDEFINED", "tif_dirwrite.c", 678, __PRETTY_FUNCTION__ ));
679	assert(o->field_readcount==TIFF_VARIABLE2)((o->field_readcount==-3) ? (void) (0) : __assert_fail ("o->field_readcount==-3" , "tif_dirwrite.c", 679, __PRETTY_FUNCTION__));
680	assert(o->field_passcount==1)((o->field_passcount==1) ? (void) (0) : __assert_fail ("o->field_passcount==1" , "tif_dirwrite.c", 680, __PRETTY_FUNCTION__));
681	TIFFGetField(tif,o->field_tag,&pa,&pb);
682	if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,o->field_tag,pa,pb))
683	goto bad;
684	}
685	break;
686	default:
687	assert(0)((0) ? (void) (0) : __assert_fail ("0", "tif_dirwrite.c", 687 , __PRETTY_FUNCTION__)); /* we should never get here */
688	break;
689	}
690	}
691	}
692	}
693	}
694	for (m=0; m<(uint32)(tif->tif_dir.td_customValueCount); m++)
695	{
696	switch (tif->tif_dir.td_customValues[m].info->field_type)
697	{
698	case TIFF_ASCII:
699	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	goto bad;
701	break;
702	case TIFF_UNDEFINED:
703	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	goto bad;
705	break;
706	case TIFF_BYTE:
707	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	goto bad;
709	break;
710	case TIFF_SBYTE:
711	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	goto bad;
713	break;
714	case TIFF_SHORT:
715	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	goto bad;
717	break;
718	case TIFF_SSHORT:
719	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	goto bad;
721	break;
722	case TIFF_LONG:
723	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	goto bad;
725	break;
726	case TIFF_SLONG:
727	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	goto bad;
729	break;
730	case TIFF_LONG8:
731	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	goto bad;
733	break;
734	case TIFF_SLONG8:
735	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	goto bad;
737	break;
738	case TIFF_RATIONAL:
739	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	goto bad;
741	break;
742	case TIFF_SRATIONAL:
743	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	goto bad;
745	break;
746	case TIFF_FLOAT:
747	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	goto bad;
749	break;
750	case TIFF_DOUBLE:
751	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	goto bad;
753	break;
754	case TIFF_IFD:
755	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	goto bad;
757	break;
758	case TIFF_IFD8:
759	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	goto bad;
761	break;
762	default:
763	assert(0)((0) ? (void) (0) : __assert_fail ("0", "tif_dirwrite.c", 763 , __PRETTY_FUNCTION__)); /* we should never get here */
764	break;
765	}
766	}
767	if (dir!=NULL((void*)0))
768	break;
769	dir=_TIFFmalloc(ndir*sizeof(TIFFDirEntry));
770	if (dir==NULL((void*)0))
771	{
772	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
773	goto bad;
774	}
775	if (isimage)
776	{
777	if ((tif->tif_diroff==0)&&(!TIFFLinkDirectory(tif)))
778	goto bad;
779	}
780	else
781	tif->tif_diroff=(TIFFSeekFile(tif,0,SEEK_END)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(0),(2)))+1)&(~1);
782	if (pdiroff!=NULL((void*)0))
783	*pdiroff=tif->tif_diroff;
784	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
785	dirsize=2+ndir*12+4;
786	else
787	dirsize=8+ndir*20+8;
788	tif->tif_dataoff=tif->tif_diroff+dirsize;
789	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
790	tif->tif_dataoff=(uint32)tif->tif_dataoff;
791	if ((tif->tif_dataoff<tif->tif_diroff)\|\|(tif->tif_dataoff<(uint64)dirsize))
792	{
793	TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded");
794	goto bad;
795	}
796	if (tif->tif_dataoff&1)
797	tif->tif_dataoff++;
798	if (isimage)
799	tif->tif_curdir++;
800	}
801	if (isimage)
802	{
803	if (TIFFFieldSet(tif,FIELD_SUBIFD)(((tif)->tif_dir.td_fieldsset[(49)/32]) & (((unsigned long )1L)<<((49)&0x1f)))&&(tif->tif_subifdoff==0))
804	{
805	uint32 na;
806	TIFFDirEntry* nb;
807	for (na=0, nb=dir; ; na++, nb++)
808	{
809	assert(na<ndir)((na<ndir) ? (void) (0) : __assert_fail ("na<ndir", "tif_dirwrite.c" , 809, __PRETTY_FUNCTION__));
810	if (nb->tdir_tag==TIFFTAG_SUBIFD330)
811	break;
812	}
813	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
814	tif->tif_subifdoff=tif->tif_diroff+2+na*12+8;
815	else
816	tif->tif_subifdoff=tif->tif_diroff+8+na*20+12;
817	}
818	}
819	dirmem=_TIFFmalloc(dirsize);
820	if (dirmem==NULL((void*)0))
821	{
822	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
823	goto bad;
824	}
825	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
826	{
827	uint8* n;
828	uint32 nTmp;
829	TIFFDirEntry* o;
830	n=dirmem;
831	(uint16)n=ndir;
832	if (tif->tif_flags&TIFF_SWAB0x00080)
833	TIFFSwabShort((uint16*)n);
834	n+=2;
835	o=dir;
836	for (m=0; m<ndir; m++)
837	{
838	(uint16)n=o->tdir_tag;
839	if (tif->tif_flags&TIFF_SWAB0x00080)
840	TIFFSwabShort((uint16*)n);
841	n+=2;
842	(uint16)n=o->tdir_type;
843	if (tif->tif_flags&TIFF_SWAB0x00080)
844	TIFFSwabShort((uint16*)n);
845	n+=2;
846	nTmp = (uint32)o->tdir_count;
847	_TIFFmemcpy(n,&nTmp,4);
848	if (tif->tif_flags&TIFF_SWAB0x00080)
849	TIFFSwabLong((uint32*)n);
850	n+=4;
851	/* This is correct. The data has been */
852	/* swabbed previously in TIFFWriteDirectoryTagData */
853	_TIFFmemcpy(n,&o->tdir_offset,4);
854	n+=4;
855	o++;
856	}
857	nTmp = (uint32)tif->tif_nextdiroff;
858	if (tif->tif_flags&TIFF_SWAB0x00080)
859	TIFFSwabLong(&nTmp);
860	_TIFFmemcpy(n,&nTmp,4);
861	}
862	else
863	{
864	uint8* n;
865	TIFFDirEntry* o;
866	n=dirmem;
867	(uint64)n=ndir;
868	if (tif->tif_flags&TIFF_SWAB0x00080)
869	TIFFSwabLong8((uint64*)n);
870	n+=8;
871	o=dir;
872	for (m=0; m<ndir; m++)
873	{
874	(uint16)n=o->tdir_tag;
875	if (tif->tif_flags&TIFF_SWAB0x00080)
876	TIFFSwabShort((uint16*)n);
877	n+=2;
878	(uint16)n=o->tdir_type;
879	if (tif->tif_flags&TIFF_SWAB0x00080)
880	TIFFSwabShort((uint16*)n);
881	n+=2;
882	_TIFFmemcpy(n,&o->tdir_count,8);
883	if (tif->tif_flags&TIFF_SWAB0x00080)
884	TIFFSwabLong8((uint64*)n);
885	n+=8;
886	_TIFFmemcpy(n,&o->tdir_offset,8);
887	n+=8;
888	o++;
889	}
890	_TIFFmemcpy(n,&tif->tif_nextdiroff,8);
891	if (tif->tif_flags&TIFF_SWAB0x00080)
892	TIFFSwabLong8((uint64*)n);
893	}
894	_TIFFfree(dir);
895	dir=NULL((void*)0);
896	if (!SeekOK(tif,tif->tif_diroff)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((tif ->tif_diroff)),(0)))==(tif->tif_diroff)))
897	{
898	TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory");
899	goto bad;
900	}
901	if (!WriteOK(tif,dirmem,(tmsize_t)dirsize)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((dirmem )),(((tmsize_t)dirsize))))==((tmsize_t)dirsize)))
902	{
903	TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory");
904	goto bad;
905	}
906	_TIFFfree(dirmem);
907	if (imagedone)
908	{
909	TIFFFreeDirectory(tif);
910	tif->tif_flags &= ~TIFF_DIRTYDIRECT0x00008;
911	tif->tif_flags &= ~TIFF_DIRTYSTRIP0x200000;
912	(*tif->tif_cleanup)(tif);
913	/*
914	* Reset directory-related state for subsequent
915	* directories.
916	*/
917	TIFFCreateDirectory(tif);
918	}
919	return(1);
920	bad:
921	if (dir!=NULL((void*)0))
922	_TIFFfree(dir);
923	if (dirmem!=NULL((void*)0))
924	_TIFFfree(dirmem);
925	return(0);
926	}
927
928	static int
929	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	conv = _TIFFmalloc(count*sizeof(double));
936	if (conv == NULL((void*)0))
937	{
938	TIFFErrorExt(tif->tif_clientdata, module, "Out of memory");
939	return (0);
940	}
941
942	switch (tif->tif_dir.td_sampleformat)
943	{
944	case SAMPLEFORMAT_IEEEFP3:
945	if (tif->tif_dir.td_bitspersample<=32)
946	{
947	for (i = 0; i < count; ++i)
948	((float*)conv)[i] = (float)value[i];
949	ok = TIFFWriteDirectoryTagFloatArray(tif,ndir,dir,tag,count,(float*)conv);
950	}
951	else
952	{
953	ok = TIFFWriteDirectoryTagDoubleArray(tif,ndir,dir,tag,count,value);
954	}
955	break;
956	case SAMPLEFORMAT_INT2:
957	if (tif->tif_dir.td_bitspersample<=8)
958	{
959	for (i = 0; i < count; ++i)
960	((int8*)conv)[i] = (int8)value[i];
961	ok = TIFFWriteDirectoryTagSbyteArray(tif,ndir,dir,tag,count,(int8*)conv);
962	}
963	else if (tif->tif_dir.td_bitspersample<=16)
964	{
965	for (i = 0; i < count; ++i)
966	((int16*)conv)[i] = (int16)value[i];
967	ok = TIFFWriteDirectoryTagSshortArray(tif,ndir,dir,tag,count,(int16*)conv);
968	}
969	else
970	{
971	for (i = 0; i < count; ++i)
972	((int32*)conv)[i] = (int32)value[i];
973	ok = TIFFWriteDirectoryTagSlongArray(tif,ndir,dir,tag,count,(int32*)conv);
974	}
975	break;
976	case SAMPLEFORMAT_UINT1:
977	if (tif->tif_dir.td_bitspersample<=8)
978	{
979	for (i = 0; i < count; ++i)
980	((uint8*)conv)[i] = (uint8)value[i];
981	ok = TIFFWriteDirectoryTagByteArray(tif,ndir,dir,tag,count,(uint8*)conv);
982	}
983	else if (tif->tif_dir.td_bitspersample<=16)
984	{
985	for (i = 0; i < count; ++i)
986	((uint16*)conv)[i] = (uint16)value[i];
987	ok = TIFFWriteDirectoryTagShortArray(tif,ndir,dir,tag,count,(uint16*)conv);
988	}
989	else
990	{
991	for (i = 0; i < count; ++i)
992	((uint32*)conv)[i] = (uint32)value[i];
993	ok = TIFFWriteDirectoryTagLongArray(tif,ndir,dir,tag,count,(uint32*)conv);
994	}
995	break;
996	default:
997	ok = 0;
998	}
999
1000	_TIFFfree(conv);
1001	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_IEEEFP3:
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_INT2:
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_UINT1:
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	TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value)
1037	{
1038	if (dir==NULL((void*)0))
1039	{
1040	(*ndir)++;
1041	return(1);
1042	}
1043	return(TIFFWriteDirectoryTagCheckedAscii(tif,ndir,dir,tag,count,value));
1044	}
1045
1046	static int
1047	TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1048	{
1049	if (dir==NULL((void*)0))
1050	{
1051	(*ndir)++;
1052	return(1);
1053	}
1054	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((void*)0))
1062	{
1063	(*ndir)++;
1064	return(1);
1065	}
1066	return(TIFFWriteDirectoryTagCheckedByte(tif,ndir,dir,tag,value));
1067	}
1068	#endif
1069
1070	static int
1071	TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1072	{
1073	if (dir==NULL((void*)0))
1074	{
1075	(*ndir)++;
1076	return(1);
1077	}
1078	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((void*)0))
1091	{
1092	(*ndir)++;
1093	return(1);
1094	}
1095	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint8));
1096	if (m==NULL((void*)0))
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((void*)0))
1114	{
1115	(*ndir)++;
1116	return(1);
1117	}
1118	return(TIFFWriteDirectoryTagCheckedSbyte(tif,ndir,dir,tag,value));
1119	}
1120	#endif
1121
1122	static int
1123	TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value)
1124	{
1125	if (dir==NULL((void*)0))
1126	{
1127	(*ndir)++;
1128	return(1);
1129	}
1130	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((void*)0))
1143	{
1144	(*ndir)++;
1145	return(1);
1146	}
1147	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int8));
1148	if (m==NULL((void*)0))
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	TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value)
1163	{
1164	if (dir==NULL((void*)0))
1165	{
1166	(*ndir)++;
1167	return(1);
1168	}
1169	return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,value));
1170	}
1171
1172	static int
1173	TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value)
1174	{
1175	if (dir==NULL((void*)0))
1176	{
1177	(*ndir)++;
1178	return(1);
1179	}
1180	return(TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,value));
1181	}
1182
1183	static int
1184	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	if (dir==NULL((void*)0))
1192	{
1193	(*ndir)++;
1194	return(1);
1195	}
1196	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint16));
1197	if (m==NULL((void*)0))
1198	{
1199	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1200	return(0);
1201	}
1202	for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++)
1203	*na=value;
1204	o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m);
1205	_TIFFfree(m);
1206	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((void*)0))
1214	{
1215	(*ndir)++;
1216	return(1);
1217	}
1218	return(TIFFWriteDirectoryTagCheckedSshort(tif,ndir,dir,tag,value));
1219	}
1220	#endif
1221
1222	static int
1223	TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value)
1224	{
1225	if (dir==NULL((void*)0))
1226	{
1227	(*ndir)++;
1228	return(1);
1229	}
1230	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((void*)0))
1243	{
1244	(*ndir)++;
1245	return(1);
1246	}
1247	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int16));
1248	if (m==NULL((void*)0))
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	TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
1263	{
1264	if (dir==NULL((void*)0))
1265	{
1266	(*ndir)++;
1267	return(1);
1268	}
1269	return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value));
1270	}
1271
1272	static int
1273	TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
1274	{
1275	if (dir==NULL((void*)0))
1276	{
1277	(*ndir)++;
1278	return(1);
1279	}
1280	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((void*)0))
1293	{
1294	(*ndir)++;
1295	return(1);
1296	}
1297	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint32));
1298	if (m==NULL((void*)0))
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((void*)0))
1316	{
1317	(*ndir)++;
1318	return(1);
1319	}
1320	return(TIFFWriteDirectoryTagCheckedSlong(tif,ndir,dir,tag,value));
1321	}
1322	#endif
1323
1324	static int
1325	TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value)
1326	{
1327	if (dir==NULL((void*)0))
1328	{
1329	(*ndir)++;
1330	return(1);
1331	}
1332	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((void*)0))
1345	{
1346	(*ndir)++;
1347	return(1);
1348	}
1349	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int32));
1350	if (m==NULL((void*)0))
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((void*)0))
1368	{
1369	(*ndir)++;
1370	return(1);
1371	}
1372	return(TIFFWriteDirectoryTagCheckedLong8(tif,ndir,dir,tag,value));
1373	}
1374	#endif
1375
1376	static int
1377	TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
1378	{
1379	if (dir==NULL((void*)0))
1380	{
1381	(*ndir)++;
1382	return(1);
1383	}
1384	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((void*)0))
1392	{
1393	(*ndir)++;
1394	return(1);
1395	}
1396	return(TIFFWriteDirectoryTagCheckedSlong8(tif,ndir,dir,tag,value));
1397	}
1398	#endif
1399
1400	static int
1401	TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value)
1402	{
1403	if (dir==NULL((void*)0))
1404	{
1405	(*ndir)++;
1406	return(1);
1407	}
1408	return(TIFFWriteDirectoryTagCheckedSlong8Array(tif,ndir,dir,tag,count,value));
1409	}
1410
1411	static int
1412	TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
1413	{
1414	if (dir==NULL((void*)0))
1415	{
1416	(*ndir)++;
1417	return(1);
1418	}
1419	return(TIFFWriteDirectoryTagCheckedRational(tif,ndir,dir,tag,value));
1420	}
1421
1422	static int
1423	TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
1424	{
1425	if (dir==NULL((void*)0))
1426	{
1427	(*ndir)++;
1428	return(1);
1429	}
1430	return(TIFFWriteDirectoryTagCheckedRationalArray(tif,ndir,dir,tag,count,value));
1431	}
1432
1433	static int
1434	TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
1435	{
1436	if (dir==NULL((void*)0))
1437	{
1438	(*ndir)++;
1439	return(1);
1440	}
1441	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((void*)0))
1448	{
1449	(*ndir)++;
1450	return(1);
1451	}
1452	return(TIFFWriteDirectoryTagCheckedFloat(tif,ndir,dir,tag,value));
1453	}
1454	#endif
1455
1456	static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
1457	{
1458	if (dir==NULL((void*)0))
1459	{
1460	(*ndir)++;
1461	return(1);
1462	}
1463	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((void*)0))
1475	{
1476	(*ndir)++;
1477	return(1);
1478	}
1479	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(float));
1480	if (m==NULL((void*)0))
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((void*)0))
1497	{
1498	(*ndir)++;
1499	return(1);
1500	}
1501	return(TIFFWriteDirectoryTagCheckedDouble(tif,ndir,dir,tag,value));
1502	}
1503	#endif
1504
1505	static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value)
1506	{
1507	if (dir==NULL((void*)0))
1508	{
1509	(*ndir)++;
1510	return(1);
1511	}
1512	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((void*)0))
1524	{
1525	(*ndir)++;
1526	return(1);
1527	}
1528	m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(double));
1529	if (m==NULL((void*)0))
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	TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
1544	{
1545	if (dir==NULL((void*)0))
1546	{
1547	(*ndir)++;
1548	return(1);
1549	}
1550	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((void*)0))
1558	{
1559	(*ndir)++;
1560	return(1);
1561	}
1562	return(TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,tag,count,value));
1563	}
1564	#endif
1565
1566	static int
1567	TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
1568	{
1569	if (dir==NULL((void*)0))
1570	{
1571	(*ndir)++;
1572	return(1);
1573	}
1574	if (value<=0xFFFF)
1575	return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,(uint16)value));
1576	else
1577	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	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	if (dir==NULL((void*)0))
1599	{
1600	(*ndir)++;
1601	return(1);
1602	}
1603
1604	/* We always write LONG8 for BigTIFF, no checking needed. */
1605	if( tif->tif_flags&TIFF_BIGTIFF0x80000 )
1606	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	p = _TIFFmalloc(count*sizeof(uint32));
1615	if (p==NULL((void*)0))
1616	{
1617	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1618	return(0);
1619	}
1620
1621	for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++)
1622	{
1623	if (*ma>0xFFFFFFFF)
1624	{
1625	TIFFErrorExt(tif->tif_clientdata,module,
1626	"Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file.");
1627	_TIFFfree(p);
1628	return(0);
1629	}
1630	q= (uint32)(ma);
1631	}
1632
1633	o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p);
1634	_TIFFfree(p);
1635
1636	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	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	if (dir==NULL((void*)0))
1657	{
1658	(*ndir)++;
1659	return(1);
1660	}
1661
1662	/* We always write IFD8 for BigTIFF, no checking needed. */
1663	if( tif->tif_flags&TIFF_BIGTIFF0x80000 )
1664	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	p = _TIFFmalloc(count*sizeof(uint32));
1673	if (p==NULL((void*)0))
1674	{
1675	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1676	return(0);
1677	}
1678
1679	for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++)
1680	{
1681	if (*ma>0xFFFFFFFF)
1682	{
1683	TIFFErrorExt(tif->tif_clientdata,module,
1684	"Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file.");
1685	_TIFFfree(p);
1686	return(0);
1687	}
1688	q= (uint32)(ma);
1689	}
1690
1691	o=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,p);
1692	_TIFFfree(p);
1693
1694	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((void*)0))
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((void*)0))
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((void*)0))
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)((n==2) ? (void) (0) : __assert_fail ("n==2", "tif_dirwrite.c" , 1754, __PRETTY_FUNCTION__));
1755	o=TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value);
1756	}
1757	return(o);
1758	}
1759	#endif
1760	static int
1761	TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir)
1762	{
1763	static const char module[] = "TIFFWriteDirectoryTagColormap";
1764	uint32 m;
1765	uint16* n;
1766	int o;
1767	if (dir==NULL((void*)0))
1768	{
1769	(*ndir)++;
1770	return(1);
1771	}
1772	m=(1<<tif->tif_dir.td_bitspersample);
1773	n=_TIFFmalloc(3msizeof(uint16));
1774	if (n==NULL((void*)0))
1775	{
1776	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1777	return(0);
1778	}
1779	_TIFFmemcpy(&n[0],tif->tif_dir.td_colormap[0],m*sizeof(uint16));
1780	_TIFFmemcpy(&n[m],tif->tif_dir.td_colormap[1],m*sizeof(uint16));
1781	_TIFFmemcpy(&n[2m],tif->tif_dir.td_colormap[2],msizeof(uint16));
1782	o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_COLORMAP320,3*m,n);
1783	_TIFFfree(n);
1784	return(o);
1785	}
1786
1787	static int
1788	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	if (dir==NULL((void*)0))
1796	{
1797	(*ndir)++;
1798	return(1);
1799	}
1800	m=(1<<tif->tif_dir.td_bitspersample);
1801	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	if (n>3)
1809	n=3;
1810	if (n==3)
1811	{
1812	if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)))
1813	n=2;
1814	}
1815	if (n==2)
1816	{
1817	if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)))
1818	n=1;
1819	}
1820	if (n==0)
1821	n=1;
1822	o=_TIFFmalloc(nmsizeof(uint16));
1823	if (o==NULL((void*)0))
1824	{
1825	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1826	return(0);
1827	}
1828	_TIFFmemcpy(&o[0],tif->tif_dir.td_transferfunction[0],m*sizeof(uint16));
1829	if (n>1)
1830	_TIFFmemcpy(&o[m],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16));
1831	if (n>2)
1832	_TIFFmemcpy(&o[2m],tif->tif_dir.td_transferfunction[2],msizeof(uint16));
1833	p=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_TRANSFERFUNCTION301,n*m,o);
1834	_TIFFfree(o);
1835	return(p);
1836	}
1837
1838	static int
1839	TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir)
1840	{
1841	static const char module[] = "TIFFWriteDirectoryTagSubifd";
1842	uint64 m;
1843	int n;
1844	if (tif->tif_dir.td_nsubifd==0)
1845	return(1);
1846	if (dir==NULL((void*)0))
1847	{
1848	(*ndir)++;
1849	return(1);
1850	}
1851	m=tif->tif_dataoff;
1852	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
1853	{
1854	uint32* o;
1855	uint64* pa;
1856	uint32* pb;
1857	uint16 p;
1858	o=_TIFFmalloc(tif->tif_dir.td_nsubifd*sizeof(uint32));
1859	if (o==NULL((void*)0))
1860	{
1861	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1862	return(0);
1863	}
1864	pa=tif->tif_dir.td_subifd;
1865	pb=o;
1866	for (p=0; p < tif->tif_dir.td_nsubifd; p++)
1867	{
1868	assert(pa != 0)((pa != 0) ? (void) (0) : __assert_fail ("pa != 0", "tif_dirwrite.c" , 1868, __PRETTY_FUNCTION__));
1869	assert(pa <= 0xFFFFFFFFUL)((pa <= 0xFFFFFFFFUL) ? (void) (0) : __assert_fail ("*pa <= 0xFFFFFFFFUL" , "tif_dirwrite.c", 1869, __PRETTY_FUNCTION__));
1870	pb++=(uint32)(pa++);
1871	}
1872	n=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,TIFFTAG_SUBIFD330,tif->tif_dir.td_nsubifd,o);
1873	_TIFFfree(o);
1874	}
1875	else
1876	n=TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,TIFFTAG_SUBIFD330,tif->tif_dir.td_nsubifd,tif->tif_dir.td_subifd);
1877	if (!n)
1878	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	tif->tif_flags\|=TIFF_INSUBIFD0x02000;
1888	tif->tif_nsubifd=tif->tif_dir.td_nsubifd;
1889	if (tif->tif_dir.td_nsubifd==1)
1890	tif->tif_subifdoff=0;
1891	else
1892	tif->tif_subifdoff=m;
1893	return(1);
1894	}
1895
1896	static int
1897	TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value)
1898	{
1899	assert(sizeof(char)==1)((sizeof(char)==1) ? (void) (0) : __assert_fail ("sizeof(char)==1" , "tif_dirwrite.c", 1899, __PRETTY_FUNCTION__));
1900	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_ASCII,count,count,value));
1901	}
1902
1903	static int
1904	TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1905	{
1906	assert(sizeof(uint8)==1)((sizeof(uint8)==1) ? (void) (0) : __assert_fail ("sizeof(uint8)==1" , "tif_dirwrite.c", 1906, __PRETTY_FUNCTION__));
1907	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)((sizeof(uint8)==1) ? (void) (0) : __assert_fail ("sizeof(uint8)==1" , "tif_dirwrite.c", 1914, __PRETTY_FUNCTION__));
1915	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,1,1,&value));
1916	}
1917	#endif
1918
1919	static int
1920	TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value)
1921	{
1922	assert(sizeof(uint8)==1)((sizeof(uint8)==1) ? (void) (0) : __assert_fail ("sizeof(uint8)==1" , "tif_dirwrite.c", 1922, __PRETTY_FUNCTION__));
1923	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)((sizeof(int8)==1) ? (void) (0) : __assert_fail ("sizeof(int8)==1" , "tif_dirwrite.c", 1930, __PRETTY_FUNCTION__));
1931	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,1,1,&value));
1932	}
1933	#endif
1934
1935	static int
1936	TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value)
1937	{
1938	assert(sizeof(int8)==1)((sizeof(int8)==1) ? (void) (0) : __assert_fail ("sizeof(int8)==1" , "tif_dirwrite.c", 1938, __PRETTY_FUNCTION__));
1939	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,count,count,value));
1940	}
1941
1942	static int
1943	TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value)
1944	{
1945	uint16 m;
1946	assert(sizeof(uint16)==2)((sizeof(uint16)==2) ? (void) (0) : __assert_fail ("sizeof(uint16)==2" , "tif_dirwrite.c", 1946, __PRETTY_FUNCTION__));
1947	m=value;
1948	if (tif->tif_flags&TIFF_SWAB0x00080)
1949	TIFFSwabShort(&m);
1950	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,1,2,&m));
1951	}
1952
1953	static int
1954	TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value)
1955	{
1956	assert(count<0x80000000)((count<0x80000000) ? (void) (0) : __assert_fail ("count<0x80000000" , "tif_dirwrite.c", 1956, __PRETTY_FUNCTION__));
1957	assert(sizeof(uint16)==2)((sizeof(uint16)==2) ? (void) (0) : __assert_fail ("sizeof(uint16)==2" , "tif_dirwrite.c", 1957, __PRETTY_FUNCTION__));
1958	if (tif->tif_flags&TIFF_SWAB0x00080)
1959	TIFFSwabArrayOfShort(value,count);
1960	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)((sizeof(int16)==2) ? (void) (0) : __assert_fail ("sizeof(int16)==2" , "tif_dirwrite.c", 1968, __PRETTY_FUNCTION__));
1969	m=value;
1970	if (tif->tif_flags&TIFF_SWAB0x00080)
1971	TIFFSwabShort((uint16*)(&m));
1972	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,1,2,&m));
1973	}
1974	#endif
1975
1976	static int
1977	TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value)
1978	{
1979	assert(count<0x80000000)((count<0x80000000) ? (void) (0) : __assert_fail ("count<0x80000000" , "tif_dirwrite.c", 1979, __PRETTY_FUNCTION__));
1980	assert(sizeof(int16)==2)((sizeof(int16)==2) ? (void) (0) : __assert_fail ("sizeof(int16)==2" , "tif_dirwrite.c", 1980, __PRETTY_FUNCTION__));
1981	if (tif->tif_flags&TIFF_SWAB0x00080)
1982	TIFFSwabArrayOfShort((uint16*)value,count);
1983	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,count,count*2,value));
1984	}
1985
1986	static int
1987	TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value)
1988	{
1989	uint32 m;
1990	assert(sizeof(uint32)==4)((sizeof(uint32)==4) ? (void) (0) : __assert_fail ("sizeof(uint32)==4" , "tif_dirwrite.c", 1990, __PRETTY_FUNCTION__));
1991	m=value;
1992	if (tif->tif_flags&TIFF_SWAB0x00080)
1993	TIFFSwabLong(&m);
1994	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,1,4,&m));
1995	}
1996
1997	static int
1998	TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
1999	{
2000	assert(count<0x40000000)((count<0x40000000) ? (void) (0) : __assert_fail ("count<0x40000000" , "tif_dirwrite.c", 2000, __PRETTY_FUNCTION__));
2001	assert(sizeof(uint32)==4)((sizeof(uint32)==4) ? (void) (0) : __assert_fail ("sizeof(uint32)==4" , "tif_dirwrite.c", 2001, __PRETTY_FUNCTION__));
2002	if (tif->tif_flags&TIFF_SWAB0x00080)
2003	TIFFSwabArrayOfLong(value,count);
2004	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)((sizeof(int32)==4) ? (void) (0) : __assert_fail ("sizeof(int32)==4" , "tif_dirwrite.c", 2012, __PRETTY_FUNCTION__));
2013	m=value;
2014	if (tif->tif_flags&TIFF_SWAB0x00080)
2015	TIFFSwabLong((uint32*)(&m));
2016	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,1,4,&m));
2017	}
2018	#endif
2019
2020	static int
2021	TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value)
2022	{
2023	assert(count<0x40000000)((count<0x40000000) ? (void) (0) : __assert_fail ("count<0x40000000" , "tif_dirwrite.c", 2023, __PRETTY_FUNCTION__));
2024	assert(sizeof(int32)==4)((sizeof(int32)==4) ? (void) (0) : __assert_fail ("sizeof(int32)==4" , "tif_dirwrite.c", 2024, __PRETTY_FUNCTION__));
2025	if (tif->tif_flags&TIFF_SWAB0x00080)
2026	TIFFSwabArrayOfLong((uint32*)value,count);
2027	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)((sizeof(uint64)==8) ? (void) (0) : __assert_fail ("sizeof(uint64)==8" , "tif_dirwrite.c", 2035, __PRETTY_FUNCTION__));
2036	assert(tif->tif_flags&TIFF_BIGTIFF)((tif->tif_flags&0x80000) ? (void) (0) : __assert_fail ("tif->tif_flags&0x80000", "tif_dirwrite.c", 2036, __PRETTY_FUNCTION__ ));
2037	m=value;
2038	if (tif->tif_flags&TIFF_SWAB0x00080)
2039	TIFFSwabLong8(&m);
2040	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,1,8,&m));
2041	}
2042	#endif
2043
2044	static int
2045	TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
2046	{
2047	assert(count<0x20000000)((count<0x20000000) ? (void) (0) : __assert_fail ("count<0x20000000" , "tif_dirwrite.c", 2047, __PRETTY_FUNCTION__));
2048	assert(sizeof(uint64)==8)((sizeof(uint64)==8) ? (void) (0) : __assert_fail ("sizeof(uint64)==8" , "tif_dirwrite.c", 2048, __PRETTY_FUNCTION__));
2049	assert(tif->tif_flags&TIFF_BIGTIFF)((tif->tif_flags&0x80000) ? (void) (0) : __assert_fail ("tif->tif_flags&0x80000", "tif_dirwrite.c", 2049, __PRETTY_FUNCTION__ ));
2050	if (tif->tif_flags&TIFF_SWAB0x00080)
2051	TIFFSwabArrayOfLong8(value,count);
2052	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)((sizeof(int64)==8) ? (void) (0) : __assert_fail ("sizeof(int64)==8" , "tif_dirwrite.c", 2060, __PRETTY_FUNCTION__));
2061	assert(tif->tif_flags&TIFF_BIGTIFF)((tif->tif_flags&0x80000) ? (void) (0) : __assert_fail ("tif->tif_flags&0x80000", "tif_dirwrite.c", 2061, __PRETTY_FUNCTION__ ));
2062	m=value;
2063	if (tif->tif_flags&TIFF_SWAB0x00080)
2064	TIFFSwabLong8((uint64*)(&m));
2065	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,1,8,&m));
2066	}
2067	#endif
2068
2069	static int
2070	TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value)
2071	{
2072	assert(count<0x20000000)((count<0x20000000) ? (void) (0) : __assert_fail ("count<0x20000000" , "tif_dirwrite.c", 2072, __PRETTY_FUNCTION__));
2073	assert(sizeof(int64)==8)((sizeof(int64)==8) ? (void) (0) : __assert_fail ("sizeof(int64)==8" , "tif_dirwrite.c", 2073, __PRETTY_FUNCTION__));
2074	assert(tif->tif_flags&TIFF_BIGTIFF)((tif->tif_flags&0x80000) ? (void) (0) : __assert_fail ("tif->tif_flags&0x80000", "tif_dirwrite.c", 2074, __PRETTY_FUNCTION__ ));
2075	if (tif->tif_flags&TIFF_SWAB0x00080)
2076	TIFFSwabArrayOfLong8((uint64*)value,count);
2077	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,count,count*8,value));
2078	}
2079
2080	static int
2081	TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value)
2082	{
2083	uint32 m[2];
2084	assert(value>=0.0)((value>=0.0) ? (void) (0) : __assert_fail ("value>=0.0" , "tif_dirwrite.c", 2084, __PRETTY_FUNCTION__));
2085	assert(sizeof(uint32)==4)((sizeof(uint32)==4) ? (void) (0) : __assert_fail ("sizeof(uint32)==4" , "tif_dirwrite.c", 2085, __PRETTY_FUNCTION__));
2086	if (value<=0.0)
2087	{
2088	m[0]=0;
2089	m[1]=1;
2090	}
2091	else if (value==(double)(uint32)value)
2092	{
2093	m[0]=(uint32)value;
2094	m[1]=1;
2095	}
2096	else if (value<1.0)
2097	{
2098	m[0]=(uint32)(value*0xFFFFFFFF);
2099	m[1]=0xFFFFFFFF;
2100	}
2101	else
2102	{
2103	m[0]=0xFFFFFFFF;
2104	m[1]=(uint32)(0xFFFFFFFF/value);
2105	}
2106	if (tif->tif_flags&TIFF_SWAB0x00080)
2107	{
2108	TIFFSwabLong(&m[0]);
2109	TIFFSwabLong(&m[1]);
2110	}
2111	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,1,8,&m[0]));
2112	}
2113
2114	static int
2115	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)((sizeof(uint32)==4) ? (void) (0) : __assert_fail ("sizeof(uint32)==4" , "tif_dirwrite.c", 2123, __PRETTY_FUNCTION__));
2124	m=_TIFFmalloc(count2sizeof(uint32));
2125	if (m==NULL((void*)0))
2126	{
2127	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
2128	return(0);
2129	}
2130	for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++)
2131	{
2132	if (*na<=0.0)
2133	{
2134	nb[0]=0;
2135	nb[1]=1;
2136	}
2137	else if (na==(float)(uint32)(na))
2138	{
2139	nb[0]=(uint32)(*na);
2140	nb[1]=1;
2141	}
2142	else if (*na<1.0)
2143	{
2144	nb[0]=(uint32)((na)0xFFFFFFFF);
2145	nb[1]=0xFFFFFFFF;
2146	}
2147	else
2148	{
2149	nb[0]=0xFFFFFFFF;
2150	nb[1]=(uint32)(0xFFFFFFFF/(*na));
2151	}
2152	}
2153	if (tif->tif_flags&TIFF_SWAB0x00080)
2154	TIFFSwabArrayOfLong(m,count*2);
2155	o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,count,count*8,&m[0]);
2156	_TIFFfree(m);
2157	return(o);
2158	}
2159
2160	static int
2161	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)((sizeof(int32)==4) ? (void) (0) : __assert_fail ("sizeof(int32)==4" , "tif_dirwrite.c", 2169, __PRETTY_FUNCTION__));
2170	m=_TIFFmalloc(count2sizeof(int32));
2171	if (m==NULL((void*)0))
2172	{
2173	TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
2174	return(0);
2175	}
2176	for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++)
2177	{
2178	if (*na<0.0)
2179	{
2180	if (na==(int32)(na))
2181	{
2182	nb[0]=(int32)(*na);
2183	nb[1]=1;
2184	}
2185	else if (*na>-1.0)
2186	{
2187	nb[0]=-(int32)((-na)0x7FFFFFFF);
2188	nb[1]=0x7FFFFFFF;
2189	}
2190	else
2191	{
2192	nb[0]=-0x7FFFFFFF;
2193	nb[1]=(int32)(0x7FFFFFFF/(-*na));
2194	}
2195	}
2196	else
2197	{
2198	if (na==(int32)(na))
2199	{
2200	nb[0]=(int32)(*na);
2201	nb[1]=1;
2202	}
2203	else if (*na<1.0)
2204	{
2205	nb[0]=(int32)((na)0x7FFFFFFF);
2206	nb[1]=0x7FFFFFFF;
2207	}
2208	else
2209	{
2210	nb[0]=0x7FFFFFFF;
2211	nb[1]=(int32)(0x7FFFFFFF/(*na));
2212	}
2213	}
2214	}
2215	if (tif->tif_flags&TIFF_SWAB0x00080)
2216	TIFFSwabArrayOfLong((uint32)m,count2);
2217	o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SRATIONAL,count,count*8,&m[0]);
2218	_TIFFfree(m);
2219	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)((sizeof(float)==4) ? (void) (0) : __assert_fail ("sizeof(float)==4" , "tif_dirwrite.c", 2227, __PRETTY_FUNCTION__));
2228	m=value;
2229	TIFFCvtNativeToIEEEFloat(tif,1,&m);
2230	if (tif->tif_flags&TIFF_SWAB0x00080)
2231	TIFFSwabFloat(&m);
2232	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,1,4,&m));
2233	}
2234	#endif
2235
2236	static int
2237	TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value)
2238	{
2239	assert(count<0x40000000)((count<0x40000000) ? (void) (0) : __assert_fail ("count<0x40000000" , "tif_dirwrite.c", 2239, __PRETTY_FUNCTION__));
2240	assert(sizeof(float)==4)((sizeof(float)==4) ? (void) (0) : __assert_fail ("sizeof(float)==4" , "tif_dirwrite.c", 2240, __PRETTY_FUNCTION__));
2241	TIFFCvtNativeToIEEEFloat(tif,count,&value);
2242	if (tif->tif_flags&TIFF_SWAB0x00080)
2243	TIFFSwabArrayOfFloat(value,count);
2244	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)((sizeof(double)==8) ? (void) (0) : __assert_fail ("sizeof(double)==8" , "tif_dirwrite.c", 2252, __PRETTY_FUNCTION__));
2253	m=value;
2254	TIFFCvtNativeToIEEEDouble(tif,1,&m);
2255	if (tif->tif_flags&TIFF_SWAB0x00080)
2256	TIFFSwabDouble(&m);
2257	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,1,8,&m));
2258	}
2259	#endif
2260
2261	static int
2262	TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value)
2263	{
2264	assert(count<0x20000000)((count<0x20000000) ? (void) (0) : __assert_fail ("count<0x20000000" , "tif_dirwrite.c", 2264, __PRETTY_FUNCTION__));
2265	assert(sizeof(double)==8)((sizeof(double)==8) ? (void) (0) : __assert_fail ("sizeof(double)==8" , "tif_dirwrite.c", 2265, __PRETTY_FUNCTION__));
2266	TIFFCvtNativeToIEEEDouble(tif,count,&value);
2267	if (tif->tif_flags&TIFF_SWAB0x00080)
2268	TIFFSwabArrayOfDouble(value,count);
2269	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,count,count*8,value));
2270	}
2271
2272	static int
2273	TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value)
2274	{
2275	assert(count<0x40000000)((count<0x40000000) ? (void) (0) : __assert_fail ("count<0x40000000" , "tif_dirwrite.c", 2275, __PRETTY_FUNCTION__));
2276	assert(sizeof(uint32)==4)((sizeof(uint32)==4) ? (void) (0) : __assert_fail ("sizeof(uint32)==4" , "tif_dirwrite.c", 2276, __PRETTY_FUNCTION__));
2277	if (tif->tif_flags&TIFF_SWAB0x00080)
2278	TIFFSwabArrayOfLong(value,count);
2279	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD,count,count*4,value));
2280	}
2281
2282	static int
2283	TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value)
2284	{
2285	assert(count<0x20000000)((count<0x20000000) ? (void) (0) : __assert_fail ("count<0x20000000" , "tif_dirwrite.c", 2285, __PRETTY_FUNCTION__));
2286	assert(sizeof(uint64)==8)((sizeof(uint64)==8) ? (void) (0) : __assert_fail ("sizeof(uint64)==8" , "tif_dirwrite.c", 2286, __PRETTY_FUNCTION__));
2287	assert(tif->tif_flags&TIFF_BIGTIFF)((tif->tif_flags&0x80000) ? (void) (0) : __assert_fail ("tif->tif_flags&0x80000", "tif_dirwrite.c", 2287, __PRETTY_FUNCTION__ ));
2288	if (tif->tif_flags&TIFF_SWAB0x00080)
2289	TIFFSwabArrayOfLong8(value,count);
2290	return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD8,count,count*8,value));
2291	}
2292
2293	static int
2294	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	m=0;
2299	while (m<(*ndir))
2300	{
2301	assert(dir[m].tdir_tag!=tag)((dir[m].tdir_tag!=tag) ? (void) (0) : __assert_fail ("dir[m].tdir_tag!=tag" , "tif_dirwrite.c", 2301, __PRETTY_FUNCTION__));
2302	if (dir[m].tdir_tag>tag)
2303	break;
2304	m++;
2305	}
2306	if (m<(*ndir))
2307	{
2308	uint32 n;
2309	for (n=*ndir; n>m; n--)
2310	dir[n]=dir[n-1];
2311	}
2312	dir[m].tdir_tag=tag;
2313	dir[m].tdir_type=datatype;
2314	dir[m].tdir_count=count;
2315	dir[m].tdir_offset.toff_long8 = 0;
2316	if (datalength<=((tif->tif_flags&TIFF_BIGTIFF0x80000)?0x8U:0x4U))
2317	_TIFFmemcpy(&dir[m].tdir_offset,data,datalength);
2318	else
2319	{
2320	uint64 na,nb;
2321	na=tif->tif_dataoff;
2322	nb=na+datalength;
2323	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2324	nb=(uint32)nb;
2325	if ((nb<na)\|\|(nb<datalength))
2326	{
2327	TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded");
2328	return(0);
2329	}
2330	if (!SeekOK(tif,na)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((na )),(0)))==(na)))
2331	{
2332	TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data");
2333	return(0);
2334	}
2335	assert(datalength<0x80000000UL)((datalength<0x80000000UL) ? (void) (0) : __assert_fail ("datalength<0x80000000UL" , "tif_dirwrite.c", 2335, __PRETTY_FUNCTION__));
2336	if (!WriteOK(tif,data,(tmsize_t)datalength)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((data )),(((tmsize_t)datalength))))==((tmsize_t)datalength)))
2337	{
2338	TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data");
2339	return(0);
2340	}
2341	tif->tif_dataoff=nb;
2342	if (tif->tif_dataoff&1)
2343	tif->tif_dataoff++;
2344	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2345	{
2346	uint32 o;
2347	o=(uint32)na;
2348	if (tif->tif_flags&TIFF_SWAB0x00080)
2349	TIFFSwabLong(&o);
2350	_TIFFmemcpy(&dir[m].tdir_offset,&o,4);
2351	}
2352	else
2353	{
2354	dir[m].tdir_offset.toff_long8 = na;
2355	if (tif->tif_flags&TIFF_SWAB0x00080)
2356	TIFFSwabLong8(&dir[m].tdir_offset.toff_long8);
2357	}
2358	}
2359	(*ndir)++;
2360	return(1);
2361	}
2362
2363	/*
2364	* Link the current directory into the directory chain for the file.
2365	*/
2366	static int
2367	TIFFLinkDirectory(TIFF* tif)
2368	{
2369	static const char module[] = "TIFFLinkDirectory";
2370
2371	tif->tif_diroff = (TIFFSeekFile(tif,0,SEEK_END)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(0),(2)))+1) &~ 1;
2372
2373	/*
2374	* Handle SubIFDs
2375	*/
2376	if (tif->tif_flags & TIFF_INSUBIFD0x02000)
2377	{
2378	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2379	{
2380	uint32 m;
2381	m = (uint32)tif->tif_diroff;
2382	if (tif->tif_flags & TIFF_SWAB0x00080)
2383	TIFFSwabLong(&m);
2384	(void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(tif-> tif_subifdoff),(0)));
2385	if (!WriteOK(tif, &m, 4)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((4))))==(4))) {
2386	TIFFErrorExt(tif->tif_clientdata, module,
2387	"Error writing SubIFD directory link");
2388	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	if (--tif->tif_nsubifd)
2396	tif->tif_subifdoff += 4;
2397	else
2398	tif->tif_flags &= ~TIFF_INSUBIFD0x02000;
2399	return (1);
2400	}
2401	else
2402	{
2403	uint64 m;
2404	m = tif->tif_diroff;
2405	if (tif->tif_flags & TIFF_SWAB0x00080)
2406	TIFFSwabLong8(&m);
2407	(void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(tif-> tif_subifdoff),(0)));
2408	if (!WriteOK(tif, &m, 8)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((8))))==(8))) {
2409	TIFFErrorExt(tif->tif_clientdata, module,
2410	"Error writing SubIFD directory link");
2411	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	if (--tif->tif_nsubifd)
2419	tif->tif_subifdoff += 8;
2420	else
2421	tif->tif_flags &= ~TIFF_INSUBIFD0x02000;
2422	return (1);
2423	}
2424	}
2425
2426	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2427	{
2428	uint32 m;
2429	uint32 nextdir;
2430	m = (uint32)(tif->tif_diroff);
2431	if (tif->tif_flags & TIFF_SWAB0x00080)
2432	TIFFSwabLong(&m);
2433	if (tif->tif_header.classic.tiff_diroff == 0) {
2434	/*
2435	* First directory, overwrite offset in header.
2436	*/
2437	tif->tif_header.classic.tiff_diroff = (uint32) tif->tif_diroff;
2438	(void) TIFFSeekFile(tif,4, SEEK_SET)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(4),(0)));
2439	if (!WriteOK(tif, &m, 4)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((4))))==(4))) {
2440	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
2441	"Error writing TIFF header");
2442	return (0);
2443	}
2444	return (1);
2445	}
2446	/*
2447	* Not the first directory, search to the last and append.
2448	*/
2449	nextdir = tif->tif_header.classic.tiff_diroff;
2450	while(1) {
2451	uint16 dircount;
2452	uint32 nextnextdir;
2453
2454	if (!SeekOK(tif, nextdir)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((nextdir )),(0)))==(nextdir)) \|\|
2455	!ReadOK(tif, &dircount, 2)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& dircount)),((2))))==(2))) {
2456	TIFFErrorExt(tif->tif_clientdata, module,
2457	"Error fetching directory count");
2458	return (0);
2459	}
2460	if (tif->tif_flags & TIFF_SWAB0x00080)
2461	TIFFSwabShort(&dircount);
2462	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount12),(0)))
2463	nextdir+2+dircount12, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount*12),(0)));
2464	if (!ReadOK(tif, &nextnextdir, 4)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& nextnextdir)),((4))))==(4))) {
2465	TIFFErrorExt(tif->tif_clientdata, module,
2466	"Error fetching directory link");
2467	return (0);
2468	}
2469	if (tif->tif_flags & TIFF_SWAB0x00080)
2470	TIFFSwabLong(&nextnextdir);
2471	if (nextnextdir==0)
2472	{
2473	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount12),(0)))
2474	nextdir+2+dircount12, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 2+dircount*12),(0)));
2475	if (!WriteOK(tif, &m, 4)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((4))))==(4))) {
2476	TIFFErrorExt(tif->tif_clientdata, module,
2477	"Error writing directory link");
2478	return (0);
2479	}
2480	break;
2481	}
2482	nextdir=nextnextdir;
2483	}
2484	}
2485	else
2486	{
2487	uint64 m;
2488	uint64 nextdir;
2489	m = tif->tif_diroff;
2490	if (tif->tif_flags & TIFF_SWAB0x00080)
2491	TIFFSwabLong8(&m);
2492	if (tif->tif_header.big.tiff_diroff == 0) {
2493	/*
2494	* First directory, overwrite offset in header.
2495	*/
2496	tif->tif_header.big.tiff_diroff = tif->tif_diroff;
2497	(void) TIFFSeekFile(tif,8, SEEK_SET)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(8),(0)));
2498	if (!WriteOK(tif, &m, 8)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((8))))==(8))) {
2499	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
2500	"Error writing TIFF header");
2501	return (0);
2502	}
2503	return (1);
2504	}
2505	/*
2506	* Not the first directory, search to the last and append.
2507	*/
2508	nextdir = tif->tif_header.big.tiff_diroff;
2509	while(1) {
2510	uint64 dircount64;
2511	uint16 dircount;
2512	uint64 nextnextdir;
2513
2514	if (!SeekOK(tif, nextdir)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((nextdir )),(0)))==(nextdir)) \|\|
2515	!ReadOK(tif, &dircount64, 8)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& dircount64)),((8))))==(8))) {
2516	TIFFErrorExt(tif->tif_clientdata, module,
2517	"Error fetching directory count");
2518	return (0);
2519	}
2520	if (tif->tif_flags & TIFF_SWAB0x00080)
2521	TIFFSwabLong8(&dircount64);
2522	if (dircount64>0xFFFF)
2523	{
2524	TIFFErrorExt(tif->tif_clientdata, module,
2525	"Sanity check on tag count failed, likely corrupt TIFF");
2526	return (0);
2527	}
2528	dircount=(uint16)dircount64;
2529	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount20),(0)))
2530	nextdir+8+dircount20, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount*20),(0)));
2531	if (!ReadOK(tif, &nextnextdir, 8)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& nextnextdir)),((8))))==(8))) {
2532	TIFFErrorExt(tif->tif_clientdata, module,
2533	"Error fetching directory link");
2534	return (0);
2535	}
2536	if (tif->tif_flags & TIFF_SWAB0x00080)
2537	TIFFSwabLong8(&nextnextdir);
2538	if (nextnextdir==0)
2539	{
2540	(void) TIFFSeekFile(tif,(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount20),(0)))
2541	nextdir+8+dircount20, SEEK_SET)(((tif)->tif_seekproc)((tif)->tif_clientdata,(nextdir+ 8+dircount*20),(0)));
2542	if (!WriteOK(tif, &m, 8)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((& m)),((8))))==(8))) {
2543	TIFFErrorExt(tif->tif_clientdata, module,
2544	"Error writing directory link");
2545	return (0);
2546	}
2547	break;
2548	}
2549	nextdir=nextnextdir;
2550	}
2551	}
2552	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	_TIFFRewriteField(TIFF* tif, uint16 tag, TIFFDataType in_datatype,
2570	tmsize_t count, void* data)
2571	{
2572	static const char module[] = "TIFFResetField";
2573	const TIFFField* fip = NULL((void*)0);
2574	uint16 dircount;
2575	tmsize_t dirsize;
2576	uint8 direntry_raw[20];
2577	uint16 entry_tag = 0;
2578	uint16 entry_type = 0;
2579	uint64 entry_count = 0;
2580	uint64 entry_offset = 0;
2581	int value_in_entry = 0;
2582	uint64 read_offset;
2583	uint8 buf_to_write = NULL((void)0);
2584	TIFFDataType datatype;
2585
2586	/* -------------------------------------------------------------------- */
2587	/* Find field definition. */
2588	/* -------------------------------------------------------------------- */
2589	fip = TIFFFindField(tif, tag, TIFF_ANYTIFF_NOTYPE);
	Value stored to 'fip' is never read
2590
2591	/* -------------------------------------------------------------------- */
2592	/* Do some checking this is a straight forward case. */
2593	/* -------------------------------------------------------------------- */
2594	if( isMapped(tif)(((tif)->tif_flags & 0x00800) != 0) )
2595	{
2596	TIFFErrorExt( tif->tif_clientdata, module,
2597	"Memory mapped files not currently supported for this operation." );
2598	return 0;
2599	}
2600
2601	if( tif->tif_diroff == 0 )
2602	{
2603	TIFFErrorExt( tif->tif_clientdata, module,
2604	"Attempt to reset field on directory not already on disk." );
2605	return 0;
2606	}
2607
2608	/* -------------------------------------------------------------------- */
2609	/* Read the directory entry count. */
2610	/* -------------------------------------------------------------------- */
2611	if (!SeekOK(tif, tif->tif_diroff)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((tif ->tif_diroff)),(0)))==(tif->tif_diroff))) {
2612	TIFFErrorExt(tif->tif_clientdata, module,
2613	"%s: Seek error accessing TIFF directory",
2614	tif->tif_name);
2615	return 0;
2616	}
2617
2618	read_offset = tif->tif_diroff;
2619
2620	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2621	{
2622	if (!ReadOK(tif, &dircount, sizeof (uint16))(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& dircount)),((sizeof (uint16)))))==(sizeof (uint16)))) {
2623	TIFFErrorExt(tif->tif_clientdata, module,
2624	"%s: Can not read TIFF directory count",
2625	tif->tif_name);
2626	return 0;
2627	}
2628	if (tif->tif_flags & TIFF_SWAB0x00080)
2629	TIFFSwabShort(&dircount);
2630	dirsize = 12;
2631	read_offset += 2;
2632	} else {
2633	uint64 dircount64;
2634	if (!ReadOK(tif, &dircount64, sizeof (uint64))(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((& dircount64)),((sizeof (uint64)))))==(sizeof (uint64)))) {
2635	TIFFErrorExt(tif->tif_clientdata, module,
2636	"%s: Can not read TIFF directory count",
2637	tif->tif_name);
2638	return 0;
2639	}
2640	if (tif->tif_flags & TIFF_SWAB0x00080)
2641	TIFFSwabLong8(&dircount64);
2642	dircount = (uint16)dircount64;
2643	dirsize = 20;
2644	read_offset += 8;
2645	}
2646
2647	/* -------------------------------------------------------------------- */
2648	/* Read through directory to find target tag. */
2649	/* -------------------------------------------------------------------- */
2650	while( dircount > 0 )
2651	{
2652	if (!ReadOK(tif, direntry_raw, dirsize)(((*((tif))->tif_readproc)(((tif))->tif_clientdata,((direntry_raw )),((dirsize))))==(dirsize))) {
2653	TIFFErrorExt(tif->tif_clientdata, module,
2654	"%s: Can not read TIFF directory entry.",
2655	tif->tif_name);
2656	return 0;
2657	}
2658
2659	memcpy( &entry_tag, direntry_raw + 0, sizeof(uint16) );
2660	if (tif->tif_flags&TIFF_SWAB0x00080)
2661	TIFFSwabShort( &entry_tag );
2662
2663	if( entry_tag == tag )
2664	break;
2665
2666	read_offset += dirsize;
2667	}
2668
2669	if( entry_tag != tag )
2670	{
2671	TIFFErrorExt(tif->tif_clientdata, module,
2672	"%s: Could not find tag %d.",
2673	tif->tif_name, tag );
2674	return 0;
2675	}
2676
2677	/* -------------------------------------------------------------------- */
2678	/* Extract the type, count and offset for this entry. */
2679	/* -------------------------------------------------------------------- */
2680	memcpy( &entry_type, direntry_raw + 2, sizeof(uint16) );
2681	if (tif->tif_flags&TIFF_SWAB0x00080)
2682	TIFFSwabShort( &entry_type );
2683
2684	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2685	{
2686	uint32 value;
2687
2688	memcpy( &value, direntry_raw + 4, sizeof(uint32) );
2689	if (tif->tif_flags&TIFF_SWAB0x00080)
2690	TIFFSwabLong( &value );
2691	entry_count = value;
2692
2693	memcpy( &value, direntry_raw + 8, sizeof(uint32) );
2694	if (tif->tif_flags&TIFF_SWAB0x00080)
2695	TIFFSwabLong( &value );
2696	entry_offset = value;
2697	}
2698	else
2699	{
2700	memcpy( &entry_count, direntry_raw + 4, sizeof(uint64) );
2701	if (tif->tif_flags&TIFF_SWAB0x00080)
2702	TIFFSwabLong8( &entry_count );
2703
2704	memcpy( &entry_offset, direntry_raw + 12, sizeof(uint64) );
2705	if (tif->tif_flags&TIFF_SWAB0x00080)
2706	TIFFSwabLong8( &entry_offset );
2707	}
2708
2709	/* -------------------------------------------------------------------- */
2710	/* What data type do we want to write this as? */
2711	/* -------------------------------------------------------------------- */
2712	if( TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags&TIFF_BIGTIFF0x80000) )
2713	{
2714	if( in_datatype == TIFF_LONG8 )
2715	datatype = TIFF_LONG;
2716	else if( in_datatype == TIFF_SLONG8 )
2717	datatype = TIFF_SLONG;
2718	else if( in_datatype == TIFF_IFD8 )
2719	datatype = TIFF_IFD;
2720	else
2721	datatype = in_datatype;
2722	}
2723	else
2724	datatype = in_datatype;
2725
2726	/* -------------------------------------------------------------------- */
2727	/* Prepare buffer of actual data to write. This includes */
2728	/* swabbing as needed. */
2729	/* -------------------------------------------------------------------- */
2730	buf_to_write =
2731	(uint8 *)_TIFFCheckMalloc(tif, count, TIFFDataWidth(datatype),
2732	"for field buffer.");
2733	if (!buf_to_write)
2734	return 0;
2735
2736	if( datatype == in_datatype )
2737	memcpy( buf_to_write, data, count * TIFFDataWidth(datatype) );
2738	else if( datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8 )
2739	{
2740	tmsize_t i;
2741
2742	for( i = 0; i < count; i++ )
2743	{
2744	((int32 *) buf_to_write)[i] =
2745	(int32) ((int64 *) data)[i];
2746	if( (int64) ((int32 ) buf_to_write)[i] != ((int64 ) data)[i] )
2747	{
2748	_TIFFfree( buf_to_write );
2749	TIFFErrorExt( tif->tif_clientdata, module,
2750	"Value exceeds 32bit range of output type." );
2751	return 0;
2752	}
2753	}
2754	}
2755	else if( (datatype == TIFF_LONG && in_datatype == TIFF_LONG8)
2756	\|\| (datatype == TIFF_IFD && in_datatype == TIFF_IFD8) )
2757	{
2758	tmsize_t i;
2759
2760	for( i = 0; i < count; i++ )
2761	{
2762	((uint32 *) buf_to_write)[i] =
2763	(uint32) ((uint64 *) data)[i];
2764	if( (uint64) ((uint32 ) buf_to_write)[i] != ((uint64 ) data)[i] )
2765	{
2766	_TIFFfree( buf_to_write );
2767	TIFFErrorExt( tif->tif_clientdata, module,
2768	"Value exceeds 32bit range of output type." );
2769	return 0;
2770	}
2771	}
2772	}
2773
2774	if( TIFFDataWidth(datatype) > 1 && (tif->tif_flags&TIFF_SWAB0x00080) )
2775	{
2776	if( TIFFDataWidth(datatype) == 2 )
2777	TIFFSwabArrayOfShort( (uint16 *) buf_to_write, count );
2778	else if( TIFFDataWidth(datatype) == 4 )
2779	TIFFSwabArrayOfLong( (uint32 *) buf_to_write, count );
2780	else if( TIFFDataWidth(datatype) == 8 )
2781	TIFFSwabArrayOfLong8( (uint64 *) buf_to_write, count );
2782	}
2783
2784	/* -------------------------------------------------------------------- */
2785	/* Is this a value that fits into the directory entry? */
2786	/* -------------------------------------------------------------------- */
2787	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2788	{
2789	if( TIFFDataWidth(datatype) * count <= 4 )
2790	{
2791	entry_offset = read_offset + 8;
2792	value_in_entry = 1;
2793	}
2794	}
2795	else
2796	{
2797	if( TIFFDataWidth(datatype) * count <= 8 )
2798	{
2799	entry_offset = read_offset + 12;
2800	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	if( entry_count == (uint64)count && entry_type == (uint16) datatype )
2810	{
2811	if (!SeekOK(tif, entry_offset)(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((entry_offset )),(0)))==(entry_offset))) {
2812	_TIFFfree( buf_to_write );
2813	TIFFErrorExt(tif->tif_clientdata, module,
2814	"%s: Seek error accessing TIFF directory",
2815	tif->tif_name);
2816	return 0;
2817	}
2818	if (!WriteOK(tif, buf_to_write, countTIFFDataWidth(datatype))(((((tif))->tif_writeproc)(((tif))->tif_clientdata,((buf_to_write )),((countTIFFDataWidth(datatype)))))==(countTIFFDataWidth( datatype)))) {
2819	_TIFFfree( buf_to_write );
2820	TIFFErrorExt(tif->tif_clientdata, module,
2821	"Error writing directory link");
2822	return (0);
2823	}
2824
2825	_TIFFfree( buf_to_write );
2826	return 1;
2827	}
2828
2829	/* -------------------------------------------------------------------- */
2830	/* Otherwise, we write the new tag data at the end of the file. */
2831	/* -------------------------------------------------------------------- */
2832	if( !value_in_entry )
2833	{
2834	entry_offset = TIFFSeekFile(tif,0,SEEK_END)((*(tif)->tif_seekproc)((tif)->tif_clientdata,(0),(2)));
2835
2836	if (!WriteOK(tif, buf_to_write, countTIFFDataWidth(datatype))(((((tif))->tif_writeproc)(((tif))->tif_clientdata,((buf_to_write )),((countTIFFDataWidth(datatype)))))==(countTIFFDataWidth( datatype)))) {
2837	_TIFFfree( buf_to_write );
2838	TIFFErrorExt(tif->tif_clientdata, module,
2839	"Error writing directory link");
2840	return (0);
2841	}
2842
2843	_TIFFfree( buf_to_write );
2844	}
2845	else
2846	{
2847	memcpy( &entry_offset, buf_to_write, count*TIFFDataWidth(datatype));
2848	}
2849
2850	/* -------------------------------------------------------------------- */
2851	/* Adjust the directory entry. */
2852	/* -------------------------------------------------------------------- */
2853	entry_type = datatype;
2854	memcpy( direntry_raw + 2, &entry_type, sizeof(uint16) );
2855	if (tif->tif_flags&TIFF_SWAB0x00080)
2856	TIFFSwabShort( (uint16 *) (direntry_raw + 2) );
2857
2858	if (!(tif->tif_flags&TIFF_BIGTIFF0x80000))
2859	{
2860	uint32 value;
2861
2862	value = (uint32) entry_count;
2863	memcpy( direntry_raw + 4, &value, sizeof(uint32) );
2864	if (tif->tif_flags&TIFF_SWAB0x00080)
2865	TIFFSwabLong( (uint32 *) (direntry_raw + 4) );
2866
2867	value = (uint32) entry_offset;
2868	memcpy( direntry_raw + 8, &value, sizeof(uint32) );
2869	if (tif->tif_flags&TIFF_SWAB0x00080)
2870	TIFFSwabLong( (uint32 *) (direntry_raw + 8) );
2871	}
2872	else
2873	{
2874	memcpy( direntry_raw + 4, &entry_count, sizeof(uint64) );
2875	if (tif->tif_flags&TIFF_SWAB0x00080)
2876	TIFFSwabLong8( (uint64 *) (direntry_raw + 4) );
2877
2878	memcpy( direntry_raw + 12, &entry_offset, sizeof(uint64) );
2879	if (tif->tif_flags&TIFF_SWAB0x00080)
2880	TIFFSwabLong8( (uint64 *) (direntry_raw + 12) );
2881	}
2882
2883	/* -------------------------------------------------------------------- */
2884	/* Write the directory entry out to disk. */
2885	/* -------------------------------------------------------------------- */
2886	if (!SeekOK(tif, read_offset )(((*((tif))->tif_seekproc)(((tif))->tif_clientdata,((read_offset )),(0)))==(read_offset))) {
2887	TIFFErrorExt(tif->tif_clientdata, module,
2888	"%s: Seek error accessing TIFF directory",
2889	tif->tif_name);
2890	return 0;
2891	}
2892
2893	if (!WriteOK(tif, direntry_raw,dirsize)(((*((tif))->tif_writeproc)(((tif))->tif_clientdata,((direntry_raw )),((dirsize))))==(dirsize)))
2894	{
2895	TIFFErrorExt(tif->tif_clientdata, module,
2896	"%s: Can not write TIFF directory entry.",
2897	tif->tif_name);
2898	return 0;
2899	}
2900
2901	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	*/