/* $Id: tif_dir.c,v 1.75.2.5 2010-06-09 21:15:27 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 Tag Get & Set Routines.

 * (and also some miscellaneous stuff)

 */

#include "tiffiop.h"

/*

 * These are used in the backwards compatibility code...

 */

#define DATATYPE_VOID		0       /* !untyped data */

#define DATATYPE_INT		1       /* !signed integer data */

#define DATATYPE_UINT		2       /* !unsigned integer data */

#define DATATYPE_IEEEFP		3       /* !IEEE floating point data */

static void

setByteArray(void** vpp, void* vp, size_t nmemb, size_t elem_size)

{

	if (*vpp)

		_TIFFfree(*vpp), *vpp = 0;

	if (vp) {

		tsize_t	bytes = nmemb * elem_size;

		if (elem_size && bytes / elem_size == nmemb)

			*vpp = (void*) _TIFFmalloc(bytes);

		if (*vpp)

			_TIFFmemcpy(*vpp, vp, bytes);

	}

}

void _TIFFsetByteArray(void** vpp, void* vp, uint32 n)

    { setByteArray(vpp, vp, n, 1); }

void _TIFFsetString(char** cpp, char* cp)

    { setByteArray((void**) cpp, (void*) cp, strlen(cp)+1, 1); }

void _TIFFsetNString(char** cpp, char* cp, uint32 n)

    { setByteArray((void**) cpp, (void*) cp, n, 1); }

void _TIFFsetShortArray(uint16** wpp, uint16* wp, uint32 n)

    { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); }

void _TIFFsetLongArray(uint32** lpp, uint32* lp, uint32 n)

    { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); }

void _TIFFsetFloatArray(float** fpp, float* fp, uint32 n)

    { setByteArray((void**) fpp, (void*) fp, n, sizeof (float)); }

void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n)

    { setByteArray((void**) dpp, (void*) dp, n, sizeof (double)); }

/*

 * Install extra samples information.

 */

static int

setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v)

{

/* XXX: Unassociated alpha data == 999 is a known Corel Draw bug, see below */

#define EXTRASAMPLE_COREL_UNASSALPHA 999 

	uint16* va;

	uint32 i;

	*v = va_arg(ap, uint32);

	if ((uint16) *v > td->td_samplesperpixel)

		return 0;

	va = va_arg(ap, uint16*);

	if (*v > 0 && va == NULL)		/* typically missing param */

		return 0;

	for (i = 0; i < *v; i++) {

		if (va[i] > EXTRASAMPLE_UNASSALPHA) {

			/*

			 * XXX: Corel Draw is known to produce incorrect

			 * ExtraSamples tags which must be patched here if we

			 * want to be able to open some of the damaged TIFF

			 * files: 

			 */

			if (va[i] == EXTRASAMPLE_COREL_UNASSALPHA)

				va[i] = EXTRASAMPLE_UNASSALPHA;

			else

				return 0;

		}

	}

	td->td_extrasamples = (uint16) *v;

	_TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);

	return 1;

#undef EXTRASAMPLE_COREL_UNASSALPHA

}

static uint32

checkInkNamesString(TIFF* tif, uint32 slen, const char* s)

{

	TIFFDirectory* td = &tif->tif_dir;

	uint16 i = td->td_samplesperpixel;

	if (slen > 0) {

		const char* ep = s+slen;

		const char* cp = s;

		for (; i > 0; i--) {

			for (; *cp != '\0'; cp++)

				if (cp >= ep)

					goto bad;

			cp++;				/* skip \0 */

		}

		return (cp-s);

	}

bad:

	TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",

	    "%s: Invalid InkNames value; expecting %d names, found %d",

	    tif->tif_name,

	    td->td_samplesperpixel,

	    td->td_samplesperpixel-i);

	return (0);

}

static int

_TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)

{

	static const char module[] = "_TIFFVSetField";

	TIFFDirectory* td = &tif->tif_dir;

	int status = 1;

	uint32 v32, i, v;

	char* s;

	switch (tag) {

	case TIFFTAG_SUBFILETYPE:

		td->td_subfiletype = va_arg(ap, uint32);

		break;

	case TIFFTAG_IMAGEWIDTH:

		td->td_imagewidth = va_arg(ap, uint32);

		break;

	case TIFFTAG_IMAGELENGTH:

		td->td_imagelength = va_arg(ap, uint32);

		break;

	case TIFFTAG_BITSPERSAMPLE:

		td->td_bitspersample = (uint16) va_arg(ap, int);

		/*

		 * If the data require post-decoding processing to byte-swap

		 * samples, set it up here.  Note that since tags are required

		 * to be ordered, compression code can override this behaviour

		 * in the setup method if it wants to roll the post decoding

		 * work in with its normal work.

		 */

		if (tif->tif_flags & TIFF_SWAB) {

			if (td->td_bitspersample == 16)

				tif->tif_postdecode = _TIFFSwab16BitData;

			else if (td->td_bitspersample == 24)

				tif->tif_postdecode = _TIFFSwab24BitData;

			else if (td->td_bitspersample == 32)

				tif->tif_postdecode = _TIFFSwab32BitData;

			else if (td->td_bitspersample == 64)

				tif->tif_postdecode = _TIFFSwab64BitData;

			else if (td->td_bitspersample == 128) /* two 64's */

				tif->tif_postdecode = _TIFFSwab64BitData;

		}

		break;

	case TIFFTAG_COMPRESSION:

		v = va_arg(ap, uint32) & 0xffff;

		/*

		 * If we're changing the compression scheme, the notify the

		 * previous module so that it can cleanup any state it's

		 * setup.

		 */

		if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {

			if (td->td_compression == v)

				break;

			(*tif->tif_cleanup)(tif);

			tif->tif_flags &= ~TIFF_CODERSETUP;

		}

		/*

		 * Setup new compression routine state.

		 */

		if( (status = TIFFSetCompressionScheme(tif, v)) != 0 )

                    td->td_compression = (uint16) v;

                else

                    status = 0;

		break;

	case TIFFTAG_PHOTOMETRIC:

		td->td_photometric = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_THRESHHOLDING:

		td->td_threshholding = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_FILLORDER:

		v = va_arg(ap, uint32);

		if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)

			goto badvalue;

		td->td_fillorder = (uint16) v;

		break;

	case TIFFTAG_ORIENTATION:

		v = va_arg(ap, uint32);

		if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v)

			goto badvalue;

		else

			td->td_orientation = (uint16) v;

		break;

	case TIFFTAG_SAMPLESPERPIXEL:

		/* XXX should cross check -- e.g. if pallette, then 1 */

		v = va_arg(ap, uint32);

		if (v == 0)

			goto badvalue;

		td->td_samplesperpixel = (uint16) v;

		break;

	case TIFFTAG_ROWSPERSTRIP:

		v32 = va_arg(ap, uint32);

		if (v32 == 0)

			goto badvalue32;

		td->td_rowsperstrip = v32;

		if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {

			td->td_tilelength = v32;

			td->td_tilewidth = td->td_imagewidth;

		}

		break;

	case TIFFTAG_MINSAMPLEVALUE:

		td->td_minsamplevalue = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_MAXSAMPLEVALUE:

		td->td_maxsamplevalue = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_SMINSAMPLEVALUE:

		td->td_sminsamplevalue = va_arg(ap, double);

		break;

	case TIFFTAG_SMAXSAMPLEVALUE:

		td->td_smaxsamplevalue = va_arg(ap, double);

		break;

	case TIFFTAG_XRESOLUTION:

		td->td_xresolution = (float) va_arg(ap, double);

		break;

	case TIFFTAG_YRESOLUTION:

		td->td_yresolution = (float) va_arg(ap, double);

		break;

	case TIFFTAG_PLANARCONFIG:

		v = va_arg(ap, uint32);

		if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)

			goto badvalue;

		td->td_planarconfig = (uint16) v;

		break;

	case TIFFTAG_XPOSITION:

		td->td_xposition = (float) va_arg(ap, double);

		break;

	case TIFFTAG_YPOSITION:

		td->td_yposition = (float) va_arg(ap, double);

		break;

	case TIFFTAG_RESOLUTIONUNIT:

		v = va_arg(ap, uint32);

		if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)

			goto badvalue;

		td->td_resolutionunit = (uint16) v;

		break;

	case TIFFTAG_PAGENUMBER:

		td->td_pagenumber[0] = (uint16) va_arg(ap, int);

		td->td_pagenumber[1] = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_HALFTONEHINTS:

		td->td_halftonehints[0] = (uint16) va_arg(ap, int);

		td->td_halftonehints[1] = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_COLORMAP:

		v32 = (uint32)(1L<<td->td_bitspersample);

		_TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);

		_TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);

		_TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);

		break;

	case TIFFTAG_EXTRASAMPLES:

		if (!setExtraSamples(td, ap, &v))

			goto badvalue;

		break;

	case TIFFTAG_MATTEING:

		td->td_extrasamples = (uint16) (va_arg(ap, int) != 0);

		if (td->td_extrasamples) {

			uint16 sv = EXTRASAMPLE_ASSOCALPHA;

			_TIFFsetShortArray(&td->td_sampleinfo, &sv, 1);

		}

		break;

	case TIFFTAG_TILEWIDTH:

		v32 = va_arg(ap, uint32);

		if (v32 % 16) {

			if (tif->tif_mode != O_RDONLY)

				goto badvalue32;

			TIFFWarningExt(tif->tif_clientdata, tif->tif_name,

				"Nonstandard tile width %d, convert file", v32);

		}

		td->td_tilewidth = v32;

		tif->tif_flags |= TIFF_ISTILED;

		break;

	case TIFFTAG_TILELENGTH:

		v32 = va_arg(ap, uint32);

		if (v32 % 16) {

			if (tif->tif_mode != O_RDONLY)

				goto badvalue32;

			TIFFWarningExt(tif->tif_clientdata, tif->tif_name,

			    "Nonstandard tile length %d, convert file", v32);

		}

		td->td_tilelength = v32;

		tif->tif_flags |= TIFF_ISTILED;

		break;

	case TIFFTAG_TILEDEPTH:

		v32 = va_arg(ap, uint32);

		if (v32 == 0)

			goto badvalue32;

		td->td_tiledepth = v32;

		break;

	case TIFFTAG_DATATYPE:

		v = va_arg(ap, uint32);

		switch (v) {

		case DATATYPE_VOID:	v = SAMPLEFORMAT_VOID;	break;

		case DATATYPE_INT:	v = SAMPLEFORMAT_INT;	break;

		case DATATYPE_UINT:	v = SAMPLEFORMAT_UINT;	break;

		case DATATYPE_IEEEFP:	v = SAMPLEFORMAT_IEEEFP;break;

		default:		goto badvalue;

		}

		td->td_sampleformat = (uint16) v;

		break;

	case TIFFTAG_SAMPLEFORMAT:

		v = va_arg(ap, uint32);

		if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_COMPLEXIEEEFP < v)

			goto badvalue;

		td->td_sampleformat = (uint16) v;

                /*  Try to fix up the SWAB function for complex data. */

                if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT 

                    && td->td_bitspersample == 32

                    && tif->tif_postdecode == _TIFFSwab32BitData )

                    tif->tif_postdecode = _TIFFSwab16BitData;

                else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT 

                          || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP)

                         && td->td_bitspersample == 64

                         && tif->tif_postdecode == _TIFFSwab64BitData )

                    tif->tif_postdecode = _TIFFSwab32BitData;

		break;

	case TIFFTAG_IMAGEDEPTH:

		td->td_imagedepth = va_arg(ap, uint32);

		break;

	case TIFFTAG_SUBIFD:

		if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {

			td->td_nsubifd = (uint16) va_arg(ap, int);

			_TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*),

			    (long) td->td_nsubifd);

		} else {

			TIFFErrorExt(tif->tif_clientdata, module,

				     "%s: Sorry, cannot nest SubIFDs",

				     tif->tif_name);

			status = 0;

		}

		break;

	case TIFFTAG_YCBCRPOSITIONING:

		td->td_ycbcrpositioning = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_YCBCRSUBSAMPLING:

		td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int);

		td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int);

		break;

	case TIFFTAG_TRANSFERFUNCTION:

		v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;

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

			_TIFFsetShortArray(&td->td_transferfunction[i],

			    va_arg(ap, uint16*), 1L<<td->td_bitspersample);

		break;

	case TIFFTAG_REFERENCEBLACKWHITE:

		/* XXX should check for null range */

		_TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6);

		break;

	case TIFFTAG_INKNAMES:

		v = va_arg(ap, uint32);

		s = va_arg(ap, char*);

		v = checkInkNamesString(tif, v, s);

                status = v > 0;

		if( v > 0 ) {

			_TIFFsetNString(&td->td_inknames, s, v);

			td->td_inknameslen = v;

		}

		break;

        default: {

            TIFFTagValue *tv;

            int tv_size, iCustom;

	    const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);

            /*

	     * This can happen if multiple images are open with different

	     * codecs which have private tags.  The global tag information

	     * table may then have tags that are valid for one file but not

	     * the other. If the client tries to set a tag that is not valid

	     * for the image's codec then we'll arrive here.  This

	     * happens, for example, when tiffcp is used to convert between

	     * compression schemes and codec-specific tags are blindly copied.

             */

            if(fip == NULL || fip->field_bit != FIELD_CUSTOM) {

		TIFFErrorExt(tif->tif_clientdata, module,

			     "%s: Invalid %stag \"%s\" (not supported by codec)",

			     tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",

			     fip ? fip->field_name : "Unknown");

		status = 0;

		break;

            }

            /*

             * Find the existing entry for this custom value.

             */

            tv = NULL;

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

		    if (td->td_customValues[iCustom].info->field_tag == tag) {

			    tv = td->td_customValues + iCustom;

			    if (tv->value != NULL) {

				    _TIFFfree(tv->value);

				    tv->value = NULL;

			    }

			    break;

		    }

            }

            /*

             * Grow the custom list if the entry was not found.

             */

            if(tv == NULL) {

		TIFFTagValue	*new_customValues;

		td->td_customValueCount++;

		new_customValues = (TIFFTagValue *)

			_TIFFrealloc(td->td_customValues,

				     sizeof(TIFFTagValue) * td->td_customValueCount);

		if (!new_customValues) {

			TIFFErrorExt(tif->tif_clientdata, module,

		"%s: Failed to allocate space for list of custom values",

				  tif->tif_name);

			status = 0;

			goto end;

		}

		td->td_customValues = new_customValues;

                tv = td->td_customValues + (td->td_customValueCount - 1);

                tv->info = fip;

                tv->value = NULL;

                tv->count = 0;

            }

            /*

             * Set custom value ... save a copy of the custom tag value.

             */

	    tv_size = _TIFFDataSize(fip->field_type);

	    if (tv_size == 0) {

		    status = 0;

		    TIFFErrorExt(tif->tif_clientdata, module,

				 "%s: Bad field type %d for \"%s\"",

				 tif->tif_name, fip->field_type,

				 fip->field_name);

		    goto end;

	    }

            if(fip->field_passcount) {

		    if (fip->field_writecount == TIFF_VARIABLE2)

			tv->count = (uint32) va_arg(ap, uint32);

		    else

			tv->count = (int) va_arg(ap, int);

	    } else if (fip->field_writecount == TIFF_VARIABLE

		       || fip->field_writecount == TIFF_VARIABLE2)

		tv->count = 1;

	    else if (fip->field_writecount == TIFF_SPP)

		tv->count = td->td_samplesperpixel;

	    else

                tv->count = fip->field_writecount;

	    if (fip->field_type == TIFF_ASCII)

		    _TIFFsetString((char **)&tv->value, va_arg(ap, char *));

	    else {

		tv->value = _TIFFCheckMalloc(tif, tv_size, tv->count,

					     "Tag Value");

		if (!tv->value) {

		    status = 0;

		    goto end;

		}

		if ((fip->field_passcount

		    || fip->field_writecount == TIFF_VARIABLE

		    || fip->field_writecount == TIFF_VARIABLE2

		    || fip->field_writecount == TIFF_SPP

		    || tv->count > 1)

		    && fip->field_tag != TIFFTAG_PAGENUMBER

		    && fip->field_tag != TIFFTAG_HALFTONEHINTS

		    && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING

		    && fip->field_tag != TIFFTAG_DOTRANGE) {

                    _TIFFmemcpy(tv->value, va_arg(ap, void *),

				tv->count * tv_size);

		} else {

		    /*

		     * XXX: The following loop required to handle

		     * TIFFTAG_PAGENUMBER, TIFFTAG_HALFTONEHINTS,

		     * TIFFTAG_YCBCRSUBSAMPLING and TIFFTAG_DOTRANGE tags.

		     * These tags are actually arrays and should be passed as

		     * array pointers to TIFFSetField() function, but actually

		     * passed as a list of separate values. This behaviour

		     * must be changed in the future!

		     */

		    int i;

		    char *val = (char *)tv->value;

		    for (i = 0; i < tv->count; i++, val += tv_size) {

			    switch (fip->field_type) {

				case TIFF_BYTE:

				case TIFF_UNDEFINED:

				    {

					uint8 v = (uint8)va_arg(ap, int);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_SBYTE:

				    {

					int8 v = (int8)va_arg(ap, int);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_SHORT:

				    {

					uint16 v = (uint16)va_arg(ap, int);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_SSHORT:

				    {

					int16 v = (int16)va_arg(ap, int);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_LONG:

				case TIFF_IFD:

				    {

					uint32 v = va_arg(ap, uint32);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_SLONG:

				    {

					int32 v = va_arg(ap, int32);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_RATIONAL:

				case TIFF_SRATIONAL:

				case TIFF_FLOAT:

				    {

					float v = (float)va_arg(ap, double);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				case TIFF_DOUBLE:

				    {

					double v = va_arg(ap, double);

					_TIFFmemcpy(val, &v, tv_size);

				    }

				    break;

				default:

				    _TIFFmemset(val, 0, tv_size);

				    status = 0;

				    break;

			    }

		    }

		}

	    }

          }

	}

	if (status) {

		TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);

		tif->tif_flags |= TIFF_DIRTYDIRECT;

	}

end:

	va_end(ap);

	return (status);

badvalue:

	TIFFErrorExt(tif->tif_clientdata, module,

		     "%s: Bad value %d for \"%s\" tag",

		     tif->tif_name, v,

		     _TIFFFieldWithTag(tif, tag)->field_name);

	va_end(ap);

	return (0);

badvalue32:

	TIFFErrorExt(tif->tif_clientdata, module,

		     "%s: Bad value %u for \"%s\" tag",

		     tif->tif_name, v32,

		     _TIFFFieldWithTag(tif, tag)->field_name);

	va_end(ap);

	return (0);

}

/*

 * Return 1/0 according to whether or not

 * it is permissible to set the tag's value.

 * Note that we allow ImageLength to be changed

 * so that we can append and extend to images.

 * Any other tag may not be altered once writing

 * has commenced, unless its value has no effect

 * on the format of the data that is written.

 */

static int

OkToChangeTag(TIFF* tif, ttag_t tag)

{

	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);

	if (!fip) {			/* unknown tag */

		TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", "%s: Unknown %stag %u",

		    tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag);

		return (0);

	}

	if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) &&

	    !fip->field_oktochange) {

		/*

		 * Consult info table to see if tag can be changed

		 * after we've started writing.  We only allow changes

		 * to those tags that don't/shouldn't affect the

		 * compression and/or format of the data.

		 */

		TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",

		    "%s: Cannot modify tag \"%s\" while writing",

		    tif->tif_name, fip->field_name);

		return (0);

	}

	return (1);

}

/*

 * Record the value of a field in the

 * internal directory structure.  The

 * field will be written to the file

 * when/if the directory structure is

 * updated.

 */

int

TIFFSetField(TIFF* tif, ttag_t tag, ...)

{

	va_list ap;

	int status;

	va_start(ap, tag);

	status = TIFFVSetField(tif, tag, ap);

	va_end(ap);

	return (status);

}

/*

 * Like TIFFSetField, but taking a varargs

 * parameter list.  This routine is useful

 * for building higher-level interfaces on

 * top of the library.

 */

int

TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)

{

	return OkToChangeTag(tif, tag) ?

	    (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0;

}

static int

_TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)

{

    TIFFDirectory* td = &tif->tif_dir;

    int            ret_val = 1;

    switch (tag) {

	case TIFFTAG_SUBFILETYPE:

            *va_arg(ap, uint32*) = td->td_subfiletype;

            break;

	case TIFFTAG_IMAGEWIDTH:

            *va_arg(ap, uint32*) = td->td_imagewidth;

            break;

	case TIFFTAG_IMAGELENGTH:

            *va_arg(ap, uint32*) = td->td_imagelength;

            break;

	case TIFFTAG_BITSPERSAMPLE:

            *va_arg(ap, uint16*) = td->td_bitspersample;

            break;

	case TIFFTAG_COMPRESSION:

            *va_arg(ap, uint16*) = td->td_compression;

            break;

	case TIFFTAG_PHOTOMETRIC:

            *va_arg(ap, uint16*) = td->td_photometric;

            break;

	case TIFFTAG_THRESHHOLDING:

            *va_arg(ap, uint16*) = td->td_threshholding;

            break;

	case TIFFTAG_FILLORDER:

            *va_arg(ap, uint16*) = td->td_fillorder;

            break;

	case TIFFTAG_ORIENTATION:

            *va_arg(ap, uint16*) = td->td_orientation;

            break;

	case TIFFTAG_SAMPLESPERPIXEL:

            *va_arg(ap, uint16*) = td->td_samplesperpixel;

            break;

	case TIFFTAG_ROWSPERSTRIP:

            *va_arg(ap, uint32*) = td->td_rowsperstrip;

            break;

	case TIFFTAG_MINSAMPLEVALUE:

            *va_arg(ap, uint16*) = td->td_minsamplevalue;

            break;

	case TIFFTAG_MAXSAMPLEVALUE:

            *va_arg(ap, uint16*) = td->td_maxsamplevalue;

            break;

	case TIFFTAG_SMINSAMPLEVALUE:

            *va_arg(ap, double*) = td->td_sminsamplevalue;

            break;

	case TIFFTAG_SMAXSAMPLEVALUE:

            *va_arg(ap, double*) = td->td_smaxsamplevalue;

            break;

	case TIFFTAG_XRESOLUTION:

            *va_arg(ap, float*) = td->td_xresolution;

            break;

	case TIFFTAG_YRESOLUTION:

            *va_arg(ap, float*) = td->td_yresolution;

            break;

	case TIFFTAG_PLANARCONFIG:

            *va_arg(ap, uint16*) = td->td_planarconfig;

            break;

	case TIFFTAG_XPOSITION:

            *va_arg(ap, float*) = td->td_xposition;

            break;

	case TIFFTAG_YPOSITION:

            *va_arg(ap, float*) = td->td_yposition;

            break;

	case TIFFTAG_RESOLUTIONUNIT:

            *va_arg(ap, uint16*) = td->td_resolutionunit;

            break;

	case TIFFTAG_PAGENUMBER:

            *va_arg(ap, uint16*) = td->td_pagenumber[0];

            *va_arg(ap, uint16*) = td->td_pagenumber[1];

            break;

	case TIFFTAG_HALFTONEHINTS:

            *va_arg(ap, uint16*) = td->td_halftonehints[0];

            *va_arg(ap, uint16*) = td->td_halftonehints[1];

            break;

	case TIFFTAG_COLORMAP:

            *va_arg(ap, uint16**) = td->td_colormap[0];

            *va_arg(ap, uint16**) = td->td_colormap[1];

            *va_arg(ap, uint16**) = td->td_colormap[2];

            break;

	case TIFFTAG_STRIPOFFSETS:

	case TIFFTAG_TILEOFFSETS:

            *va_arg(ap, uint32**) = td->td_stripoffset;

            break;

	case TIFFTAG_STRIPBYTECOUNTS:

	case TIFFTAG_TILEBYTECOUNTS:

            *va_arg(ap, uint32**) = td->td_stripbytecount;

            break;

	case TIFFTAG_MATTEING:

            *va_arg(ap, uint16*) =

                (td->td_extrasamples == 1 &&

                 td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);

            break;

	case TIFFTAG_EXTRASAMPLES:

            *va_arg(ap, uint16*) = td->td_extrasamples;

            *va_arg(ap, uint16**) = td->td_sampleinfo;

            break;

	case TIFFTAG_TILEWIDTH:

            *va_arg(ap, uint32*) = td->td_tilewidth;

            break;

	case TIFFTAG_TILELENGTH:

            *va_arg(ap, uint32*) = td->td_tilelength;

            break;

	case TIFFTAG_TILEDEPTH:

            *va_arg(ap, uint32*) = td->td_tiledepth;

            break;

	case TIFFTAG_DATATYPE:

            switch (td->td_sampleformat) {

		case SAMPLEFORMAT_UINT:

                    *va_arg(ap, uint16*) = DATATYPE_UINT;

                    break;

		case SAMPLEFORMAT_INT:

                    *va_arg(ap, uint16*) = DATATYPE_INT;

                    break;

		case SAMPLEFORMAT_IEEEFP:

                    *va_arg(ap, uint16*) = DATATYPE_IEEEFP;

                    break;

		case SAMPLEFORMAT_VOID:

                    *va_arg(ap, uint16*) = DATATYPE_VOID;

                    break;

            }

            break;

	case TIFFTAG_SAMPLEFORMAT:

            *va_arg(ap, uint16*) = td->td_sampleformat;

            break;

	case TIFFTAG_IMAGEDEPTH:

            *va_arg(ap, uint32*) = td->td_imagedepth;

            break;

	case TIFFTAG_SUBIFD:

            *va_arg(ap, uint16*) = td->td_nsubifd;

            *va_arg(ap, uint32**) = td->td_subifd;

            break;

	case TIFFTAG_YCBCRPOSITIONING:

            *va_arg(ap, uint16*) = td->td_ycbcrpositioning;

            break;

	case TIFFTAG_YCBCRSUBSAMPLING:

            *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];

            *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];

            break;

	case TIFFTAG_TRANSFERFUNCTION:

            *va_arg(ap, uint16**) = td->td_transferfunction[0];

            if (td->td_samplesperpixel - td->td_extrasamples > 1) {

                *va_arg(ap, uint16**) = td->td_transferfunction[1];

                *va_arg(ap, uint16**) = td->td_transferfunction[2];

            }

            break;

	case TIFFTAG_REFERENCEBLACKWHITE:

	    *va_arg(ap, float**) = td->td_refblackwhite;

	    break;

	case TIFFTAG_INKNAMES:

            *va_arg(ap, char**) = td->td_inknames;

            break;

        default:

        {

            const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);

            int           i;

            /*

	     * This can happen if multiple images are open with different

	     * codecs which have private tags.  The global tag information

	     * table may then have tags that are valid for one file but not

	     * the other. If the client tries to get a tag that is not valid

	     * for the image's codec then we'll arrive here.

             */

            if( fip == NULL || fip->field_bit != FIELD_CUSTOM )

            {

		    TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField",

				 "%s: Invalid %stag \"%s\" "

				 "(not supported by codec)",

				 tif->tif_name,

				 isPseudoTag(tag) ? "pseudo-" : "",

				 fip ? fip->field_name : "Unknown");

		    ret_val = 0;

		    break;

            }

            /*

	     * Do we have a custom value?

	     */

            ret_val = 0;

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

		TIFFTagValue *tv = td->td_customValues + i;

		if (tv->info->field_tag != tag)

			continue;

		if (fip->field_passcount) {

			if (fip->field_readcount == TIFF_VARIABLE2) 

				*va_arg(ap, uint32*) = (uint32)tv->count;

			else	/* Assume TIFF_VARIABLE */

				*va_arg(ap, uint16*) = (uint16)tv->count;

			*va_arg(ap, void **) = tv->value;

			ret_val = 1;

                } else {

			if ((fip->field_type == TIFF_ASCII

			    || fip->field_readcount == TIFF_VARIABLE

			    || fip->field_readcount == TIFF_VARIABLE2

			    || fip->field_readcount == TIFF_SPP

			    || tv->count > 1)

			    && fip->field_tag != TIFFTAG_PAGENUMBER

			    && fip->field_tag != TIFFTAG_HALFTONEHINTS

			    && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING

			    && fip->field_tag != TIFFTAG_DOTRANGE) {

				*va_arg(ap, void **) = tv->value;

				ret_val = 1;