tif_dir.c

奇趣公司比较新的qt/emd版本

	    }
           
            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 = _TIFFmalloc(tv_size * tv->count);
		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\"",
		  tif->tif_name, v, _TIFFFieldWithTag(tif, tag)->field_name);
	va_end(ap);
	return (0);
badvalue32:
	TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad value %ld for \"%s\"",
		   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_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-" : "",
                          _TIFFFieldWithTag(tif, tag)->field_name);
                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:
						*va_arg(ap, double*) =