/* $Id: tif_dirwrite.c,v 1.37.2.7 2010-06-08 18:50:42 bfriesen 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"

#ifdef HAVE_IEEEFP

# define	TIFFCvtNativeToIEEEFloat(tif, n, fp)

# define	TIFFCvtNativeToIEEEDouble(tif, n, dp)

#else

extern	void TIFFCvtNativeToIEEEFloat(TIFF*, uint32, float*);

extern	void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*);

#endif

static	int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*);

static	void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32);

static	void TIFFSetupShort(TIFF*, ttag_t, TIFFDirEntry*, uint16);

static	int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*);

static	int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*);

static	int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*);

static	int TIFFWriteShortTable(TIFF*, ttag_t, TIFFDirEntry*, uint32, uint16**);

static	int TIFFWriteShortArray(TIFF*, TIFFDirEntry*, uint16*);

static	int TIFFWriteLongArray(TIFF *, TIFFDirEntry*, uint32*);

static	int TIFFWriteRationalArray(TIFF *, TIFFDirEntry*, float*);

static	int TIFFWriteFloatArray(TIFF *, TIFFDirEntry*, float*);

static	int TIFFWriteDoubleArray(TIFF *, TIFFDirEntry*, double*);

static	int TIFFWriteByteArray(TIFF*, TIFFDirEntry*, char*);

static	int TIFFWriteAnyArray(TIFF*,

	    TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*);

static	int TIFFWriteTransferFunction(TIFF*, TIFFDirEntry*);

static	int TIFFWriteInkNames(TIFF*, TIFFDirEntry*);

static	int TIFFWriteData(TIFF*, TIFFDirEntry*, char*);

static	int TIFFLinkDirectory(TIFF*);

#define	WriteRationalPair(type, tag1, v1, tag2, v2) {		\

	TIFFWriteRational((tif), (type), (tag1), (dir), (v1))	\

	TIFFWriteRational((tif), (type), (tag2), (dir)+1, (v2))	\

	(dir)++;						\

}

#define	TIFFWriteRational(tif, type, tag, dir, v)		\

	(dir)->tdir_tag = (tag);				\

	(dir)->tdir_type = (type);				\

	(dir)->tdir_count = 1;					\

	if (!TIFFWriteRationalArray((tif), (dir), &(v)))	\

		goto bad;

/*

 * 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.

 */

static int

_TIFFWriteDirectory(TIFF* tif, int done)

{

	uint16 dircount;

	toff_t diroff;

	ttag_t tag;

	uint32 nfields;

	tsize_t dirsize;

	char* data;

	TIFFDirEntry* dir;

	TIFFDirectory* td;

	unsigned long b, fields[FIELD_SETLONGS];

	int fi, nfi;

	if (tif->tif_mode == O_RDONLY)

		return (1);

	/*

	 * Clear write state so that subsequent images with

	 * different characteristics get the right buffers

	 * setup for them.

	 */

	if (done)

	{

		if (tif->tif_flags & TIFF_POSTENCODE) {

			tif->tif_flags &= ~TIFF_POSTENCODE;

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

				TIFFErrorExt(tif->tif_clientdata,

					     tif->tif_name,

				"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.

		 */

		if (tif->tif_rawcc > 0

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

                    && !TIFFFlushData1(tif)) {

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

			    "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_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);

	}

	td = &tif->tif_dir;

	/*

	 * Size the directory so that we can calculate

	 * offsets for the data items that aren't kept

	 * in-place in each field.

	 */

	nfields = 0;

	for (b = 0; b <= FIELD_LAST; b++)

		if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)

			nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);

	nfields += td->td_customValueCount;

	dirsize = nfields * sizeof (TIFFDirEntry);

	data = (char*) _TIFFmalloc(dirsize);

	if (data == NULL) {

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

			     "Cannot write directory, out of space");

		return (0);

	}

	/*

	 * Directory hasn't been placed yet, put

	 * it at the end of the file and link it

	 * into the existing directory structure.

	 */

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

		goto bad;

	tif->tif_dataoff = (toff_t)(

	    tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));

	if (tif->tif_dataoff & 1)

		tif->tif_dataoff++;

	(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);

	tif->tif_curdir++;

	dir = (TIFFDirEntry*) data;

	/*

	 * Setup external form of directory

	 * entries and write data items.

	 */

	_TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));

	/*

	 * Write out ExtraSamples tag only if

	 * extra samples are present in the data.

	 */

	if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) {

		ResetFieldBit(fields, FIELD_EXTRASAMPLES);

		nfields--;

		dirsize -= sizeof (TIFFDirEntry);

	}								/*XXX*/

	for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {

		const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];

		/*

		 * For custom fields, we test to see if the custom field

		 * is set or not.  For normal fields, we just use the

		 * FieldSet test.

		*/

		if( fip->field_bit == FIELD_CUSTOM )

		{

			int ci, is_set = FALSE;

			for( ci = 0; ci < td->td_customValueCount; ci++ )

				is_set |= (td->td_customValues[ci].info == fip);

			if( !is_set )

				continue;

		}

		else if (!FieldSet(fields, fip->field_bit))

			continue;

		/*

		 * Handle other fields.

		 */

		switch (fip->field_bit)

		{

		case FIELD_STRIPOFFSETS:

			/*

			 * We use one field bit for both strip and tile

			 * offsets, and so must be careful in selecting

			 * the appropriate field descriptor (so that tags

			 * are written in sorted order).

			 */

			tag = isTiled(tif) ?

			    TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS;

			if (tag != fip->field_tag)

				continue;

			dir->tdir_tag = (uint16) tag;

			dir->tdir_type = (uint16) TIFF_LONG;

			dir->tdir_count = (uint32) td->td_nstrips;

			if (!TIFFWriteLongArray(tif, dir, td->td_stripoffset))

				goto bad;

			break;

		case FIELD_STRIPBYTECOUNTS:

			/*

			 * We use one field bit for both strip and tile

			 * byte counts, and so must be careful in selecting

			 * the appropriate field descriptor (so that tags

			 * are written in sorted order).

			 */

			tag = isTiled(tif) ?

			    TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS;

			if (tag != fip->field_tag)

				continue;

			dir->tdir_tag = (uint16) tag;

			dir->tdir_type = (uint16) TIFF_LONG;

			dir->tdir_count = (uint32) td->td_nstrips;

			if (!TIFFWriteLongArray(tif, dir, td->td_stripbytecount))

				goto bad;

			break;

		case FIELD_ROWSPERSTRIP:

			TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP,

			    dir, td->td_rowsperstrip);

			break;

		case FIELD_COLORMAP:

			if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir,

			    3, td->td_colormap))

				goto bad;

			break;

		case FIELD_IMAGEDIMENSIONS:

			TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH,

			    dir++, td->td_imagewidth);

			TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH,

			    dir, td->td_imagelength);

			break;

		case FIELD_TILEDIMENSIONS:

			TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH,

			    dir++, td->td_tilewidth);

			TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH,

			    dir, td->td_tilelength);

			break;

		case FIELD_COMPRESSION:

			TIFFSetupShort(tif, TIFFTAG_COMPRESSION,

			    dir, td->td_compression);

			break;

		case FIELD_PHOTOMETRIC:

			TIFFSetupShort(tif, TIFFTAG_PHOTOMETRIC,

			    dir, td->td_photometric);

			break;

		case FIELD_POSITION:

			WriteRationalPair(TIFF_RATIONAL,

			    TIFFTAG_XPOSITION, td->td_xposition,

			    TIFFTAG_YPOSITION, td->td_yposition);

			break;

		case FIELD_RESOLUTION:

			WriteRationalPair(TIFF_RATIONAL,

			    TIFFTAG_XRESOLUTION, td->td_xresolution,

			    TIFFTAG_YRESOLUTION, td->td_yresolution);

			break;

		case FIELD_BITSPERSAMPLE:

		case FIELD_MINSAMPLEVALUE:

		case FIELD_MAXSAMPLEVALUE:

		case FIELD_SAMPLEFORMAT:

			if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir))

				goto bad;

			break;

		case FIELD_SMINSAMPLEVALUE:

		case FIELD_SMAXSAMPLEVALUE:

			if (!TIFFWritePerSampleAnys(tif,

			    _TIFFSampleToTagType(tif), fip->field_tag, dir))

				goto bad;

			break;

		case FIELD_PAGENUMBER:

		case FIELD_HALFTONEHINTS:

		case FIELD_YCBCRSUBSAMPLING:

			if (!TIFFSetupShortPair(tif, fip->field_tag, dir))

				goto bad;

			break;

		case FIELD_INKNAMES:

			if (!TIFFWriteInkNames(tif, dir))

				goto bad;

			break;

		case FIELD_TRANSFERFUNCTION:

			if (!TIFFWriteTransferFunction(tif, dir))

				goto bad;

			break;

		case FIELD_SUBIFD:

			/*

			 * XXX: Always write this field using LONG type

			 * for backward compatibility.

			 */

			dir->tdir_tag = (uint16) fip->field_tag;

			dir->tdir_type = (uint16) TIFF_LONG;

			dir->tdir_count = (uint32) td->td_nsubifd;

			if (!TIFFWriteLongArray(tif, dir, td->td_subifd))

				goto bad;

			/*

			 * Total hack: if this directory includes a SubIFD

			 * tag then force the next <n> directories to be

			 * written as ``sub directories'' of this one.  This

			 * is used to write things like thumbnails and

			 * image masks that one wants to keep out of the

			 * normal directory linkage access mechanism.

			 */

			if (dir->tdir_count > 0) {

				tif->tif_flags |= TIFF_INSUBIFD;

				tif->tif_nsubifd = (uint16) dir->tdir_count;

				if (dir->tdir_count > 1)

					tif->tif_subifdoff = dir->tdir_offset;

				else

					tif->tif_subifdoff = (uint32)(

					      tif->tif_diroff

					    + sizeof (uint16)

					    + ((char*)&dir->tdir_offset-data));

			}

			break;

		default:

			/* XXX: Should be fixed and removed. */

			if (fip->field_tag == TIFFTAG_DOTRANGE) {

				if (!TIFFSetupShortPair(tif, fip->field_tag, dir))

					goto bad;

			}

			else if (!TIFFWriteNormalTag(tif, dir, fip))

				goto bad;

			break;

		}

		dir++;

		if( fip->field_bit != FIELD_CUSTOM )

			ResetFieldBit(fields, fip->field_bit);

	}

	/*

	 * Write directory.

	 */

	dircount = (uint16) nfields;

	diroff = (uint32) tif->tif_nextdiroff;

	if (tif->tif_flags & TIFF_SWAB) {

		/*

		 * The file's byte order is opposite to the

		 * native machine architecture.  We overwrite

		 * the directory information with impunity

		 * because it'll be released below after we

		 * write it to the file.  Note that all the

		 * other tag construction routines assume that

		 * we do this byte-swapping; i.e. they only

		 * byte-swap indirect data.

		 */

		for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {

			TIFFSwabArrayOfShort(&dir->tdir_tag, 2);

			TIFFSwabArrayOfLong(&dir->tdir_count, 2);

		}

		dircount = (uint16) nfields;

		TIFFSwabShort(&dircount);

		TIFFSwabLong(&diroff);

	}

	(void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);

	if (!WriteOK(tif, &dircount, sizeof (dircount))) {

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

			     "Error writing directory count");

		goto bad;

	}

	if (!WriteOK(tif, data, dirsize)) {

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

			     "Error writing directory contents");

		goto bad;

	}

	if (!WriteOK(tif, &diroff, sizeof (uint32))) {

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

			     "Error writing directory link");

		goto bad;

	}

	if (done) {

		TIFFFreeDirectory(tif);

		tif->tif_flags &= ~TIFF_DIRTYDIRECT;

		(*tif->tif_cleanup)(tif);

		/*

		* Reset directory-related state for subsequent

		* directories.

		*/

		TIFFCreateDirectory(tif);

	}

	_TIFFfree(data);

	return (1);

bad:

	_TIFFfree(data);

	return (0);

}

#undef WriteRationalPair

int

TIFFWriteDirectory(TIFF* tif)

{

	return _TIFFWriteDirectory(tif, TRUE);

}

/*

 * 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 = _TIFFWriteDirectory(tif, FALSE);

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

	return rc;

}

static int

_TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)

{

	uint16 dircount;

	uint32 nfields;

	tsize_t dirsize;

	char* data;

	TIFFDirEntry* dir;

	TIFFDirectory* td;

	unsigned long b, fields[FIELD_SETLONGS];

	int fi, nfi;

	if (tif->tif_mode == O_RDONLY)

		return (1);

	td = &tif->tif_dir;

	/*

	 * Size the directory so that we can calculate

	 * offsets for the data items that aren't kept

	 * in-place in each field.

	 */

	nfields = 0;

	for (b = 0; b <= FIELD_LAST; b++)

		if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)

			nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);

	nfields += td->td_customValueCount;

	dirsize = nfields * sizeof (TIFFDirEntry);

	data = (char*) _TIFFmalloc(dirsize);

	if (data == NULL) {

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

			     "Cannot write directory, out of space");

		return (0);

	}

	/*

	 * Put the directory  at the end of the file.

	 */

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

	tif->tif_dataoff = (toff_t)(

	    tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));

	if (tif->tif_dataoff & 1)

		tif->tif_dataoff++;

	(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);

	dir = (TIFFDirEntry*) data;

	/*

	 * Setup external form of directory

	 * entries and write data items.

	 */

	_TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));

	for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {

		const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];

		/*

		 * For custom fields, we test to see if the custom field

		 * is set or not.  For normal fields, we just use the

		 * FieldSet test.

		*/

		if( fip->field_bit == FIELD_CUSTOM )

		{

			int ci, is_set = FALSE;

			for( ci = 0; ci < td->td_customValueCount; ci++ )

				is_set |= (td->td_customValues[ci].info == fip);

			if( !is_set )

				continue;

		}

		else if (!FieldSet(fields, fip->field_bit))

			continue;

		if( fip->field_bit != FIELD_CUSTOM )

			ResetFieldBit(fields, fip->field_bit);

	}

	/*

	 * Write directory.

	 */

	dircount = (uint16) nfields;

	*pdiroff = (uint32) tif->tif_nextdiroff;

	if (tif->tif_flags & TIFF_SWAB) {

		/*

		 * The file's byte order is opposite to the

		 * native machine architecture.  We overwrite

		 * the directory information with impunity

		 * because it'll be released below after we

		 * write it to the file.  Note that all the

		 * other tag construction routines assume that

		 * we do this byte-swapping; i.e. they only

		 * byte-swap indirect data.

		 */

		for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {

			TIFFSwabArrayOfShort(&dir->tdir_tag, 2);

			TIFFSwabArrayOfLong(&dir->tdir_count, 2);

		}

		dircount = (uint16) nfields;

		TIFFSwabShort(&dircount);

		TIFFSwabLong(pdiroff);

	}

	(void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);

	if (!WriteOK(tif, &dircount, sizeof (dircount))) {

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

			     "Error writing directory count");

		goto bad;

	}

	if (!WriteOK(tif, data, dirsize)) {

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

			     "Error writing directory contents");

		goto bad;

	}

	if (!WriteOK(tif, pdiroff, sizeof (uint32))) {

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

			     "Error writing directory link");

		goto bad;

	}

	_TIFFfree(data);

	return (1);

bad:

	_TIFFfree(data);

	return (0);

}

int

TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)

{

	return _TIFFWriteCustomDirectory(tif, pdiroff);

}

/*

 * Process tags that are not special cased.

 */

static int

TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)

{

	uint16 wc = (uint16) fip->field_writecount;

	uint32 wc2;

	dir->tdir_tag = (uint16) fip->field_tag;

	dir->tdir_type = (uint16) fip->field_type;

	dir->tdir_count = wc;

	switch (fip->field_type) {

	case TIFF_SHORT:

	case TIFF_SSHORT:

		if (fip->field_passcount) {

			uint16* wp;

			if (wc == (uint16) TIFF_VARIABLE2) {

				TIFFGetField(tif, fip->field_tag, &wc2, &wp);

				dir->tdir_count = wc2;

			} else {	/* Assume TIFF_VARIABLE */

				TIFFGetField(tif, fip->field_tag, &wc, &wp);

				dir->tdir_count = wc;

			}

			if (!TIFFWriteShortArray(tif, dir, wp))

				return 0;

		} else {

			if (wc == 1) {

				uint16 sv;

				TIFFGetField(tif, fip->field_tag, &sv;;

				dir->tdir_offset =

					TIFFInsertData(tif, dir->tdir_type, sv);

			} else {

				uint16* wp;

				TIFFGetField(tif, fip->field_tag, &wp);

				if (!TIFFWriteShortArray(tif, dir, wp))

					return 0;

			}

		}

		break;

	case TIFF_LONG:

	case TIFF_SLONG:

	case TIFF_IFD:

		if (fip->field_passcount) {

			uint32* lp;

			if (wc == (uint16) TIFF_VARIABLE2) {

				TIFFGetField(tif, fip->field_tag, &wc2, &lp);

				dir->tdir_count = wc2;

			} else {	/* Assume TIFF_VARIABLE */

				TIFFGetField(tif, fip->field_tag, &wc, &lp);

				dir->tdir_count = wc;

			}

			if (!TIFFWriteLongArray(tif, dir, lp))

				return 0;

		} else {

			if (wc == 1) {

				/* XXX handle LONG->SHORT conversion */

				TIFFGetField(tif, fip->field_tag,

					     &dir->tdir_offset);

			} else {

				uint32* lp;

				TIFFGetField(tif, fip->field_tag, &lp);

				if (!TIFFWriteLongArray(tif, dir, lp))

					return 0;

			}

		}

		break;

	case TIFF_RATIONAL:

	case TIFF_SRATIONAL:

		if (fip->field_passcount) {

			float* fp;

			if (wc == (uint16) TIFF_VARIABLE2) {

				TIFFGetField(tif, fip->field_tag, &wc2, &fp);

				dir->tdir_count = wc2;

			} else {	/* Assume TIFF_VARIABLE */

				TIFFGetField(tif, fip->field_tag, &wc, &fp);

				dir->tdir_count = wc;

			}

			if (!TIFFWriteRationalArray(tif, dir, fp))

				return 0;

		} else {

			if (wc == 1) {

				float fv;

				TIFFGetField(tif, fip->field_tag, &fv;;

				if (!TIFFWriteRationalArray(tif, dir, &fv))

					return 0;

			} else {

				float* fp;

				TIFFGetField(tif, fip->field_tag, &fp);

				if (!TIFFWriteRationalArray(tif, dir, fp))

					return 0;

			}

		}

		break;

	case TIFF_FLOAT:

		if (fip->field_passcount) {

			float* fp;

			if (wc == (uint16) TIFF_VARIABLE2) {

				TIFFGetField(tif, fip->field_tag, &wc2, &fp);

				dir->tdir_count = wc2;

			} else {	/* Assume TIFF_VARIABLE */

				TIFFGetField(tif, fip->field_tag, &wc, &fp);

				dir->tdir_count = wc;

			}

			if (!TIFFWriteFloatArray(tif, dir, fp))

				return 0;

		} else {

			if (wc == 1) {

				float fv;

				TIFFGetField(tif, fip->field_tag, &fv;;

				if (!TIFFWriteFloatArray(tif, dir, &fv))

					return 0;

			} else {

				float* fp;

				TIFFGetField(tif, fip->field_tag, &fp);

				if (!TIFFWriteFloatArray(tif, dir, fp))

					return 0;

			}

		}

		break;

	case TIFF_DOUBLE:

		if (fip->field_passcount) {

			double* dp;

			if (wc == (uint16) TIFF_VARIABLE2) {

				TIFFGetField(tif, fip->field_tag, &wc2, &dp;;

				dir->tdir_count = wc2;

			} else {	/* Assume TIFF_VARIABLE */

				TIFFGetField(tif, fip->field_tag, &wc, &dp;;

				dir->tdir_count = wc;

			}

			if (!TIFFWriteDoubleArray(tif, dir, dp))

				return 0;

		} else {

			if (wc == 1) {

				double dv;

				TIFFGetField(tif, fip->field_tag, &dv;;

				if (!TIFFWriteDoubleArray(tif, dir, &dv))

					return 0;

			} else {

				double* dp;

				TIFFGetField(tif, fip->field_tag, &dp;;

				if (!TIFFWriteDoubleArray(tif, dir, dp))

					return 0;

			}

		}

		break;

	case TIFF_ASCII:

		{ 

                    char* cp;

                    if (fip->field_passcount)

                    {

                        if( wc == (uint16) TIFF_VARIABLE2 )

                            TIFFGetField(tif, fip->field_tag, &wc2, &cp;;

                        else

                            TIFFGetField(tif, fip->field_tag, &wc, &cp;;

                    }

                    else

                        TIFFGetField(tif, fip->field_tag, &cp;;

                    dir->tdir_count = (uint32) (strlen(cp) + 1);

                    if (!TIFFWriteByteArray(tif, dir, cp))

                        return (0);

		}

		break;

        case TIFF_BYTE:

        case TIFF_SBYTE:          

		if (fip->field_passcount) {

			char* cp;

			if (wc == (uint16) TIFF_VARIABLE2) {

				TIFFGetField(tif, fip->field_tag, &wc2, &cp;;

				dir->tdir_count = wc2;

			} else {	/* Assume TIFF_VARIABLE */

				TIFFGetField(tif, fip->field_tag, &wc, &cp;;

				dir->tdir_count = wc;

			}

			if (!TIFFWriteByteArray(tif, dir, cp))

				return 0;

		} else {

			if (wc == 1) {

				char cv;

				TIFFGetField(tif, fip->field_tag, &cv;;

				if (!TIFFWriteByteArray(tif, dir, &cv))

					return 0;

			} else {

				char* cp;

				TIFFGetField(tif, fip->field_tag, &cp;;

				if (!TIFFWriteByteArray(tif, dir, cp))

					return 0;

			}

		}

                break;

	case TIFF_UNDEFINED:

		{ char* cp;

		  if (wc == (unsigned short) TIFF_VARIABLE) {

			TIFFGetField(tif, fip->field_tag, &wc, &cp;;

			dir->tdir_count = wc;

		  } else if (wc == (unsigned short) TIFF_VARIABLE2) {

			TIFFGetField(tif, fip->field_tag, &wc2, &cp;;

			dir->tdir_count = wc2;

		  } else 

			TIFFGetField(tif, fip->field_tag, &cp;;

		  if (!TIFFWriteByteArray(tif, dir, cp))

			return (0);

		}

		break;

        case TIFF_NOTYPE:

                break;

	}

	return (1);

}

/*

 * Setup a directory entry with either a SHORT

 * or LONG type according to the value.

 */

static void

TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v)

{

	dir->tdir_tag = (uint16) tag;

	dir->tdir_count = 1;

	if (v > 0xffffL) {

		dir->tdir_type = (short) TIFF_LONG;

		dir->tdir_offset = v;

	} else {

		dir->tdir_type = (short) TIFF_SHORT;

		dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);

	}

}

/*

 * Setup a SHORT directory entry

 */

static void

TIFFSetupShort(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint16 v)

{

	dir->tdir_tag = (uint16) tag;

	dir->tdir_count = 1;

	dir->tdir_type = (short) TIFF_SHORT;

	dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);

}

#undef MakeShortDirent

#define	NITEMS(x)	(sizeof (x) / sizeof (x[0]))

/*

 * Setup a directory entry that references a

 * samples/pixel array of SHORT values and

 * (potentially) write the associated indirect

 * values.

 */

static int

TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)

{

	uint16 buf[10], v;

	uint16* w = buf;

	uint16 i, samples = tif->tif_dir.td_samplesperpixel;

	int status;

	if (samples > NITEMS(buf)) {

		w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));

		if (w == NULL) {

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

			    "No space to write per-sample shorts");

			return (0);

		}

	}

	TIFFGetField(tif, tag, &v);

	for (i = 0; i < samples; i++)

		w[i] = v;

	dir->tdir_tag = (uint16) tag;

	dir->tdir_type = (uint16) TIFF_SHORT;

	dir->tdir_count = samples;

	status = TIFFWriteShortArray(tif, dir, w);

	if (w != buf)

		_TIFFfree((char*) w);

	return (status);

}

/*

 * Setup a directory entry that references a samples/pixel array of ``type''

 * values and (potentially) write the associated indirect values.  The source

 * data from TIFFGetField() for the specified tag must be returned as double.

 */

static int

TIFFWritePerSampleAnys(TIFF* tif,

    TIFFDataType type, ttag_t tag, TIFFDirEntry* dir)

{

	double buf[10], v;

	double* w = buf;

	uint16 i, samples = tif->tif_dir.td_samplesperpixel;

	int status;

	if (samples > NITEMS(buf)) {

		w = (double*) _TIFFmalloc(samples * sizeof (double));

		if (w == NULL) {

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

			    "No space to write per-sample values");

			return (0);

		}

	}

	TIFFGetField(tif, tag, &v);

	for (i = 0; i < samples; i++)

		w[i] = v;

	status = TIFFWriteAnyArray(tif, type, tag, dir, samples, w);

	if (w != buf)

		_TIFFfree(w);

	return (status);

}

#undef NITEMS

/*

 * Setup a pair of shorts that are returned by

 * value, rather than as a reference to an array.