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, fip->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, fip ? fip->field_name : "Unknown");	va_end(ap);	return (0);badvalue32:	TIFFErrorExt(tif->tif_clientdata, module,		     "%s: Bad value %ld for \"%s\" tag",		     tif->tif_name, v32, fip ? fip->field_name : "Unknown");	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 intOkToChangeTag(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. */intTIFFSetField(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. */intTIFFVSetField(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_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;			} else {			    int j;			    char *val = (char *)tv->value;			    for (j = 0; j < tv->count;				 j++, val += _TIFFDataSize(tv->info->field_type)) {				switch (fip->field_type) {					case TIFF_BYTE:					case TIFF_UNDEFINED:						*va_arg(ap, uint8*) =							*(uint8 *)val;						ret_val = 1;						break;					case TIFF_SBYTE:						*va_arg(ap, int8*) =							*(int8 *)val;						ret_val = 1;						break;					case TIFF_SHORT:						*va_arg(ap, uint16*) =							*(uint16 *)val;						ret_val = 1;						break;					case TIFF_SSHORT:						*va_arg(ap, int16*) =							*(int16 *)val;						ret_val = 1;						break;					case TIFF_LONG:					case TIFF_IFD:						*va_arg(ap, uint32*) =							*(uint32 *)val;						ret_val = 1;						break;					case TIFF_SLONG:						*va_arg(ap, int32*) =							*(int32 *)val;						ret_val = 1;						break;					case TIFF_RATIONAL:					case TIFF_SRATIONAL:					case TIFF_FLOAT:						*va_arg(ap, float*) =							*(float *)val;						ret_val = 1;						break;					case TIFF_DOUBLE: