Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

tif_dir.c@ 245

Last change on this file since 245 was 95, checked in by Rick van der Zwet, 15 years ago
Bad boy, improper move of directory
File size: 39.3 KB

Rev	Line
[95]	1	/* $Id: tif_dir.c,v 1.72 2006/03/15 12:49:35 dron Exp $ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	6	*
	7	* Permission to use, copy, modify, distribute, and sell this software and
	8	* its documentation for any purpose is hereby granted without fee, provided
	9	* that (i) the above copyright notices and this permission notice appear in
	10	* all copies of the software and related documentation, and (ii) the names of
	11	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	12	* publicity relating to the software without the specific, prior written
	13	* permission of Sam Leffler and Silicon Graphics.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	16	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	17	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	18	*
	19	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	20	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	21	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	22	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	23	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	24	* OF THIS SOFTWARE.
	25	*/
	26
	27	/*
	28	* TIFF Library.
	29	*
	30	* Directory Tag Get & Set Routines.
	31	* (and also some miscellaneous stuff)
	32	*/
	33	#include "tiffiop.h"
	34
	35	/*
	36	* These are used in the backwards compatibility code...
	37	*/
	38	#define DATATYPE_VOID 0 /* !untyped data */
	39	#define DATATYPE_INT 1 /* !signed integer data */
	40	#define DATATYPE_UINT 2 /* !unsigned integer data */
	41	#define DATATYPE_IEEEFP 3 /* !IEEE floating point data */
	42
	43	static void
	44	setByteArray(void** vpp, void* vp, size_t nmemb, size_t elem_size)
	45	{
	46	if (*vpp)
	47	_TIFFfree(vpp), vpp = 0;
	48	if (vp) {
	49	tsize_t bytes = nmemb * elem_size;
	50	if (elem_size && bytes / elem_size == nmemb)
	51	vpp = (void) _TIFFmalloc(bytes);
	52	if (*vpp)
	53	_TIFFmemcpy(*vpp, vp, bytes);
	54	}
	55	}
	56	void _TIFFsetByteArray(void** vpp, void* vp, uint32 n)
	57	{ setByteArray(vpp, vp, n, 1); }
	58	void _TIFFsetString(char** cpp, char* cp)
	59	{ setByteArray((void*) cpp, (void) cp, strlen(cp)+1, 1); }
	60	void _TIFFsetNString(char** cpp, char* cp, uint32 n)
	61	{ setByteArray((void*) cpp, (void) cp, n, 1); }
	62	void _TIFFsetShortArray(uint16** wpp, uint16* wp, uint32 n)
	63	{ setByteArray((void*) wpp, (void) wp, n, sizeof (uint16)); }
	64	void _TIFFsetLongArray(uint32** lpp, uint32* lp, uint32 n)
	65	{ setByteArray((void*) lpp, (void) lp, n, sizeof (uint32)); }
	66	void _TIFFsetFloatArray(float** fpp, float* fp, uint32 n)
	67	{ setByteArray((void*) fpp, (void) fp, n, sizeof (float)); }
	68	void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n)
	69	{ setByteArray((void*) dpp, (void) dp, n, sizeof (double)); }
	70
	71	/*
	72	* Install extra samples information.
	73	*/
	74	static int
	75	setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v)
	76	{
	77	uint16* va;
	78	uint32 i;
	79
	80	*v = va_arg(ap, uint32);
	81	if ((uint16) *v > td->td_samplesperpixel)
	82	return (0);
	83	va = va_arg(ap, uint16*);
	84	if (v > 0 && va == NULL) / typically missing param */
	85	return (0);
	86	for (i = 0; i < *v; i++)
	87	if (va[i] > EXTRASAMPLE_UNASSALPHA)
	88	return (0);
	89	td->td_extrasamples = (uint16) *v;
	90	_TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
	91	return (1);
	92	}
	93
	94	static uint32
	95	checkInkNamesString(TIFF* tif, uint32 slen, const char* s)
	96	{
	97	TIFFDirectory* td = &tif->tif_dir;
	98	uint16 i = td->td_samplesperpixel;
	99
	100	if (slen > 0) {
	101	const char* ep = s+slen;
	102	const char* cp = s;
	103	for (; i > 0; i--) {
	104	for (; *cp != '\0'; cp++)
	105	if (cp >= ep)
	106	goto bad;
	107	cp++; /* skip \0 */
	108	}
	109	return (cp-s);
	110	}
	111	bad:
	112	TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",
	113	"%s: Invalid InkNames value; expecting %d names, found %d",
	114	tif->tif_name,
	115	td->td_samplesperpixel,
	116	td->td_samplesperpixel-i);
	117	return (0);
	118	}
	119
	120	static int
	121	_TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
	122	{
	123	static const char module[] = "_TIFFVSetField";
	124
	125	TIFFDirectory* td = &tif->tif_dir;
	126	int status = 1;
	127	uint32 v32, i, v;
	128	char* s;
	129
	130	switch (tag) {
	131	case TIFFTAG_SUBFILETYPE:
	132	td->td_subfiletype = va_arg(ap, uint32);
	133	break;
	134	case TIFFTAG_IMAGEWIDTH:
	135	td->td_imagewidth = va_arg(ap, uint32);
	136	break;
	137	case TIFFTAG_IMAGELENGTH:
	138	td->td_imagelength = va_arg(ap, uint32);
	139	break;
	140	case TIFFTAG_BITSPERSAMPLE:
	141	td->td_bitspersample = (uint16) va_arg(ap, int);
	142	/*
	143	* If the data require post-decoding processing to byte-swap
	144	* samples, set it up here. Note that since tags are required
	145	* to be ordered, compression code can override this behaviour
	146	* in the setup method if it wants to roll the post decoding
	147	* work in with its normal work.
	148	*/
	149	if (tif->tif_flags & TIFF_SWAB) {
	150	if (td->td_bitspersample == 16)
	151	tif->tif_postdecode = _TIFFSwab16BitData;
	152	else if (td->td_bitspersample == 24)
	153	tif->tif_postdecode = _TIFFSwab24BitData;
	154	else if (td->td_bitspersample == 32)
	155	tif->tif_postdecode = _TIFFSwab32BitData;
	156	else if (td->td_bitspersample == 64)
	157	tif->tif_postdecode = _TIFFSwab64BitData;
	158	else if (td->td_bitspersample == 128) /* two 64's */
	159	tif->tif_postdecode = _TIFFSwab64BitData;
	160	}
	161	break;
	162	case TIFFTAG_COMPRESSION:
	163	v = va_arg(ap, uint32) & 0xffff;
	164	/*
	165	* If we're changing the compression scheme, the notify the
	166	* previous module so that it can cleanup any state it's
	167	* setup.
	168	*/
	169	if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
	170	if (td->td_compression == v)
	171	break;
	172	(*tif->tif_cleanup)(tif);
	173	tif->tif_flags &= ~TIFF_CODERSETUP;
	174	}
	175	/*
	176	* Setup new compression routine state.
	177	*/
	178	if( (status = TIFFSetCompressionScheme(tif, v)) != 0 )
	179	td->td_compression = (uint16) v;
	180	else
	181	status = 0;
	182	break;
	183	case TIFFTAG_PHOTOMETRIC:
	184	td->td_photometric = (uint16) va_arg(ap, int);
	185	break;
	186	case TIFFTAG_THRESHHOLDING:
	187	td->td_threshholding = (uint16) va_arg(ap, int);
	188	break;
	189	case TIFFTAG_FILLORDER:
	190	v = va_arg(ap, uint32);
	191	if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
	192	goto badvalue;
	193	td->td_fillorder = (uint16) v;
	194	break;
	195	break;
	196	case TIFFTAG_ORIENTATION:
	197	v = va_arg(ap, uint32);
	198	if (v < ORIENTATION_TOPLEFT \|\| ORIENTATION_LEFTBOT < v) {
	199	TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
	200	"Bad value %lu for \"%s\" tag ignored",
	201	v, _TIFFFieldWithTag(tif, tag)->field_name);
	202	} else
	203	td->td_orientation = (uint16) v;
	204	break;
	205	case TIFFTAG_SAMPLESPERPIXEL:
	206	/* XXX should cross check -- e.g. if pallette, then 1 */
	207	v = va_arg(ap, uint32);
	208	if (v == 0)
	209	goto badvalue;
	210	td->td_samplesperpixel = (uint16) v;
	211	break;
	212	case TIFFTAG_ROWSPERSTRIP:
	213	v32 = va_arg(ap, uint32);
	214	if (v32 == 0)
	215	goto badvalue32;
	216	td->td_rowsperstrip = v32;
	217	if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
	218	td->td_tilelength = v32;
	219	td->td_tilewidth = td->td_imagewidth;
	220	}
	221	break;
	222	case TIFFTAG_MINSAMPLEVALUE:
	223	td->td_minsamplevalue = (uint16) va_arg(ap, int);
	224	break;
	225	case TIFFTAG_MAXSAMPLEVALUE:
	226	td->td_maxsamplevalue = (uint16) va_arg(ap, int);
	227	break;
	228	case TIFFTAG_SMINSAMPLEVALUE:
	229	td->td_sminsamplevalue = va_arg(ap, double);
	230	break;
	231	case TIFFTAG_SMAXSAMPLEVALUE:
	232	td->td_smaxsamplevalue = va_arg(ap, double);
	233	break;
	234	case TIFFTAG_XRESOLUTION:
	235	td->td_xresolution = (float) va_arg(ap, double);
	236	break;
	237	case TIFFTAG_YRESOLUTION:
	238	td->td_yresolution = (float) va_arg(ap, double);
	239	break;
	240	case TIFFTAG_PLANARCONFIG:
	241	v = va_arg(ap, uint32);
	242	if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
	243	goto badvalue;
	244	td->td_planarconfig = (uint16) v;
	245	break;
	246	case TIFFTAG_XPOSITION:
	247	td->td_xposition = (float) va_arg(ap, double);
	248	break;
	249	case TIFFTAG_YPOSITION:
	250	td->td_yposition = (float) va_arg(ap, double);
	251	break;
	252	case TIFFTAG_RESOLUTIONUNIT:
	253	v = va_arg(ap, uint32);
	254	if (v < RESUNIT_NONE \|\| RESUNIT_CENTIMETER < v)
	255	goto badvalue;
	256	td->td_resolutionunit = (uint16) v;
	257	break;
	258	case TIFFTAG_PAGENUMBER:
	259	td->td_pagenumber[0] = (uint16) va_arg(ap, int);
	260	td->td_pagenumber[1] = (uint16) va_arg(ap, int);
	261	break;
	262	case TIFFTAG_HALFTONEHINTS:
	263	td->td_halftonehints[0] = (uint16) va_arg(ap, int);
	264	td->td_halftonehints[1] = (uint16) va_arg(ap, int);
	265	break;
	266	case TIFFTAG_COLORMAP:
	267	v32 = (uint32)(1L<<td->td_bitspersample);
	268	_TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);
	269	_TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);
	270	_TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
	271	break;
	272	case TIFFTAG_EXTRASAMPLES:
	273	if (!setExtraSamples(td, ap, &v))
	274	goto badvalue;
	275	break;
	276	case TIFFTAG_MATTEING:
	277	td->td_extrasamples = (uint16) (va_arg(ap, int) != 0);
	278	if (td->td_extrasamples) {
	279	uint16 sv = EXTRASAMPLE_ASSOCALPHA;
	280	_TIFFsetShortArray(&td->td_sampleinfo, &sv, 1);
	281	}
	282	break;
	283	case TIFFTAG_TILEWIDTH:
	284	v32 = va_arg(ap, uint32);
	285	if (v32 % 16) {
	286	if (tif->tif_mode != O_RDONLY)
	287	goto badvalue32;
	288	TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
	289	"Nonstandard tile width %d, convert file", v32);
	290	}
	291	td->td_tilewidth = v32;
	292	tif->tif_flags \|= TIFF_ISTILED;
	293	break;
	294	case TIFFTAG_TILELENGTH:
	295	v32 = va_arg(ap, uint32);
	296	if (v32 % 16) {
	297	if (tif->tif_mode != O_RDONLY)
	298	goto badvalue32;
	299	TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
	300	"Nonstandard tile length %d, convert file", v32);
	301	}
	302	td->td_tilelength = v32;
	303	tif->tif_flags \|= TIFF_ISTILED;
	304	break;
	305	case TIFFTAG_TILEDEPTH:
	306	v32 = va_arg(ap, uint32);
	307	if (v32 == 0)
	308	goto badvalue32;
	309	td->td_tiledepth = v32;
	310	break;
	311	case TIFFTAG_DATATYPE:
	312	v = va_arg(ap, uint32);
	313	switch (v) {
	314	case DATATYPE_VOID: v = SAMPLEFORMAT_VOID; break;
	315	case DATATYPE_INT: v = SAMPLEFORMAT_INT; break;
	316	case DATATYPE_UINT: v = SAMPLEFORMAT_UINT; break;
	317	case DATATYPE_IEEEFP: v = SAMPLEFORMAT_IEEEFP;break;
	318	default: goto badvalue;
	319	}
	320	td->td_sampleformat = (uint16) v;
	321	break;
	322	case TIFFTAG_SAMPLEFORMAT:
	323	v = va_arg(ap, uint32);
	324	if (v < SAMPLEFORMAT_UINT \|\| SAMPLEFORMAT_COMPLEXIEEEFP < v)
	325	goto badvalue;
	326	td->td_sampleformat = (uint16) v;
	327
	328	/* Try to fix up the SWAB function for complex data. */
	329	if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
	330	&& td->td_bitspersample == 32
	331	&& tif->tif_postdecode == _TIFFSwab32BitData )
	332	tif->tif_postdecode = _TIFFSwab16BitData;
	333	else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
	334	\|\| td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP)
	335	&& td->td_bitspersample == 64
	336	&& tif->tif_postdecode == _TIFFSwab64BitData )
	337	tif->tif_postdecode = _TIFFSwab32BitData;
	338	break;
	339	case TIFFTAG_IMAGEDEPTH:
	340	td->td_imagedepth = va_arg(ap, uint32);
	341	break;
	342	case TIFFTAG_SUBIFD:
	343	if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {
	344	td->td_nsubifd = (uint16) va_arg(ap, int);
	345	_TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*),
	346	(long) td->td_nsubifd);
	347	} else {
	348	TIFFErrorExt(tif->tif_clientdata, module, "%s: Sorry, cannot nest SubIFDs",
	349	tif->tif_name);
	350	status = 0;
	351	}
	352	break;
	353	case TIFFTAG_YCBCRPOSITIONING:
	354	td->td_ycbcrpositioning = (uint16) va_arg(ap, int);
	355	break;
	356	case TIFFTAG_YCBCRSUBSAMPLING:
	357	td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int);
	358	td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int);
	359	break;
	360	case TIFFTAG_TRANSFERFUNCTION:
	361	v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
	362	for (i = 0; i < v; i++)
	363	_TIFFsetShortArray(&td->td_transferfunction[i],
	364	va_arg(ap, uint16*), 1L<<td->td_bitspersample);
	365	break;
	366	case TIFFTAG_INKNAMES:
	367	v = va_arg(ap, uint32);
	368	s = va_arg(ap, char*);
	369	v = checkInkNamesString(tif, v, s);
	370	status = v > 0;
	371	if( v > 0 ) {
	372	_TIFFsetNString(&td->td_inknames, s, v);
	373	td->td_inknameslen = v;
	374	}
	375	break;
	376	default: {
	377	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
	378	TIFFTagValue *tv;
	379	int tv_size, iCustom;
	380
	381	/*
	382	* This can happen if multiple images are open with different
	383	* codecs which have private tags. The global tag information
	384	* table may then have tags that are valid for one file but not
	385	* the other. If the client tries to set a tag that is not valid
	386	* for the image's codec then we'll arrive here. This
	387	* happens, for example, when tiffcp is used to convert between
	388	* compression schemes and codec-specific tags are blindly copied.
	389	*/
	390	if(fip == NULL \|\| fip->field_bit != FIELD_CUSTOM) {
	391	TIFFErrorExt(tif->tif_clientdata, module,
	392	"%s: Invalid %stag \"%s\" (not supported by codec)",
	393	tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
	394	_TIFFFieldWithTag(tif, tag)->field_name);
	395	status = 0;
	396	break;
	397	}
	398
	399	/*
	400	* Find the existing entry for this custom value.
	401	*/
	402	tv = NULL;
	403	for(iCustom = 0; iCustom < td->td_customValueCount; iCustom++) {
	404	if(td->td_customValues[iCustom].info == fip) {
	405	tv = td->td_customValues + iCustom;
	406	if(tv->value != NULL)
	407	{
	408	_TIFFfree(tv->value);
	409	tv->value = NULL;
	410	}
	411	break;
	412	}
	413	}
	414
	415	/*
	416	* Grow the custom list if the entry was not found.
	417	*/
	418	if(tv == NULL) {
	419	TIFFTagValue *new_customValues;
	420
	421	td->td_customValueCount++;
	422	new_customValues = (TIFFTagValue *)
	423	_TIFFrealloc(td->td_customValues,
	424	sizeof(TIFFTagValue) * td->td_customValueCount);
	425	if (!new_customValues) {
	426	TIFFErrorExt(tif->tif_clientdata, module,
	427	"%s: Failed to allocate space for list of custom values",
	428	tif->tif_name);
	429	status = 0;
	430	goto end;
	431	}
	432
	433	td->td_customValues = new_customValues;
	434
	435	tv = td->td_customValues + (td->td_customValueCount-1);
	436	tv->info = fip;
	437	tv->value = NULL;
	438	tv->count = 0;
	439	}
	440
	441	/*
	442	* Set custom value ... save a copy of the custom tag value.
	443	*/
	444	tv_size = _TIFFDataSize(fip->field_type);
	445	if (tv_size == 0) {
	446	status = 0;
	447	TIFFErrorExt(tif->tif_clientdata, module,
	448	"%s: Bad field type %d for \"%s\"",
	449	tif->tif_name, fip->field_type,
	450	fip->field_name);
	451	goto end;
	452	}
	453
	454	if(fip->field_passcount) {
	455	if (fip->field_writecount == TIFF_VARIABLE2)
	456	tv->count = (uint32) va_arg(ap, uint32);
	457	else
	458	tv->count = (int) va_arg(ap, int);
	459	} else if (fip->field_writecount == TIFF_VARIABLE
	460	\|\| fip->field_writecount == TIFF_VARIABLE2)
	461	tv->count = 1;
	462	else if (fip->field_writecount == TIFF_SPP)
	463	tv->count = td->td_samplesperpixel;
	464	else
	465	tv->count = fip->field_writecount;
	466
	467
	468	if (fip->field_type == TIFF_ASCII)
	469	_TIFFsetString((char *)&tv->value, va_arg(ap, char ));
	470	else {
	471	tv->value = _TIFFmalloc(tv_size * tv->count);
	472	if (!tv->value) {
	473	status = 0;
	474	goto end;
	475	}
	476
	477	if ((fip->field_passcount
	478	\|\| fip->field_writecount == TIFF_VARIABLE
	479	\|\| fip->field_writecount == TIFF_VARIABLE2
	480	\|\| fip->field_writecount == TIFF_SPP
	481	\|\| tv->count > 1)
	482	&& fip->field_tag != TIFFTAG_PAGENUMBER
	483	&& fip->field_tag != TIFFTAG_HALFTONEHINTS
	484	&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
	485	&& fip->field_tag != TIFFTAG_DOTRANGE) {
	486	_TIFFmemcpy(tv->value, va_arg(ap, void *),
	487	tv->count * tv_size);
	488	} else {
	489	/*
	490	* XXX: The following loop required to handle
	491	* TIFFTAG_PAGENUMBER, TIFFTAG_HALFTONEHINTS,
	492	* TIFFTAG_YCBCRSUBSAMPLING and TIFFTAG_DOTRANGE tags.
	493	* These tags are actually arrays and should be passed as
	494	* array pointers to TIFFSetField() function, but actually
	495	* passed as a list of separate values. This behaviour
	496	* must be changed in the future!
	497	*/
	498	int i;
	499	char val = (char )tv->value;
	500
	501	for (i = 0; i < tv->count; i++, val += tv_size) {
	502	switch (fip->field_type) {
	503	case TIFF_BYTE:
	504	case TIFF_UNDEFINED:
	505	{
	506	uint8 v = (uint8)va_arg(ap, int);
	507	_TIFFmemcpy(val, &v, tv_size);
	508	}
	509	break;
	510	case TIFF_SBYTE:
	511	{
	512	int8 v = (int8)va_arg(ap, int);
	513	_TIFFmemcpy(val, &v, tv_size);
	514	}
	515	break;
	516	case TIFF_SHORT:
	517	{
	518	uint16 v = (uint16)va_arg(ap, int);
	519	_TIFFmemcpy(val, &v, tv_size);
	520	}
	521	break;
	522	case TIFF_SSHORT:
	523	{
	524	int16 v = (int16)va_arg(ap, int);
	525	_TIFFmemcpy(val, &v, tv_size);
	526	}
	527	break;
	528	case TIFF_LONG:
	529	case TIFF_IFD:
	530	{
	531	uint32 v = va_arg(ap, uint32);
	532	_TIFFmemcpy(val, &v, tv_size);
	533	}
	534	break;
	535	case TIFF_SLONG:
	536	{
	537	int32 v = va_arg(ap, int32);
	538	_TIFFmemcpy(val, &v, tv_size);
	539	}
	540	break;
	541	case TIFF_RATIONAL:
	542	case TIFF_SRATIONAL:
	543	case TIFF_FLOAT:
	544	{
	545	float v = (float)va_arg(ap, double);
	546	_TIFFmemcpy(val, &v, tv_size);
	547	}
	548	break;
	549	case TIFF_DOUBLE:
	550	{
	551	double v = va_arg(ap, double);
	552	_TIFFmemcpy(val, &v, tv_size);
	553	}
	554	break;
	555	default:
	556	_TIFFmemset(val, 0, tv_size);
	557	status = 0;
	558	break;
	559	}
	560	}
	561	}
	562	}
	563	}
	564	}
	565	if (status) {
	566	TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
	567	tif->tif_flags \|= TIFF_DIRTYDIRECT;
	568	}
	569
	570	end:
	571	va_end(ap);
	572	return (status);
	573	badvalue:
	574	TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad value %d for \"%s\"",
	575	tif->tif_name, v, _TIFFFieldWithTag(tif, tag)->field_name);
	576	va_end(ap);
	577	return (0);
	578	badvalue32:
	579	TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad value %ld for \"%s\"",
	580	tif->tif_name, v32, _TIFFFieldWithTag(tif, tag)->field_name);
	581	va_end(ap);
	582	return (0);
	583	}
	584
	585	/*
	586	* Return 1/0 according to whether or not
	587	* it is permissible to set the tag's value.
	588	* Note that we allow ImageLength to be changed
	589	* so that we can append and extend to images.
	590	* Any other tag may not be altered once writing
	591	* has commenced, unless its value has no effect
	592	* on the format of the data that is written.
	593	*/
	594	static int
	595	OkToChangeTag(TIFF* tif, ttag_t tag)
	596	{
	597	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
	598	if (!fip) { /* unknown tag */
	599	TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", "%s: Unknown %stag %u",
	600	tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag);
	601	return (0);
	602	}
	603	if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) &&
	604	!fip->field_oktochange) {
	605	/*
	606	* Consult info table to see if tag can be changed
	607	* after we've started writing. We only allow changes
	608	* to those tags that don't/shouldn't affect the
	609	* compression and/or format of the data.
	610	*/
	611	TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",
	612	"%s: Cannot modify tag \"%s\" while writing",
	613	tif->tif_name, fip->field_name);
	614	return (0);
	615	}
	616	return (1);
	617	}
	618
	619	/*
	620	* Record the value of a field in the
	621	* internal directory structure. The
	622	* field will be written to the file
	623	* when/if the directory structure is
	624	* updated.
	625	*/
	626	int
	627	TIFFSetField(TIFF* tif, ttag_t tag, ...)
	628	{
	629	va_list ap;
	630	int status;
	631
	632	va_start(ap, tag);
	633	status = TIFFVSetField(tif, tag, ap);
	634	va_end(ap);
	635	return (status);
	636	}
	637
	638	/*
	639	* Like TIFFSetField, but taking a varargs
	640	* parameter list. This routine is useful
	641	* for building higher-level interfaces on
	642	* top of the library.
	643	*/
	644	int
	645	TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
	646	{
	647	return OkToChangeTag(tif, tag) ?
	648	(*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0;
	649	}
	650
	651	static int
	652	_TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
	653	{
	654	TIFFDirectory* td = &tif->tif_dir;
	655	int ret_val = 1;
	656
	657	switch (tag) {
	658	case TIFFTAG_SUBFILETYPE:
	659	va_arg(ap, uint32) = td->td_subfiletype;
	660	break;
	661	case TIFFTAG_IMAGEWIDTH:
	662	va_arg(ap, uint32) = td->td_imagewidth;
	663	break;
	664	case TIFFTAG_IMAGELENGTH:
	665	va_arg(ap, uint32) = td->td_imagelength;
	666	break;
	667	case TIFFTAG_BITSPERSAMPLE:
	668	va_arg(ap, uint16) = td->td_bitspersample;
	669	break;
	670	case TIFFTAG_COMPRESSION:
	671	va_arg(ap, uint16) = td->td_compression;
	672	break;
	673	case TIFFTAG_PHOTOMETRIC:
	674	va_arg(ap, uint16) = td->td_photometric;
	675	break;
	676	case TIFFTAG_THRESHHOLDING:
	677	va_arg(ap, uint16) = td->td_threshholding;
	678	break;
	679	case TIFFTAG_FILLORDER:
	680	va_arg(ap, uint16) = td->td_fillorder;
	681	break;
	682	case TIFFTAG_ORIENTATION:
	683	va_arg(ap, uint16) = td->td_orientation;
	684	break;
	685	case TIFFTAG_SAMPLESPERPIXEL:
	686	va_arg(ap, uint16) = td->td_samplesperpixel;
	687	break;
	688	case TIFFTAG_ROWSPERSTRIP:
	689	va_arg(ap, uint32) = td->td_rowsperstrip;
	690	break;
	691	case TIFFTAG_MINSAMPLEVALUE:
	692	va_arg(ap, uint16) = td->td_minsamplevalue;
	693	break;
	694	case TIFFTAG_MAXSAMPLEVALUE:
	695	va_arg(ap, uint16) = td->td_maxsamplevalue;
	696	break;
	697	case TIFFTAG_SMINSAMPLEVALUE:
	698	va_arg(ap, double) = td->td_sminsamplevalue;
	699	break;
	700	case TIFFTAG_SMAXSAMPLEVALUE:
	701	va_arg(ap, double) = td->td_smaxsamplevalue;
	702	break;
	703	case TIFFTAG_XRESOLUTION:
	704	va_arg(ap, float) = td->td_xresolution;
	705	break;
	706	case TIFFTAG_YRESOLUTION:
	707	va_arg(ap, float) = td->td_yresolution;
	708	break;
	709	case TIFFTAG_PLANARCONFIG:
	710	va_arg(ap, uint16) = td->td_planarconfig;
	711	break;
	712	case TIFFTAG_XPOSITION:
	713	va_arg(ap, float) = td->td_xposition;
	714	break;
	715	case TIFFTAG_YPOSITION:
	716	va_arg(ap, float) = td->td_yposition;
	717	break;
	718	case TIFFTAG_RESOLUTIONUNIT:
	719	va_arg(ap, uint16) = td->td_resolutionunit;
	720	break;
	721	case TIFFTAG_PAGENUMBER:
	722	va_arg(ap, uint16) = td->td_pagenumber[0];
	723	va_arg(ap, uint16) = td->td_pagenumber[1];
	724	break;
	725	case TIFFTAG_HALFTONEHINTS:
	726	va_arg(ap, uint16) = td->td_halftonehints[0];
	727	va_arg(ap, uint16) = td->td_halftonehints[1];
	728	break;
	729	case TIFFTAG_COLORMAP:
	730	va_arg(ap, uint16*) = td->td_colormap[0];
	731	va_arg(ap, uint16*) = td->td_colormap[1];
	732	va_arg(ap, uint16*) = td->td_colormap[2];
	733	break;
	734	case TIFFTAG_STRIPOFFSETS:
	735	case TIFFTAG_TILEOFFSETS:
	736	va_arg(ap, uint32*) = td->td_stripoffset;
	737	break;
	738	case TIFFTAG_STRIPBYTECOUNTS:
	739	case TIFFTAG_TILEBYTECOUNTS:
	740	va_arg(ap, uint32*) = td->td_stripbytecount;
	741	break;
	742	case TIFFTAG_MATTEING:
	743	va_arg(ap, uint16) =
	744	(td->td_extrasamples == 1 &&
	745	td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
	746	break;
	747	case TIFFTAG_EXTRASAMPLES:
	748	va_arg(ap, uint16) = td->td_extrasamples;
	749	va_arg(ap, uint16*) = td->td_sampleinfo;
	750	break;
	751	case TIFFTAG_TILEWIDTH:
	752	va_arg(ap, uint32) = td->td_tilewidth;
	753	break;
	754	case TIFFTAG_TILELENGTH:
	755	va_arg(ap, uint32) = td->td_tilelength;
	756	break;
	757	case TIFFTAG_TILEDEPTH:
	758	va_arg(ap, uint32) = td->td_tiledepth;
	759	break;
	760	case TIFFTAG_DATATYPE:
	761	switch (td->td_sampleformat) {
	762	case SAMPLEFORMAT_UINT:
	763	va_arg(ap, uint16) = DATATYPE_UINT;
	764	break;
	765	case SAMPLEFORMAT_INT:
	766	va_arg(ap, uint16) = DATATYPE_INT;
	767	break;
	768	case SAMPLEFORMAT_IEEEFP:
	769	va_arg(ap, uint16) = DATATYPE_IEEEFP;
	770	break;
	771	case SAMPLEFORMAT_VOID:
	772	va_arg(ap, uint16) = DATATYPE_VOID;
	773	break;
	774	}
	775	break;
	776	case TIFFTAG_SAMPLEFORMAT:
	777	va_arg(ap, uint16) = td->td_sampleformat;
	778	break;
	779	case TIFFTAG_IMAGEDEPTH:
	780	va_arg(ap, uint32) = td->td_imagedepth;
	781	break;
	782	case TIFFTAG_SUBIFD:
	783	va_arg(ap, uint16) = td->td_nsubifd;
	784	va_arg(ap, uint32*) = td->td_subifd;
	785	break;
	786	case TIFFTAG_YCBCRPOSITIONING:
	787	va_arg(ap, uint16) = td->td_ycbcrpositioning;
	788	break;
	789	case TIFFTAG_YCBCRSUBSAMPLING:
	790	va_arg(ap, uint16) = td->td_ycbcrsubsampling[0];
	791	va_arg(ap, uint16) = td->td_ycbcrsubsampling[1];
	792	break;
	793	case TIFFTAG_TRANSFERFUNCTION:
	794	va_arg(ap, uint16*) = td->td_transferfunction[0];
	795	if (td->td_samplesperpixel - td->td_extrasamples > 1) {
	796	va_arg(ap, uint16*) = td->td_transferfunction[1];
	797	va_arg(ap, uint16*) = td->td_transferfunction[2];
	798	}
	799	break;
	800	case TIFFTAG_INKNAMES:
	801	va_arg(ap, char*) = td->td_inknames;
	802	break;
	803	default:
	804	{
	805	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
	806	int i;
	807
	808	/*
	809	* This can happen if multiple images are open with
	810	* different codecs which have private tags. The
	811	* global tag information table may then have tags
	812	* that are valid for one file but not the other.
	813	* If the client tries to get a tag that is not valid
	814	* for the image's codec then we'll arrive here.
	815	*/
	816	if( fip == NULL \|\| fip->field_bit != FIELD_CUSTOM )
	817	{
	818	TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField",
	819	"%s: Invalid %stag \"%s\" (not supported by codec)",
	820	tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
	821	_TIFFFieldWithTag(tif, tag)->field_name);
	822	ret_val = 0;
	823	break;
	824	}
	825
	826	/*
	827	* Do we have a custom value?
	828	*/
	829	ret_val = 0;
	830	for (i = 0; i < td->td_customValueCount; i++) {
	831	TIFFTagValue *tv = td->td_customValues + i;
	832
	833	if (tv->info->field_tag != tag)
	834	continue;
	835
	836	if (fip->field_passcount) {
	837	if (fip->field_readcount == TIFF_VARIABLE2)
	838	va_arg(ap, uint32) = (uint32)tv->count;
	839	else /* Assume TIFF_VARIABLE */
	840	va_arg(ap, uint16) = (uint16)tv->count;
	841	va_arg(ap, void *) = tv->value;
	842	ret_val = 1;
	843	} else {
	844	if ((fip->field_type == TIFF_ASCII
	845	\|\| fip->field_readcount == TIFF_VARIABLE
	846	\|\| fip->field_readcount == TIFF_VARIABLE2
	847	\|\| fip->field_readcount == TIFF_SPP
	848	\|\| tv->count > 1)
	849	&& fip->field_tag != TIFFTAG_PAGENUMBER
	850	&& fip->field_tag != TIFFTAG_HALFTONEHINTS
	851	&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
	852	&& fip->field_tag != TIFFTAG_DOTRANGE) {
	853	va_arg(ap, void *) = tv->value;
	854	ret_val = 1;
	855	} else {
	856	int j;
	857	char val = (char )tv->value;
	858
	859	for (j = 0; j < tv->count;
	860	j++, val += _TIFFDataSize(tv->info->field_type)) {
	861	switch (fip->field_type) {
	862	case TIFF_BYTE:
	863	case TIFF_UNDEFINED:
	864	va_arg(ap, uint8) =
	865	(uint8 )val;
	866	ret_val = 1;
	867	break;
	868	case TIFF_SBYTE:
	869	va_arg(ap, int8) =
	870	(int8 )val;
	871	ret_val = 1;
	872	break;
	873	case TIFF_SHORT:
	874	va_arg(ap, uint16) =
	875	(uint16 )val;
	876	ret_val = 1;
	877	break;
	878	case TIFF_SSHORT:
	879	va_arg(ap, int16) =
	880	(int16 )val;
	881	ret_val = 1;
	882	break;
	883	case TIFF_LONG:
	884	case TIFF_IFD:
	885	va_arg(ap, uint32) =
	886	(uint32 )val;
	887	ret_val = 1;
	888	break;
	889	case TIFF_SLONG:
	890	va_arg(ap, int32) =
	891	(int32 )val;
	892	ret_val = 1;
	893	break;
	894	case TIFF_RATIONAL:
	895	case TIFF_SRATIONAL:
	896	case TIFF_FLOAT:
	897	va_arg(ap, float) =
	898	(float )val;
	899	ret_val = 1;
	900	break;
	901	case TIFF_DOUBLE:
	902	va_arg(ap, double) =
	903	(double )val;
	904	ret_val = 1;
	905	break;
	906	default:
	907	ret_val = 0;
	908	break;
	909	}
	910	}
	911	}
	912	}
	913	break;
	914	}
	915	}
	916	}
	917	return(ret_val);
	918	}
	919
	920	/*
	921	* Return the value of a field in the
	922	* internal directory structure.
	923	*/
	924	int
	925	TIFFGetField(TIFF* tif, ttag_t tag, ...)
	926	{
	927	int status;
	928	va_list ap;
	929
	930	va_start(ap, tag);
	931	status = TIFFVGetField(tif, tag, ap);
	932	va_end(ap);
	933	return (status);
	934	}
	935
	936	/*
	937	* Like TIFFGetField, but taking a varargs
	938	* parameter list. This routine is useful
	939	* for building higher-level interfaces on
	940	* top of the library.
	941	*/
	942	int
	943	TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
	944	{
	945	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
	946	return (fip && (isPseudoTag(tag) \|\| TIFFFieldSet(tif, fip->field_bit)) ?
	947	(*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0);
	948	}
	949
	950	#define CleanupField(member) { \
	951	if (td->member) { \
	952	_TIFFfree(td->member); \
	953	td->member = 0; \
	954	} \
	955	}
	956
	957	/*
	958	* Release storage associated with a directory.
	959	*/
	960	void
	961	TIFFFreeDirectory(TIFF* tif)
	962	{
	963	TIFFDirectory *td = &tif->tif_dir;
	964	int i;
	965
	966	_TIFFmemset(td->td_fieldsset, 0, FIELD_SETLONGS);
	967	CleanupField(td_colormap[0]);
	968	CleanupField(td_colormap[1]);
	969	CleanupField(td_colormap[2]);
	970	CleanupField(td_sampleinfo);
	971	CleanupField(td_subifd);
	972	CleanupField(td_inknames);
	973	CleanupField(td_transferfunction[0]);
	974	CleanupField(td_transferfunction[1]);
	975	CleanupField(td_transferfunction[2]);
	976	CleanupField(td_stripoffset);
	977	CleanupField(td_stripbytecount);
	978	TIFFClrFieldBit(tif, FIELD_YCBCRSUBSAMPLING);
	979	TIFFClrFieldBit(tif, FIELD_YCBCRPOSITIONING);
	980
	981	/* Cleanup custom tag values */
	982	for( i = 0; i < td->td_customValueCount; i++ ) {
	983	if (td->td_customValues[i].value)
	984	_TIFFfree(td->td_customValues[i].value);
	985	}
	986
	987	td->td_customValueCount = 0;
	988	CleanupField(td_customValues);
	989	}
	990	#undef CleanupField
	991
	992	/*
	993	* Client Tag extension support (from Niles Ritter).
	994	*/
	995	static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL;
	996
	997	TIFFExtendProc
	998	TIFFSetTagExtender(TIFFExtendProc extender)
	999	{
	1000	TIFFExtendProc prev = _TIFFextender;
	1001	_TIFFextender = extender;
	1002	return (prev);
	1003	}
	1004
	1005	/*
	1006	* Setup for a new directory. Should we automatically call
	1007	* TIFFWriteDirectory() if the current one is dirty?
	1008	*
	1009	* The newly created directory will not exist on the file till
	1010	* TIFFWriteDirectory(), TIFFFlush() or TIFFClose() is called.
	1011	*/
	1012	int
	1013	TIFFCreateDirectory(TIFF* tif)
	1014	{
	1015	TIFFDefaultDirectory(tif);
	1016	tif->tif_diroff = 0;
	1017	tif->tif_nextdiroff = 0;
	1018	tif->tif_curoff = 0;
	1019	tif->tif_row = (uint32) -1;
	1020	tif->tif_curstrip = (tstrip_t) -1;
	1021
	1022	return 0;
	1023	}
	1024
	1025	/*
	1026	* Setup a default directory structure.
	1027	*/
	1028	int
	1029	TIFFDefaultDirectory(TIFF* tif)
	1030	{
	1031	register TIFFDirectory* td = &tif->tif_dir;
	1032
	1033	size_t tiffFieldInfoCount;
	1034	const TIFFFieldInfo *tiffFieldInfo =
	1035	_TIFFGetFieldInfo(&tiffFieldInfoCount);
	1036	_TIFFSetupFieldInfo(tif, tiffFieldInfo, tiffFieldInfoCount);
	1037
	1038	_TIFFmemset(td, 0, sizeof (*td));
	1039	td->td_fillorder = FILLORDER_MSB2LSB;
	1040	td->td_bitspersample = 1;
	1041	td->td_threshholding = THRESHHOLD_BILEVEL;
	1042	td->td_orientation = ORIENTATION_TOPLEFT;
	1043	td->td_samplesperpixel = 1;
	1044	td->td_rowsperstrip = (uint32) -1;
	1045	td->td_tilewidth = 0;
	1046	td->td_tilelength = 0;
	1047	td->td_tiledepth = 1;
	1048	td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */
	1049	td->td_resolutionunit = RESUNIT_INCH;
	1050	td->td_sampleformat = SAMPLEFORMAT_UINT;
	1051	td->td_imagedepth = 1;
	1052	td->td_ycbcrsubsampling[0] = 2;
	1053	td->td_ycbcrsubsampling[1] = 2;
	1054	td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
	1055	tif->tif_postdecode = _TIFFNoPostDecode;
	1056	tif->tif_foundfield = NULL;
	1057	tif->tif_tagmethods.vsetfield = _TIFFVSetField;
	1058	tif->tif_tagmethods.vgetfield = _TIFFVGetField;
	1059	tif->tif_tagmethods.printdir = NULL;
	1060	/*
	1061	* Give client code a chance to install their own
	1062	* tag extensions & methods, prior to compression overloads.
	1063	*/
	1064	if (_TIFFextender)
	1065	(*_TIFFextender)(tif);
	1066	(void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
	1067	/*
	1068	* NB: The directory is marked dirty as a result of setting
	1069	* up the default compression scheme. However, this really
	1070	* isn't correct -- we want TIFF_DIRTYDIRECT to be set only
	1071	* if the user does something. We could just do the setup
	1072	* by hand, but it seems better to use the normal mechanism
	1073	* (i.e. TIFFSetField).
	1074	*/
	1075	tif->tif_flags &= ~TIFF_DIRTYDIRECT;
	1076
	1077	/*
	1078	* As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
	1079	* we clear the ISTILED flag when setting up a new directory.
	1080	* Should we also be clearing stuff like INSUBIFD?
	1081	*/
	1082	tif->tif_flags &= ~TIFF_ISTILED;
	1083
	1084	return (1);
	1085	}
	1086
	1087	static int
	1088	TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off)
	1089	{
	1090	static const char module[] = "TIFFAdvanceDirectory";
	1091	uint16 dircount;
	1092	if (isMapped(tif))
	1093	{
	1094	toff_t poff=*nextdir;
	1095	if (poff+sizeof(uint16) > tif->tif_size)
	1096	{
	1097	TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
	1098	tif->tif_name);
	1099	return (0);
	1100	}
	1101	_TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16));
	1102	if (tif->tif_flags & TIFF_SWAB)
	1103	TIFFSwabShort(&dircount);
	1104	poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry);
	1105	if (off != NULL)
	1106	*off = poff;
	1107	if (((toff_t) (poff+sizeof (uint32))) > tif->tif_size)
	1108	{
	1109	TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
	1110	tif->tif_name);
	1111	return (0);
	1112	}
	1113	_TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32));
	1114	if (tif->tif_flags & TIFF_SWAB)
	1115	TIFFSwabLong(nextdir);
	1116	return (1);
	1117	}
	1118	else
	1119	{
	1120	if (!SeekOK(tif, *nextdir) \|\|
	1121	!ReadOK(tif, &dircount, sizeof (uint16))) {
	1122	TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
	1123	tif->tif_name);
	1124	return (0);
	1125	}
	1126	if (tif->tif_flags & TIFF_SWAB)
	1127	TIFFSwabShort(&dircount);
	1128	if (off != NULL)
	1129	*off = TIFFSeekFile(tif,
	1130	dircount*sizeof (TIFFDirEntry), SEEK_CUR);
	1131	else
	1132	(void) TIFFSeekFile(tif,
	1133	dircount*sizeof (TIFFDirEntry), SEEK_CUR);
	1134	if (!ReadOK(tif, nextdir, sizeof (uint32))) {
	1135	TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
	1136	tif->tif_name);
	1137	return (0);
	1138	}
	1139	if (tif->tif_flags & TIFF_SWAB)
	1140	TIFFSwabLong(nextdir);
	1141	return (1);
	1142	}
	1143	}
	1144
	1145	/*
	1146	* Count the number of directories in a file.
	1147	*/
	1148	tdir_t
	1149	TIFFNumberOfDirectories(TIFF* tif)
	1150	{
	1151	toff_t nextdir = tif->tif_header.tiff_diroff;
	1152	tdir_t n = 0;
	1153
	1154	while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL))
	1155	n++;
	1156	return (n);
	1157	}
	1158
	1159	/*
	1160	* Set the n-th directory as the current directory.
	1161	* NB: Directories are numbered starting at 0.
	1162	*/
	1163	int
	1164	TIFFSetDirectory(TIFF* tif, tdir_t dirn)
	1165	{
	1166	toff_t nextdir;
	1167	tdir_t n;
	1168
	1169	nextdir = tif->tif_header.tiff_diroff;
	1170	for (n = dirn; n > 0 && nextdir != 0; n--)
	1171	if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
	1172	return (0);
	1173	tif->tif_nextdiroff = nextdir;
	1174	/*
	1175	* Set curdir to the actual directory index. The
	1176	* -1 is because TIFFReadDirectory will increment
	1177	* tif_curdir after successfully reading the directory.
	1178	*/
	1179	tif->tif_curdir = (dirn - n) - 1;
	1180	/*
	1181	* Reset tif_dirnumber counter and start new list of seen directories.
	1182	* We need this to prevent IFD loops.
	1183	*/
	1184	tif->tif_dirnumber = 0;
	1185	return (TIFFReadDirectory(tif));
	1186	}
	1187
	1188	/*
	1189	* Set the current directory to be the directory
	1190	* located at the specified file offset. This interface
	1191	* is used mainly to access directories linked with
	1192	* the SubIFD tag (e.g. thumbnail images).
	1193	*/
	1194	int
	1195	TIFFSetSubDirectory(TIFF* tif, uint32 diroff)
	1196	{
	1197	tif->tif_nextdiroff = diroff;
	1198	/*
	1199	* Reset tif_dirnumber counter and start new list of seen directories.
	1200	* We need this to prevent IFD loops.
	1201	*/
	1202	tif->tif_dirnumber = 0;
	1203	return (TIFFReadDirectory(tif));
	1204	}
	1205
	1206	/*
	1207	* Return file offset of the current directory.
	1208	*/
	1209	uint32
	1210	TIFFCurrentDirOffset(TIFF* tif)
	1211	{
	1212	return (tif->tif_diroff);
	1213	}
	1214
	1215	/*
	1216	* Return an indication of whether or not we are
	1217	* at the last directory in the file.
	1218	*/
	1219	int
	1220	TIFFLastDirectory(TIFF* tif)
	1221	{
	1222	return (tif->tif_nextdiroff == 0);
	1223	}
	1224
	1225	/*
	1226	* Unlink the specified directory from the directory chain.
	1227	*/
	1228	int
	1229	TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn)
	1230	{
	1231	static const char module[] = "TIFFUnlinkDirectory";
	1232	toff_t nextdir;
	1233	toff_t off;
	1234	tdir_t n;
	1235
	1236	if (tif->tif_mode == O_RDONLY) {
	1237	TIFFErrorExt(tif->tif_clientdata, module,
	1238	"Can not unlink directory in read-only file");
	1239	return (0);
	1240	}
	1241	/*
	1242	* Go to the directory before the one we want
	1243	* to unlink and nab the offset of the link
	1244	* field we'll need to patch.
	1245	*/
	1246	nextdir = tif->tif_header.tiff_diroff;
	1247	off = sizeof (uint16) + sizeof (uint16);
	1248	for (n = dirn-1; n > 0; n--) {
	1249	if (nextdir == 0) {
	1250	TIFFErrorExt(tif->tif_clientdata, module, "Directory %d does not exist", dirn);
	1251	return (0);
	1252	}
	1253	if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
	1254	return (0);
	1255	}
	1256	/*
	1257	* Advance to the directory to be unlinked and fetch
	1258	* the offset of the directory that follows.
	1259	*/
	1260	if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
	1261	return (0);
	1262	/*
	1263	* Go back and patch the link field of the preceding
	1264	* directory to point to the offset of the directory
	1265	* that follows.
	1266	*/
	1267	(void) TIFFSeekFile(tif, off, SEEK_SET);
	1268	if (tif->tif_flags & TIFF_SWAB)
	1269	TIFFSwabLong(&nextdir);
	1270	if (!WriteOK(tif, &nextdir, sizeof (uint32))) {
	1271	TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
	1272	return (0);
	1273	}
	1274	/*
	1275	* Leave directory state setup safely. We don't have
	1276	* facilities for doing inserting and removing directories,
	1277	* so it's safest to just invalidate everything. This
	1278	* means that the caller can only append to the directory
	1279	* chain.
	1280	*/
	1281	(*tif->tif_cleanup)(tif);
	1282	if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
	1283	_TIFFfree(tif->tif_rawdata);
	1284	tif->tif_rawdata = NULL;
	1285	tif->tif_rawcc = 0;
	1286	}
	1287	tif->tif_flags &= ~(TIFF_BEENWRITING\|TIFF_BUFFERSETUP\|TIFF_POSTENCODE);
	1288	TIFFFreeDirectory(tif);
	1289	TIFFDefaultDirectory(tif);
	1290	tif->tif_diroff = 0; /* force link on next write */
	1291	tif->tif_nextdiroff = 0; /* next write must be at end */
	1292	tif->tif_curoff = 0;
	1293	tif->tif_row = (uint32) -1;
	1294	tif->tif_curstrip = (tstrip_t) -1;
	1295	return (1);
	1296	}
	1297
	1298	/* [BFC]
	1299	*
	1300	* Author: Bruce Cameron <cameron@petris.com>
	1301	*
	1302	* Set a table of tags that are to be replaced during directory process by the
	1303	* 'IGNORE' state - or return TRUE/FALSE for the requested tag such that
	1304	* 'ReadDirectory' can use the stored information.
	1305	*
	1306	* FIXME: this is never used properly. Should be removed in the future.
	1307	*/
	1308	int
	1309	TIFFReassignTagToIgnore (enum TIFFIgnoreSense task, int TIFFtagID)
	1310	{
	1311	static int TIFFignoretags [FIELD_LAST];
	1312	static int tagcount = 0 ;
	1313	int i; /* Loop index */
	1314	int j; /* Loop index */
	1315
	1316	switch (task)
	1317	{
	1318	case TIS_STORE:
	1319	if ( tagcount < (FIELD_LAST - 1) )
	1320	{
	1321	for ( j = 0 ; j < tagcount ; ++j )
	1322	{ /* Do not add duplicate tag */
	1323	if ( TIFFignoretags [j] == TIFFtagID )
	1324	return (TRUE) ;
	1325	}
	1326	TIFFignoretags [tagcount++] = TIFFtagID ;
	1327	return (TRUE) ;
	1328	}
	1329	break ;
	1330
	1331	case TIS_EXTRACT:
	1332	for ( i = 0 ; i < tagcount ; ++i )
	1333	{
	1334	if ( TIFFignoretags [i] == TIFFtagID )
	1335	return (TRUE) ;
	1336	}
	1337	break;
	1338
	1339	case TIS_EMPTY:
	1340	tagcount = 0 ; /* Clear the list */
	1341	return (TRUE) ;
	1342
	1343	default:
	1344	break;
	1345	}
	1346
	1347	return (FALSE);
	1348	}
	1349
	1350	/* vim: set ts=8 sts=8 sw=8 noet: */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: liacs/MIR2010/SourceCode/cximage/tiff/tif_dir.c@ 245

Download in other formats: