/* $Header: /cvs/maptools/cvsroot/libtiff/contrib/pds/tif_pdsdirread.c,v 1.4 2010-06-08 18:55:15 bfriesen Exp $ */

/*

 * Copyright (c) 1988-1996 Sam Leffler

 * Copyright (c) 1991-1996 Silicon Graphics, Inc.

 * Copyright (c( 1996 USAF Phillips Laboratory

 *

 * 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.

 * 

 * These routines written by Conrad J. Poelman on a single late-night of

 * March 20-21, 1996.

 *

 * The entire purpose of this file is to provide a single external function,

 * TIFFReadPrivateDataSubDirectory(). This function is intended for use in reading a

 * private subdirectory from a TIFF file into a private structure. The

 * actual writing of data into the structure is handled by the setFieldFn(),

 * which is passed to TIFFReadPrivateDataSubDirectory() as a parameter. The idea is to

 * enable any application wishing to store private subdirectories to do so

 * easily using this function, without modifying the TIFF library.

 *

 * The astute observer will notice that only two functions are at all different

 * from the original tif_dirread.c file: TIFFReadPrivateDataSubDirectory() and

 * TIFFFetchNormalSubTag(). All the other stuff that makes this file so huge

 * is only necessary because all of those functions are declared static in

 * tif_dirread.c, so we have to totally duplicate them in order to use them.

 *

 * Oh, also note the bug fix in TIFFFetchFloat().

 *

 */

#include "tiffiop.h"

#define	IGNORE	0		/* tag placeholder used below */

#if HAVE_IEEEFP

#define	TIFFCvtIEEEFloatToNative(tif, n, fp)

#define	TIFFCvtIEEEDoubleToNative(tif, n, dp)

#else

extern	void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*);

extern	void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*);

#endif

static	void EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16);

static	void MissingRequired(TIFF*, const char*);

static	int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);

static	tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);

static	tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);

static	float TIFFFetchRational(TIFF*, TIFFDirEntry*);

static	int TIFFFetchNormalSubTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*,

				  int (*getFieldFn)(TIFF *tif,ttag_t tag,...));

static	int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, int*);

static	int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*);

static	int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);

static	int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);

static	int TIFFFetchExtraSamples(TIFF*, TIFFDirEntry*);

static	int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);

static	float TIFFFetchFloat(TIFF*, TIFFDirEntry*);

static	int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);

static	int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*);

static	int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*);

static	int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);

#if STRIPCHOP_SUPPORT

static	void ChopUpSingleUncompressedStrip(TIFF*);

#endif

static char *

CheckMalloc(TIFF* tif, tsize_t n, const char* what)

{

	char *cp = (char*)_TIFFmalloc(n);

	if (cp == NULL)

		TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space %s", what);

	return (cp);

}

/* Just as was done with TIFFWritePrivateDataSubDirectory(), here we implement

   TIFFReadPrivateDataSubDirectory() which takes an offset into the TIFF file,

   a TIFFFieldInfo structure specifying the types of the various tags,

   and a function to use to set individual tags when they are encountered.

   The data is read from the file, translated using the TIFF library's

   built-in machine-independent conversion functions, and filled into

   private subdirectory structure.

   This code was written by copying the original TIFFReadDirectory() function

   from tif_dirread.c and paring it down to what is needed for this.

   It is the caller's responsibility to allocate and initialize the internal

   structure that setFieldFn() will be writing into. If this function is being

   called more than once before closing the file, the caller also must be

   careful to free data in the structure before re-initializing.

   It is also the caller's responsibility to verify the presence of

   any required fields after reading the directory in.

*/

int

TIFFReadPrivateDataSubDirectory(TIFF* tif, toff_t pdir_offset,

				TIFFFieldInfo *field_info,

				int (*setFieldFn)(TIFF *tif, ttag_t tag, ...))

{

	register TIFFDirEntry* dp;

	register int n;

	register TIFFDirectory* td;

	TIFFDirEntry* dir;

	int iv;

	long v;

	double dv;

	const TIFFFieldInfo* fip;

	int fix;

	uint16 dircount;

	uint32 nextdiroff;

	char* cp;

	int diroutoforderwarning = 0;

	/* Skipped part about checking for directories or compression data. */

	if (!isMapped(tif)) {

		if (!SeekOK(tif, pdir_offset)) {

			TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

			    "Seek error accessing TIFF private subdirectory");

			return (0);

		}

		if (!ReadOK(tif, &dircount, sizeof (uint16))) {

			TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

			    "Can not read TIFF private subdirectory count");

			return (0);

		}

		if (tif->tif_flags & TIFF_SWAB)

			TIFFSwabShort(&dircount);

		dir = (TIFFDirEntry *)CheckMalloc(tif,

		    dircount * sizeof (TIFFDirEntry), "to read TIFF private subdirectory");

		if (dir == NULL)

			return (0);

		if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {

			TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Can not read TIFF private subdirectory");

			goto bad;

		}

		/*

		 * Read offset to next directory for sequential scans.

		 */

		(void) ReadOK(tif, &nextdiroff, sizeof (uint32));

	} else {

		toff_t off = pdir_offset;

		if (off + sizeof (short) > tif->tif_size) {

			TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

			    "Can not read TIFF private subdirectory count");

			return (0);

		} else

			_TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));

		off += sizeof (uint16);

		if (tif->tif_flags & TIFF_SWAB)

			TIFFSwabShort(&dircount);

		dir = (TIFFDirEntry *)CheckMalloc(tif,

		    dircount * sizeof (TIFFDirEntry), "to read TIFF private subdirectory");

		if (dir == NULL)

			return (0);

		if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {

			TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Can not read TIFF private subdirectory");

			goto bad;

		} else

			_TIFFmemcpy(dir, tif->tif_base + off,

			    dircount*sizeof (TIFFDirEntry));

		off += dircount* sizeof (TIFFDirEntry);

		if (off + sizeof (uint32) < tif->tif_size)

			_TIFFmemcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32));

	}

	if (tif->tif_flags & TIFF_SWAB)

		TIFFSwabLong(&nextdiroff);

	/*

	 * Setup default value and then make a pass over

	 * the fields to check type and tag information,

	 * and to extract info required to size data

	 * structures.  A second pass is made afterwards

	 * to read in everthing not taken in the first pass.

	 */

	td = &tif->tif_dir;

	for (fip = field_info, dp = dir, n = dircount;

	     n > 0; n--, dp++) {

		if (tif->tif_flags & TIFF_SWAB) {

			TIFFSwabArrayOfShort(&dp->tdir_tag, 2);

			TIFFSwabArrayOfLong(&dp->tdir_count, 2);

		}

		/*

		 * Find the field information entry for this tag.

		 */

		/*

		 * Silicon Beach (at least) writes unordered

		 * directory tags (violating the spec).  Handle

		 * it here, but be obnoxious (maybe they'll fix it?).

		 */

		if (dp->tdir_tag < fip->field_tag) {

			if (!diroutoforderwarning) {

				TIFFWarning(tif->tif_name,

	"invalid TIFF private subdirectory; tags are not sorted in ascending order");

				diroutoforderwarning = 1;

			}

			fip = field_info;    /* O(n^2) */

		}

		while (fip->field_tag && fip->field_tag < dp->tdir_tag)

			fip++;

		if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {

			TIFFWarning(tif->tif_name,

			    "unknown field with tag %d (0x%x) in private subdirectory ignored",

			    dp->tdir_tag,  dp->tdir_tag);

			dp->tdir_tag = IGNORE;

			fip = field_info;/* restart search */

			continue;

		}

		/*

		 * Null out old tags that we ignore.

		 */

		/* Not implemented yet, since FIELD_IGNORE is specific to

		   the main directories. Could pass this in too... */

		if (0 /* && fip->field_bit == FIELD_IGNORE */) {

	ignore:

			dp->tdir_tag = IGNORE;

			continue;

		}

		/*

		 * Check data type.

		 */

		while (dp->tdir_type != (u_short)fip->field_type) {

			if (fip->field_type == TIFF_ANY)	/* wildcard */

				break;

			fip++;

			if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {

				TIFFWarning(tif->tif_name,

				   "wrong data type %d for \"%s\"; tag ignored",

				    dp->tdir_type, fip[-1].field_name);

				goto ignore;

			}

		}

		/*

		 * Check count if known in advance.

		 */

		if (fip->field_readcount != TIFF_VARIABLE) {

			uint32 expected = (fip->field_readcount == TIFF_SPP) ?

			    (uint32) td->td_samplesperpixel :

			    (uint32) fip->field_readcount;

			if (!CheckDirCount(tif, dp, expected))

				goto ignore;

		}

		/* Now read in and process data from field. */

		if (!TIFFFetchNormalSubTag(tif, dp, fip, setFieldFn))

		    goto bad;

	}

	if (dir)

		_TIFFfree(dir);

	return (1);

bad:

	if (dir)

		_TIFFfree(dir);

	return (0);

}

static void

EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)

{

	register TIFFDirEntry *dp;

	register TIFFDirectory *td = &tif->tif_dir;

	uint16 i;

	if (td->td_stripbytecount)

		_TIFFfree(td->td_stripbytecount);

	td->td_stripbytecount = (uint32*)

	    CheckMalloc(tif, td->td_nstrips * sizeof (uint32),

		"for \"StripByteCounts\" array");

	if (td->td_compression != COMPRESSION_NONE) {

		uint32 space = (uint32)(sizeof (TIFFHeader)

		    + sizeof (uint16)

		    + (dircount * sizeof (TIFFDirEntry))

		    + sizeof (uint32));

		toff_t filesize = TIFFGetFileSize(tif);

		uint16 n;

		/* calculate amount of space used by indirect values */

		for (dp = dir, n = dircount; n > 0; n--, dp++) {

			uint32 cc = dp->tdir_count*TIFFDataWidth(dp->tdir_type);

			if (cc > sizeof (uint32))

				space += cc;

		}

		space = (filesize - space) / td->td_samplesperpixel;

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

			td->td_stripbytecount[i] = space;

		/*

		 * This gross hack handles the case were the offset to

		 * the last strip is past the place where we think the strip

		 * should begin.  Since a strip of data must be contiguous,

		 * it's safe to assume that we've overestimated the amount

		 * of data in the strip and trim this number back accordingly.

		 */ 

		i--;

		if (td->td_stripoffset[i] + td->td_stripbytecount[i] > filesize)

			td->td_stripbytecount[i] =

			    filesize - td->td_stripoffset[i];

	} else {

		uint32 rowbytes = TIFFScanlineSize(tif);

		uint32 rowsperstrip = td->td_imagelength / td->td_nstrips;

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

			td->td_stripbytecount[i] = rowbytes*rowsperstrip;

	}

	TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);

	if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))

		td->td_rowsperstrip = td->td_imagelength;

}

static void

MissingRequired(TIFF* tif, const char* tagname)

{

	TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

	    "TIFF directory is missing required \"%s\" field", tagname);

}

/*

 * Check the count field of a directory

 * entry against a known value.  The caller

 * is expected to skip/ignore the tag if

 * there is a mismatch.

 */

static int

CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)

{

	if (count != dir->tdir_count) {

		TIFFWarning(tif->tif_name,

	"incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored",

		    _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,

		    dir->tdir_count, count);

		return (0);

	}

	return (1);

}

/*

 * Fetch a contiguous directory item.

 */

static tsize_t

TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)

{

	int w = TIFFDataWidth(dir->tdir_type);

	tsize_t cc = dir->tdir_count * w;

	if (!isMapped(tif)) {

		if (!SeekOK(tif, dir->tdir_offset))

			goto bad;

		if (!ReadOK(tif, cp, cc))

			goto bad;

	} else {

		if (dir->tdir_offset + cc > tif->tif_size)

			goto bad;

		_TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc);

	}

	if (tif->tif_flags & TIFF_SWAB) {

		switch (dir->tdir_type) {

		case TIFF_SHORT:

		case TIFF_SSHORT:

			TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);

			break;

		case TIFF_LONG:

		case TIFF_SLONG:

		case TIFF_FLOAT:

			TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);

			break;

		case TIFF_RATIONAL:

		case TIFF_SRATIONAL:

			TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);

			break;

		case TIFF_DOUBLE:

			TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);

			break;

		}

	}

	return (cc);

bad:

	TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error fetching data for field \"%s\"",

	    _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);

	return ((tsize_t) 0);

}

/*

 * Fetch an ASCII item from the file.

 */

static tsize_t

TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp)

{

	if (dir->tdir_count <= 4) {

		uint32 l = dir->tdir_offset;

		if (tif->tif_flags & TIFF_SWAB)

			TIFFSwabLong(&l);

		_TIFFmemcpy(cp, &l, dir->tdir_count);

		return (1);

	}

	return (TIFFFetchData(tif, dir, cp));

}

/*

 * Convert numerator+denominator to float.

 */

static int

cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)

{

	if (denom == 0) {

		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

		    "%s: Rational with zero denominator (num = %lu)",

		    _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num);

		return (0);

	} else {

		if (dir->tdir_type == TIFF_RATIONAL)

			*rv = ((float)num / (float)denom);

		else

			*rv = ((float)(int32)num / (float)(int32)denom);

		return (1);

	}

}

/*

 * Fetch a rational item from the file

 * at offset off and return the value

 * as a floating point number.

 */

static float

TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)

{

	uint32 l[2];

	float v;

	return (!TIFFFetchData(tif, dir, (char *)l) ||

	    !cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v);

}

/*

 * Fetch a single floating point value

 * from the offset field and return it

 * as a native float.

 */

static float

TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)

{

	/* This appears to be a flagrant bug in the TIFF library, yet I

	   actually don't understand how it could have ever worked the old

	   way. Look at the comments in my new code and you'll understand. */

#if (0)

	float v = (float)

	    TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);

	TIFFCvtIEEEFloatToNative(tif, 1, &v);

#else

	float v;

	/* This is a little bit tricky - if we just cast the uint32 to a float,

	   C will perform a numerical conversion, which is not what we want.

	   We want to take the actual bit pattern in the uint32 and interpret

	   it as a float. Thus we cast a uint32 * into a float * and then

	   dereference to get v. */

	uint32 l = (uint32)

	    TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);

	v = * (float *) &l;

	TIFFCvtIEEEFloatToNative(tif, 1, &v);

#endif

	return (v);

}

/*

 * Fetch an array of BYTE or SBYTE values.

 */

static int

TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)

{

	if (dir->tdir_count <= 4) {

		/*

		 * Extract data from offset field.

		 */

		if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {

			switch (dir->tdir_count) {

			case 4: v[3] = dir->tdir_offset & 0xff;

			case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;

			case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;

			case 1: v[0] = dir->tdir_offset >> 24;

			}

		} else {

			switch (dir->tdir_count) {

			case 4: v[3] = dir->tdir_offset >> 24;

			case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;

			case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;

			case 1: v[0] = dir->tdir_offset & 0xff;

			}

		}

		return (1);

	} else

		return (TIFFFetchData(tif, dir, (char*) v) != 0);	/* XXX */

}

/*

 * Fetch an array of SHORT or SSHORT values.

 */

static int

TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)

{

	if (dir->tdir_count <= 2) {

		if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {

			switch (dir->tdir_count) {

			case 2: v[1] = dir->tdir_offset & 0xffff;

			case 1: v[0] = dir->tdir_offset >> 16;

			}

		} else {

			switch (dir->tdir_count) {

			case 2: v[1] = dir->tdir_offset >> 16;

			case 1: v[0] = dir->tdir_offset & 0xffff;

			}

		}

		return (1);

	} else

		return (TIFFFetchData(tif, dir, (char *)v) != 0);

}

/*

 * Fetch a pair of SHORT or BYTE values.

 */

static int

TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)

{

	uint16 v[2];

	int ok = 0;

	switch (dir->tdir_type) {

	case TIFF_SHORT:

	case TIFF_SSHORT:

		ok = TIFFFetchShortArray(tif, dir, v);

		break;

	case TIFF_BYTE:

	case TIFF_SBYTE:

		ok  = TIFFFetchByteArray(tif, dir, v);

		break;

	}

	if (ok)

		TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);

	return (ok);

}

/*

 * Fetch an array of LONG or SLONG values.

 */

static int

TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)

{

	if (dir->tdir_count == 1) {

		v[0] = dir->tdir_offset;

		return (1);

	} else

		return (TIFFFetchData(tif, dir, (char*) v) != 0);

}

/*

 * Fetch an array of RATIONAL or SRATIONAL values.

 */

static int

TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)

{

	int ok = 0;

	uint32* l;

	l = (uint32*)CheckMalloc(tif,

	    dir->tdir_count*TIFFDataWidth(dir->tdir_type),

	    "to fetch array of rationals");

	if (l) {

		if (TIFFFetchData(tif, dir, (char *)l)) {

			uint32 i;

			for (i = 0; i < dir->tdir_count; i++) {

				ok = cvtRational(tif, dir,

				    l[2*i+0], l[2*i+1], &v[i]);

				if (!ok)

					break;

			}

		}

		_TIFFfree((char *)l);

	}

	return (ok);

}

/*

 * Fetch an array of FLOAT values.

 */

static int

TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)

{

	if (dir->tdir_count == 1) {

		v[0] = *(float*) &dir->tdir_offset;

		TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);

		return (1);

	} else	if (TIFFFetchData(tif, dir, (char*) v)) {

		TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);

		return (1);

	} else

		return (0);

}

/*

 * Fetch an array of DOUBLE values.

 */

static int

TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)

{

	if (TIFFFetchData(tif, dir, (char*) v)) {

		TIFFCvtIEEEDoubleToNative(tif, dir->tdir_count, v);

		return (1);

	} else

		return (0);

}

/*

 * Fetch an array of ANY values.  The actual values are

 * returned as doubles which should be able hold all the

 * types.  Yes, there really should be an tany_t to avoid

 * this potential non-portability ...  Note in particular

 * that we assume that the double return value vector is

 * large enough to read in any fundamental type.  We use

 * that vector as a buffer to read in the base type vector

 * and then convert it in place to double (from end

 * to front of course).

 */

static int

TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v)

{

	int i;

	switch (dir->tdir_type) {

	case TIFF_BYTE:

	case TIFF_SBYTE:

		if (!TIFFFetchByteArray(tif, dir, (uint16*) v))

			return (0);

		if (dir->tdir_type == TIFF_BYTE) {

			uint16* vp = (uint16*) v;

			for (i = dir->tdir_count-1; i >= 0; i--)

				v[i] = vp[i];

		} else {

			int16* vp = (int16*) v;

			for (i = dir->tdir_count-1; i >= 0; i--)

				v[i] = vp[i];

		}

		break;

	case TIFF_SHORT:

	case TIFF_SSHORT:

		if (!TIFFFetchShortArray(tif, dir, (uint16*) v))

			return (0);

		if (dir->tdir_type == TIFF_SHORT) {

			uint16* vp = (uint16*) v;

			for (i = dir->tdir_count-1; i >= 0; i--)

				v[i] = vp[i];

		} else {

			int16* vp = (int16*) v;

			for (i = dir->tdir_count-1; i >= 0; i--)

				v[i] = vp[i];

		}

		break;

	case TIFF_LONG:

	case TIFF_SLONG:

		if (!TIFFFetchLongArray(tif, dir, (uint32*) v))

			return (0);

		if (dir->tdir_type == TIFF_LONG) {

			uint32* vp = (uint32*) v;

			for (i = dir->tdir_count-1; i >= 0; i--)

				v[i] = vp[i];

		} else {

			int32* vp = (int32*) v;

			for (i = dir->tdir_count-1; i >= 0; i--)

				v[i] = vp[i];

		}

		break;

	case TIFF_RATIONAL:

	case TIFF_SRATIONAL:

		if (!TIFFFetchRationalArray(tif, dir, (float*) v))

			return (0);

		{ float* vp = (float*) v;

		  for (i = dir->tdir_count-1; i >= 0; i--)

			v[i] = vp[i];

		}

		break;

	case TIFF_FLOAT:

		if (!TIFFFetchFloatArray(tif, dir, (float*) v))

			return (0);

		{ float* vp = (float*) v;

		  for (i = dir->tdir_count-1; i >= 0; i--)

			v[i] = vp[i];

		}

		break;

	case TIFF_DOUBLE:

		return (TIFFFetchDoubleArray(tif, dir, (double*) v));

	default:

		/* TIFF_NOTYPE */

		/* TIFF_ASCII */

		/* TIFF_UNDEFINED */

		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

		    "Cannot read TIFF_ANY type %d for field \"%s\"",

		    _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);

		return (0);

	}

	return (1);

}

/*

 * Fetch a tag that is not handled by special case code.

 */

/* The standard function TIFFFetchNormalTag() could definitely be replaced

   with a simple call to this function, just adding TIFFSetField() as the

   last argument. */

static int

TIFFFetchNormalSubTag(TIFF* tif, TIFFDirEntry* dp, const TIFFFieldInfo* fip,

		      int (*setFieldFn)(TIFF *tif, ttag_t tag, ...))

{

	static char mesg[] = "to fetch tag value";

	int ok = 0;

	if (dp->tdir_count > 1) {		/* array of values */

		char* cp = NULL;

		switch (dp->tdir_type) {

		case TIFF_BYTE:

		case TIFF_SBYTE:

			/* NB: always expand BYTE values to shorts */

			cp = CheckMalloc(tif,

			    dp->tdir_count * sizeof (uint16), mesg);

			ok = cp && TIFFFetchByteArray(tif, dp, (uint16*) cp);

			break;

		case TIFF_SHORT:

		case TIFF_SSHORT:

			cp = CheckMalloc(tif,

			    dp->tdir_count * sizeof (uint16), mesg);

			ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp);

			break;

		case TIFF_LONG:

		case TIFF_SLONG:

			cp = CheckMalloc(tif,

			    dp->tdir_count * sizeof (uint32), mesg);

			ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp);

			break;

		case TIFF_RATIONAL:

		case TIFF_SRATIONAL:

			cp = CheckMalloc(tif,

			    dp->tdir_count * sizeof (float), mesg);

			ok = cp && TIFFFetchRationalArray(tif, dp, (float*) cp);

			break;

		case TIFF_FLOAT:

			cp = CheckMalloc(tif,

			    dp->tdir_count * sizeof (float), mesg);

			ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp);

			break;

		case TIFF_DOUBLE:

			cp = CheckMalloc(tif,

			    dp->tdir_count * sizeof (double), mesg);

			ok = cp && TIFFFetchDoubleArray(tif, dp, (double*) cp);

			break;

		case TIFF_ASCII:

		case TIFF_UNDEFINED:		/* bit of a cheat... */

			/*

			 * Some vendors write strings w/o the trailing

			 * NULL byte, so always append one just in case.

			 */

			cp = CheckMalloc(tif, dp->tdir_count+1, mesg);

			if (ok = (cp && TIFFFetchString(tif, dp, cp)))

				cp[dp->tdir_count] = '\0';	/* XXX */

			break;

		}

		if (ok) {

			ok = (fip->field_passcount ?

			    (*setFieldFn)(tif, dp->tdir_tag, dp->tdir_count, cp)

			  : (*setFieldFn)(tif, dp->tdir_tag, cp));

		}

		if (cp != NULL)

			_TIFFfree(cp);

	} else if (CheckDirCount(tif, dp, 1)) {	/* singleton value */

		switch (dp->tdir_type) {

		case TIFF_BYTE:

		case TIFF_SBYTE:

		case TIFF_SHORT:

		case TIFF_SSHORT:

			/*

			 * If the tag is also acceptable as a LONG or SLONG

			 * then (*setFieldFn) will expect an uint32 parameter

			 * passed to it (through varargs).  Thus, for machines

			 * where sizeof (int) != sizeof (uint32) we must do

			 * a careful check here.  It's hard to say if this

			 * is worth optimizing.

			 *

			 * NB: We use TIFFFieldWithTag here knowing that

			 *     it returns us the first entry in the table

			 *     for the tag and that that entry is for the

			 *     widest potential data type the tag may have.

			 */

			{ TIFFDataType type = fip->field_type;

			  if (type != TIFF_LONG && type != TIFF_SLONG) {

				uint16 v = (uint16)

			   TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);

				ok = (fip->field_passcount ?

				    (*setFieldFn)(tif, dp->tdir_tag, 1, &v)

				  : (*setFieldFn)(tif, dp->tdir_tag, v));

				break;

			  }

			}

			/* fall thru... */

		case TIFF_LONG:

		case TIFF_SLONG:

			{ uint32 v32 =

		    TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);

			  ok = (fip->field_passcount ? 

			      (*setFieldFn)(tif, dp->tdir_tag, 1, &v32)

			    : (*setFieldFn)(tif, dp->tdir_tag, v32));

			}

			break;

		case TIFF_RATIONAL:

		case TIFF_SRATIONAL:

		case TIFF_FLOAT:

			{ float v = (dp->tdir_type == TIFF_FLOAT ? 

			      TIFFFetchFloat(tif, dp)

			    : TIFFFetchRational(tif, dp));

			  ok = (fip->field_passcount ?

			      (*setFieldFn)(tif, dp->tdir_tag, 1, &v)

			    : (*setFieldFn)(tif, dp->tdir_tag, v));

			}

			break;

		case TIFF_DOUBLE:

			{ double v;

			  ok = (TIFFFetchDoubleArray(tif, dp, &v) &&

			    (fip->field_passcount ?

			      (*setFieldFn)(tif, dp->tdir_tag, 1, &v)

			    : (*setFieldFn)(tif, dp->tdir_tag, v))

			  );

			}

			break;

		case TIFF_ASCII:

		case TIFF_UNDEFINED:		/* bit of a cheat... */

			{ char c[2];

			  if (ok = (TIFFFetchString(tif, dp, c) != 0)) {

				c[1] = '\0';		/* XXX paranoid */

				ok = (*setFieldFn)(tif, dp->tdir_tag, c);

			  }

			}

			break;

		}

	}

	return (ok);

}

/* Everything after this is exactly duplicated from the standard tif_dirread.c

   file, necessitated by the fact that they are declared static there so

   we can't call them!

*/

#define	NITEMS(x)	(sizeof (x) / sizeof (x[0]))