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);}intTIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff){	return _TIFFWriteCustomDirectory(tif, pdiroff);}/* * Process tags that are not special cased. */static intTIFFWriteNormalTag(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 voidTIFFSetupShortLong(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 voidTIFFSetupShort(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 intTIFFWritePerSampleShorts(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 intTIFFWritePerSampleAnys(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. */static intTIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir){	uint16 v[2];	TIFFGetField(tif, tag, &v[0], &v[1]);	dir->tdir_tag = (uint16) tag;	dir->tdir_type = (uint16) TIFF_SHORT;	dir->tdir_count = 2;	return (TIFFWriteShortArray(tif, dir, v));}/* * Setup a directory entry for an NxM table of shorts, * where M is known to be 2**bitspersample, and write * the associated indirect data. */static intTIFFWriteShortTable(TIFF* tif,    ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16** table){	uint32 i, off;	dir->tdir_tag = (uint16) tag;	dir->tdir_type = (short) TIFF_SHORT;	/* XXX -- yech, fool TIFFWriteData */	dir->tdir_count = (uint32) (1L<<tif->tif_dir.td_bitspersample);	off = tif->tif_dataoff;	for (i = 0; i < n; i++)		if (!TIFFWriteData(tif, dir, (char *)table[i]))			return (0);	dir->tdir_count *= n;	dir->tdir_offset = off;	return (1);}/* * Write/copy data associated with an ASCII or opaque tag value. */static intTIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp){	if (dir->tdir_count > 4) {		if (!TIFFWriteData(tif, dir, cp))