/* $Id: tif_dirwrite.c,v 1.89 2017-08-23 13:33:42 erouault Exp $ */

/*

 * Copyright (c) 1988-1997 Sam Leffler

 * Copyright (c) 1991-1997 Silicon Graphics, Inc.

 *

 * Permission to use, copy, modify, distribute, and sell this software and

 * its documentation for any purpose is hereby granted without fee, provided

 * that (i) the above copyright notices and this permission notice appear in

 * all copies of the software and related documentation, and (ii) the names of

 * Sam Leffler and Silicon Graphics may not be used in any advertising or

 * publicity relating to the software without the specific, prior written

 * permission of Sam Leffler and Silicon Graphics.

 *

 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

 *

 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR

 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

 * OF THIS SOFTWARE.

 */

/*

 * TIFF Library.

 *

 * Directory Write Support Routines.

 */

#include "tiffiop.h"

#include <float.h>

#ifdef HAVE_IEEEFP

#define TIFFCvtNativeToIEEEFloat(tif, n, fp)

#define TIFFCvtNativeToIEEEDouble(tif, n, dp)

#else

extern void TIFFCvtNativeToIEEEFloat(TIFF* tif, uint32 n, float* fp);

extern void TIFFCvtNativeToIEEEDouble(TIFF* tif, uint32 n, double* dp);

#endif

static int TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff);

static int TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value);

#if 0

static int TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);

#endif

static int TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value);

static int TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);

#ifdef notdef

static int TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value);

#endif

static int TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);

#if 0

static int TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value);

#endif

static int TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value);

#if 0

static int TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value);

#endif

static int TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value);

static int TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value);

static int TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value);

#ifdef notdef

static int TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value);

#endif

static int TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value);

#if 0

static int TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value);

#endif

static int TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);

static int TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);

#if 0

static int TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value);

#endif

static int TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value);

#if 0

static int TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value);

#endif

static int TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

#ifdef notdef

static int TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value);

#endif

static int TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value);

static int TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);

static int TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);

static int TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);

#ifdef notdef

static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value);

#endif

static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);

#if 0

static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);

#endif

static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value);

#if 0

static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);

#endif

static int TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);

#ifdef notdef

static int TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

#endif

static int TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);

static int TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

#ifdef notdef

static int TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

#endif

static int TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir);

static int TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir);

static int TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir);

static int TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value);

static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value);

#endif

static int TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value);

#endif

static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value);

static int TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value);

static int TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value);

#endif

static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value);

static int TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value);

static int TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value);

#endif

static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value);

#endif

static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value);

#endif

static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value);

static int TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);

static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);

static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value);

#endif

static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value);

#endif

static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value);

static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value);

static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value);

static int TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data);

static int TIFFLinkDirectory(TIFF*);

/*

 * Write the contents of the current directory

 * to the specified file.  This routine doesn't

 * handle overwriting a directory with auxiliary

 * storage that's been changed.

 */

int

TIFFWriteDirectory(TIFF* tif)

{

	return TIFFWriteDirectorySec(tif,TRUE,TRUE,NULL);

}

/*

 * Similar to TIFFWriteDirectory(), writes the directory out

 * but leaves all data structures in memory so that it can be

 * written again.  This will make a partially written TIFF file

 * readable before it is successfully completed/closed.

 */

int

TIFFCheckpointDirectory(TIFF* tif)

{

	int rc;

	/* Setup the strips arrays, if they haven't already been. */

	if (tif->tif_dir.td_stripoffset == NULL)

	    (void) TIFFSetupStrips(tif);

	rc = TIFFWriteDirectorySec(tif,TRUE,FALSE,NULL);

	(void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));

	return rc;

}

int

TIFFWriteCustomDirectory(TIFF* tif, uint64* pdiroff)

{

	return TIFFWriteDirectorySec(tif,FALSE,FALSE,pdiroff);

}

/*

 * Similar to TIFFWriteDirectory(), but if the directory has already

 * been written once, it is relocated to the end of the file, in case it

 * has changed in size.  Note that this will result in the loss of the

 * previously used directory space. 

 */ 

int

TIFFRewriteDirectory( TIFF *tif )

{

	static const char module[] = "TIFFRewriteDirectory";

	/* We don't need to do anything special if it hasn't been written. */

	if( tif->tif_diroff == 0 )

		return TIFFWriteDirectory( tif );

	/*

	 * Find and zero the pointer to this directory, so that TIFFLinkDirectory

	 * will cause it to be added after this directories current pre-link.

	 */

	if (!(tif->tif_flags&TIFF_BIGTIFF))

	{

		if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff)

		{

			tif->tif_header.classic.tiff_diroff = 0;

			tif->tif_diroff = 0;

			TIFFSeekFile(tif,4,SEEK_SET);

			if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4))

			{

				TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

				    "Error updating TIFF header");

				return (0);

			}

		}

		else

		{

			uint32 nextdir;

			nextdir = tif->tif_header.classic.tiff_diroff;

			while(1) {

				uint16 dircount;

				uint32 nextnextdir;

				if (!SeekOK(tif, nextdir) ||

				    !ReadOK(tif, &dircount, 2)) {

					TIFFErrorExt(tif->tif_clientdata, module,

					     "Error fetching directory count");

					return (0);

				}

				if (tif->tif_flags & TIFF_SWAB)

					TIFFSwabShort(&dircount);

				(void) TIFFSeekFile(tif,

				    nextdir+2+dircount*12, SEEK_SET);

				if (!ReadOK(tif, &nextnextdir, 4)) {

					TIFFErrorExt(tif->tif_clientdata, module,

					     "Error fetching directory link");

					return (0);

				}

				if (tif->tif_flags & TIFF_SWAB)

					TIFFSwabLong(&nextnextdir);

				if (nextnextdir==tif->tif_diroff)

				{

					uint32 m;

					m=0;

					(void) TIFFSeekFile(tif,

					    nextdir+2+dircount*12, SEEK_SET);

					if (!WriteOK(tif, &m, 4)) {

						TIFFErrorExt(tif->tif_clientdata, module,

						     "Error writing directory link");

						return (0);

					}

					tif->tif_diroff=0;

					break;

				}

				nextdir=nextnextdir;

			}

		}

	}

	else

	{

		if (tif->tif_header.big.tiff_diroff == tif->tif_diroff)

		{

			tif->tif_header.big.tiff_diroff = 0;

			tif->tif_diroff = 0;

			TIFFSeekFile(tif,8,SEEK_SET);

			if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8))

			{

				TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

				    "Error updating TIFF header");

				return (0);

			}

		}

		else

		{

			uint64 nextdir;

			nextdir = tif->tif_header.big.tiff_diroff;

			while(1) {

				uint64 dircount64;

				uint16 dircount;

				uint64 nextnextdir;

				if (!SeekOK(tif, nextdir) ||

				    !ReadOK(tif, &dircount64, 8)) {

					TIFFErrorExt(tif->tif_clientdata, module,

					     "Error fetching directory count");

					return (0);

				}

				if (tif->tif_flags & TIFF_SWAB)

					TIFFSwabLong8(&dircount64);

				if (dircount64>0xFFFF)

				{

					TIFFErrorExt(tif->tif_clientdata, module,

					     "Sanity check on tag count failed, likely corrupt TIFF");

					return (0);

				}

				dircount=(uint16)dircount64;

				(void) TIFFSeekFile(tif,

				    nextdir+8+dircount*20, SEEK_SET);

				if (!ReadOK(tif, &nextnextdir, 8)) {

					TIFFErrorExt(tif->tif_clientdata, module,

					     "Error fetching directory link");

					return (0);

				}

				if (tif->tif_flags & TIFF_SWAB)

					TIFFSwabLong8(&nextnextdir);

				if (nextnextdir==tif->tif_diroff)

				{

					uint64 m;

					m=0;

					(void) TIFFSeekFile(tif,

					    nextdir+8+dircount*20, SEEK_SET);

					if (!WriteOK(tif, &m, 8)) {

						TIFFErrorExt(tif->tif_clientdata, module,

						     "Error writing directory link");

						return (0);

					}

					tif->tif_diroff=0;

					break;

				}

				nextdir=nextnextdir;

			}

		}

	}

	/*

	 * Now use TIFFWriteDirectory() normally.

	 */

	return TIFFWriteDirectory( tif );

}

static int

TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff)

{

	static const char module[] = "TIFFWriteDirectorySec";

	uint32 ndir;

	TIFFDirEntry* dir;

	uint32 dirsize;

	void* dirmem;

	uint32 m;

	if (tif->tif_mode == O_RDONLY)

		return (1);

        _TIFFFillStriles( tif );

	/*

	 * Clear write state so that subsequent images with

	 * different characteristics get the right buffers

	 * setup for them.

	 */

	if (imagedone)

	{

		if (tif->tif_flags & TIFF_POSTENCODE)

		{

			tif->tif_flags &= ~TIFF_POSTENCODE;

			if (!(*tif->tif_postencode)(tif))

			{

				TIFFErrorExt(tif->tif_clientdata,module,

				    "Error post-encoding before directory write");

				return (0);

			}

		}

		(*tif->tif_close)(tif);       /* shutdown encoder */

		/*

		 * Flush any data that might have been written

		 * by the compression close+cleanup routines.  But

                 * be careful not to write stuff if we didn't add data

                 * in the previous steps as the "rawcc" data may well be

                 * a previously read tile/strip in mixed read/write mode.

		 */

		if (tif->tif_rawcc > 0 

		    && (tif->tif_flags & TIFF_BEENWRITING) != 0 )

		{

		    if( !TIFFFlushData1(tif) )

                    {

			TIFFErrorExt(tif->tif_clientdata, module,

			    "Error flushing data before directory write");

			return (0);

                    }

		}

		if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)

		{

			_TIFFfree(tif->tif_rawdata);

			tif->tif_rawdata = NULL;

			tif->tif_rawcc = 0;

			tif->tif_rawdatasize = 0;

                        tif->tif_rawdataoff = 0;

                        tif->tif_rawdataloaded = 0;

		}

		tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);

	}

	dir=NULL;

	dirmem=NULL;

	dirsize=0;

	while (1)

	{

		ndir=0;

		if (isimage)

		{

			if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS))

			{

				if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH,tif->tif_dir.td_imagewidth))

					goto bad;

				if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH,tif->tif_dir.td_imagelength))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS))

			{

				if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILEWIDTH,tif->tif_dir.td_tilewidth))

					goto bad;

				if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH,tif->tif_dir.td_tilelength))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_RESOLUTION))

			{

				if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION,tif->tif_dir.td_xresolution))

					goto bad;

				if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION,tif->tif_dir.td_yresolution))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_POSITION))

			{

				if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XPOSITION,tif->tif_dir.td_xposition))

					goto bad;

				if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YPOSITION,tif->tif_dir.td_yposition))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_SUBFILETYPE))

			{

				if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_SUBFILETYPE,tif->tif_dir.td_subfiletype))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))

			{

				if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE,tif->tif_dir.td_bitspersample))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_COMPRESSION))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_COMPRESSION,tif->tif_dir.td_compression))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PHOTOMETRIC,tif->tif_dir.td_photometric))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_THRESHHOLDING))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING,tif->tif_dir.td_threshholding))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_FILLORDER))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_FILLORDER,tif->tif_dir.td_fillorder))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_ORIENTATION))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_ORIENTATION,tif->tif_dir.td_orientation))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL,tif->tif_dir.td_samplesperpixel))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP))

			{

				if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP,tif->tif_dir.td_rowsperstrip))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))

			{

				if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE,tif->tif_dir.td_minsamplevalue))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))

			{

				if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE,tif->tif_dir.td_maxsamplevalue))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_PLANARCONFIG))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG,tif->tif_dir.td_planarconfig))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT,tif->tif_dir.td_resolutionunit))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_PAGENUMBER))

			{

				if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER,2,&tif->tif_dir.td_pagenumber[0]))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_STRIPBYTECOUNTS))

			{

				if (!isTiled(tif))

				{

					if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount))

						goto bad;

				}

				else

				{

					if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount))

						goto bad;

				}

			}

			if (TIFFFieldSet(tif,FIELD_STRIPOFFSETS))

			{

				if (!isTiled(tif))

				{

                    /* td_stripoffset might be NULL in an odd OJPEG case. See

                     *  tif_dirread.c around line 3634.

                     * XXX: OJPEG hack.

                     * If a) compression is OJPEG, b) it's not a tiled TIFF,

                     * and c) the number of strips is 1,

                     * then we tolerate the absence of stripoffsets tag,

                     * because, presumably, all required data is in the

                     * JpegInterchangeFormat stream.

                     * We can get here when using tiffset on such a file.

                     * See http://bugzilla.maptools.org/show_bug.cgi?id=2500

                    */

                    if (tif->tif_dir.td_stripoffset != NULL &&

                        !TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset))

                        goto bad;

				}

				else

				{

					if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset))

						goto bad;

				}

			}

			if (TIFFFieldSet(tif,FIELD_COLORMAP))

			{

				if (!TIFFWriteDirectoryTagColormap(tif,&ndir,dir))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES))

			{

				if (tif->tif_dir.td_extrasamples)

				{

					uint16 na;

					uint16* nb;

					TIFFGetFieldDefaulted(tif,TIFFTAG_EXTRASAMPLES,&na,&nb);

					if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_EXTRASAMPLES,na,nb))

						goto bad;

				}

			}

			if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT))

			{

				if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT,tif->tif_dir.td_sampleformat))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))

			{

				if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))

			{

				if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))

			{

				if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_IMAGEDEPTH,tif->tif_dir.td_imagedepth))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_TILEDEPTH))

			{

				if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_TILEDEPTH,tif->tif_dir.td_tiledepth))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))

			{

				if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS,2,&tif->tif_dir.td_halftonehints[0]))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))

			{

				if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING,2,&tif->tif_dir.td_ycbcrsubsampling[0]))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING))

			{

				if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING,tif->tif_dir.td_ycbcrpositioning))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE))

			{

				if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE,6,tif->tif_dir.td_refblackwhite))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION))

			{

				if (!TIFFWriteDirectoryTagTransferfunction(tif,&ndir,dir))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_INKNAMES))

			{

				if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames))

					goto bad;

			}

			if (TIFFFieldSet(tif,FIELD_SUBIFD))

			{

				if (!TIFFWriteDirectoryTagSubifd(tif,&ndir,dir))

					goto bad;

			}

			{

				uint32 n;

				for (n=0; n<tif->tif_nfields; n++) {

					const TIFFField* o;

					o = tif->tif_fields[n];

					if ((o->field_bit>=FIELD_CODEC)&&(TIFFFieldSet(tif,o->field_bit)))

					{

						switch (o->get_field_type)

						{

							case TIFF_SETGET_ASCII:

								{

									uint32 pa;

									char* pb;

									assert(o->field_type==TIFF_ASCII);

									assert(o->field_readcount==TIFF_VARIABLE);

									assert(o->field_passcount==0);

									TIFFGetField(tif,o->field_tag,&pb;;

									pa=(uint32)(strlen(pb));

									if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,(uint16)o->field_tag,pa,pb))

										goto bad;

								}

								break;

							case TIFF_SETGET_UINT16:

								{

									uint16 p;

									assert(o->field_type==TIFF_SHORT);

									assert(o->field_readcount==1);

									assert(o->field_passcount==0);

									TIFFGetField(tif,o->field_tag,&p);

									if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,(uint16)o->field_tag,p))

										goto bad;

								}

								break;

							case TIFF_SETGET_UINT32:

								{

									uint32 p;

									assert(o->field_type==TIFF_LONG);

									assert(o->field_readcount==1);

									assert(o->field_passcount==0);

									TIFFGetField(tif,o->field_tag,&p);

									if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,(uint16)o->field_tag,p))

										goto bad;

								}

								break;

							case TIFF_SETGET_C32_UINT8:

								{

									uint32 pa;

									void* pb;

									assert(o->field_type==TIFF_UNDEFINED);

									assert(o->field_readcount==TIFF_VARIABLE2);

									assert(o->field_passcount==1);

									TIFFGetField(tif,o->field_tag,&pa,&pb;;

									if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,(uint16)o->field_tag,pa,pb))

										goto bad;

								}

								break;

							default:

								assert(0);   /* we should never get here */

								break;

						}

					}

				}

			}

		}

		for (m=0; m<(uint32)(tif->tif_dir.td_customValueCount); m++)

		{

                        uint16 tag = (uint16)tif->tif_dir.td_customValues[m].info->field_tag;

                        uint32 count = tif->tif_dir.td_customValues[m].count;

			switch (tif->tif_dir.td_customValues[m].info->field_type)

			{

				case TIFF_ASCII:

					if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_UNDEFINED:

					if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_BYTE:

					if (!TIFFWriteDirectoryTagByteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_SBYTE:

					if (!TIFFWriteDirectoryTagSbyteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_SHORT:

					if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_SSHORT:

					if (!TIFFWriteDirectoryTagSshortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_LONG:

					if (!TIFFWriteDirectoryTagLongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_SLONG:

					if (!TIFFWriteDirectoryTagSlongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_LONG8:

					if (!TIFFWriteDirectoryTagLong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_SLONG8:

					if (!TIFFWriteDirectoryTagSlong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_RATIONAL:

					if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_SRATIONAL:

					if (!TIFFWriteDirectoryTagSrationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_FLOAT:

					if (!TIFFWriteDirectoryTagFloatArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_DOUBLE:

					if (!TIFFWriteDirectoryTagDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_IFD:

					if (!TIFFWriteDirectoryTagIfdArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				case TIFF_IFD8:

					if (!TIFFWriteDirectoryTagIfdIfd8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

						goto bad;

					break;

				default:

					assert(0);   /* we should never get here */

					break;

			}

		}

		if (dir!=NULL)

			break;

		dir=_TIFFmalloc(ndir*sizeof(TIFFDirEntry));

		if (dir==NULL)

		{

			TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");

			goto bad;

		}

		if (isimage)

		{

			if ((tif->tif_diroff==0)&&(!TIFFLinkDirectory(tif)))

				goto bad;

		}

		else

			tif->tif_diroff=(TIFFSeekFile(tif,0,SEEK_END)+1)&(~((toff_t)1));

		if (pdiroff!=NULL)

			*pdiroff=tif->tif_diroff;

		if (!(tif->tif_flags&TIFF_BIGTIFF))

			dirsize=2+ndir*12+4;

		else

			dirsize=8+ndir*20+8;

		tif->tif_dataoff=tif->tif_diroff+dirsize;

		if (!(tif->tif_flags&TIFF_BIGTIFF))

			tif->tif_dataoff=(uint32)tif->tif_dataoff;

		if ((tif->tif_dataoff<tif->tif_diroff)||(tif->tif_dataoff<(uint64)dirsize))

		{

			TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded");

			goto bad;

		}

		if (tif->tif_dataoff&1)

			tif->tif_dataoff++;

		if (isimage)

			tif->tif_curdir++;

	}

	if (isimage)

	{

		if (TIFFFieldSet(tif,FIELD_SUBIFD)&&(tif->tif_subifdoff==0))

		{

			uint32 na;

			TIFFDirEntry* nb;

			for (na=0, nb=dir; ; na++, nb++)

			{

				if( na == ndir )

                                {

                                    TIFFErrorExt(tif->tif_clientdata,module,

                                                 "Cannot find SubIFD tag");

                                    goto bad;

                                }

				if (nb->tdir_tag==TIFFTAG_SUBIFD)

					break;

			}

			if (!(tif->tif_flags&TIFF_BIGTIFF))

				tif->tif_subifdoff=tif->tif_diroff+2+na*12+8;

			else

				tif->tif_subifdoff=tif->tif_diroff+8+na*20+12;

		}

	}

	dirmem=_TIFFmalloc(dirsize);

	if (dirmem==NULL)

	{

		TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");

		goto bad;

	}

	if (!(tif->tif_flags&TIFF_BIGTIFF))

	{

		uint8* n;

		uint32 nTmp;

		TIFFDirEntry* o;

		n=dirmem;

		*(uint16*)n=(uint16)ndir;

		if (tif->tif_flags&TIFF_SWAB)

			TIFFSwabShort((uint16*)n);

		n+=2;

		o=dir;

		for (m=0; m

		{

			*(uint16*)n=o->tdir_tag;

			if (tif->tif_flags&TIFF_SWAB)

				TIFFSwabShort((uint16*)n);

			n+=2;

			*(uint16*)n=o->tdir_type;

			if (tif->tif_flags&TIFF_SWAB)

				TIFFSwabShort((uint16*)n);

			n+=2;

			nTmp = (uint32)o->tdir_count;

			_TIFFmemcpy(n,&nTmp,4);

			if (tif->tif_flags&TIFF_SWAB)

				TIFFSwabLong((uint32*)n);

			n+=4;

			/* This is correct. The data has been */

			/* swabbed previously in TIFFWriteDirectoryTagData */

			_TIFFmemcpy(n,&o->tdir_offset,4);

			n+=4;

			o++;

		}

		nTmp = (uint32)tif->tif_nextdiroff;

		if (tif->tif_flags&TIFF_SWAB)

			TIFFSwabLong(&nTmp);

		_TIFFmemcpy(n,&nTmp,4);