/* $Id: tif_dirread.c,v 1.178 2012-08-19 16:56:34 bfriesen Exp $ */

/*

 * Copyright (c) 1988-1997 Sam Leffler

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

 *

 * Permission to use, copy, modify, distribute, and sell this software and

 * its documentation for any purpose is hereby granted without fee, provided

 * that (i) the above copyright notices and this permission notice appear in

 * all copies of the software and related documentation, and (ii) the names of

 * Sam Leffler and Silicon Graphics may not be used in any advertising or

 * publicity relating to the software without the specific, prior written

 * permission of Sam Leffler and Silicon Graphics.

 *

 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

 *

 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR

 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

 * OF THIS SOFTWARE.

 */

/*

 * TIFF Library.

 *

 * Directory Read Support Routines.

 */

/* Suggested pending improvements:

 * - add a field 'ignore' to the TIFFDirEntry structure, to flag status,

 *   eliminating current use of the IGNORE value, and therefore eliminating

 *   current irrational behaviour on tags with tag id code 0

 * - add a field 'field_info' to the TIFFDirEntry structure, and set that with

 *   the pointer to the appropriate TIFFField structure early on in

 *   TIFFReadDirectory, so as to eliminate current possibly repetitive lookup.

 */

#include "tiffiop.h"

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

#define FAILED_FII    ((uint32) -1)

#ifdef 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

enum TIFFReadDirEntryErr {

	TIFFReadDirEntryErrOk = 0,

	TIFFReadDirEntryErrCount = 1,

	TIFFReadDirEntryErrType = 2,

	TIFFReadDirEntryErrIo = 3,

	TIFFReadDirEntryErrRange = 4,

	TIFFReadDirEntryErrPsdif = 5,

	TIFFReadDirEntryErrSizesan = 6,

	TIFFReadDirEntryErrAlloc = 7,

};

static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, void** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEntry* direntry, float** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value);

#if 0

static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFDirEntry* direntry, double* value);

#endif

static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value);

static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8* value);

static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value);

static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16* value);

static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value);

static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF* tif, TIFFDirEntry* direntry, double* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF* tif, TIFFDirEntry* direntry, double* value);

static void TIFFReadDirEntryCheckedFloat(TIFF* tif, TIFFDirEntry* direntry, float* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF* tif, TIFFDirEntry* direntry, double* value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongLong8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong(uint32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongSlong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sshort(int16 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong(int32 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong8(int64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlong8Long8(uint64 value);

static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF* tif, uint64 offset, tmsize_t size, void* dest);

static void TIFFReadDirEntryOutputErr(TIFF* tif, enum TIFFReadDirEntryErr err, const char* module, const char* tagname, int recover);

static void TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16 dircount);

static TIFFDirEntry* TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16 dircount, uint16 tagid);

static void TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii);

static int EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount);

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

static int TIFFCheckDirOffset(TIFF* tif, uint64 diroff);

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

static uint16 TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, uint64* nextdiroff);

static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*, int recover);

static int TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp);

static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*);

static void ChopUpSingleUncompressedStrip(TIFF*);

static uint64 TIFFReadUInt64(const uint8 *value);

typedef union _UInt64Aligned_t

{

        double d;

	uint64 l;

	uint32 i[2];

	uint16 s[4];

	uint8  c[8];

} UInt64Aligned_t;

/*

  Unaligned safe copy of a uint64 value from an octet array.

*/

static uint64 TIFFReadUInt64(const uint8 *value)

{

	UInt64Aligned_t result;

	result.c[0]=value[0];

	result.c[1]=value[1];

	result.c[2]=value[2];

	result.c[3]=value[3];

	result.c[4]=value[4];

	result.c[5]=value[5];

	result.c[6]=value[6];

	result.c[7]=value[7];

	return result.l;

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_BYTE:

			TIFFReadDirEntryCheckedByte(tif,direntry,value);

			return(TIFFReadDirEntryErrOk);

		case TIFF_SBYTE:

			{

				int8 m;

				TIFFReadDirEntryCheckedSbyte(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeByteSbyte(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SHORT:

			{

				uint16 m;

				TIFFReadDirEntryCheckedShort(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeByteShort(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SSHORT:

			{

				int16 m;

				TIFFReadDirEntryCheckedSshort(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeByteSshort(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG:

			{

				uint32 m;

				TIFFReadDirEntryCheckedLong(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeByteLong(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG:

			{

				int32 m;

				TIFFReadDirEntryCheckedSlong(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeByteSlong(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

			{

				uint64 m;

				err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeByteLong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG8:

			{

				int64 m;

				err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeByteSlong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint8)m;

				return(TIFFReadDirEntryErrOk);

			}

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_BYTE:

			{

				uint8 m;

				TIFFReadDirEntryCheckedByte(tif,direntry,&m);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SBYTE:

			{

				int8 m;

				TIFFReadDirEntryCheckedSbyte(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeShortSbyte(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SHORT:

			TIFFReadDirEntryCheckedShort(tif,direntry,value);

			return(TIFFReadDirEntryErrOk);

		case TIFF_SSHORT:

			{

				int16 m;

				TIFFReadDirEntryCheckedSshort(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeShortSshort(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG:

			{

				uint32 m;

				TIFFReadDirEntryCheckedLong(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeShortLong(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG:

			{

				int32 m;

				TIFFReadDirEntryCheckedSlong(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeShortSlong(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

			{

				uint64 m;

				err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeShortLong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG8:

			{

				int64 m;

				err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeShortSlong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint16)m;

				return(TIFFReadDirEntryErrOk);

			}

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_BYTE:

			{

				uint8 m;

				TIFFReadDirEntryCheckedByte(tif,direntry,&m);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SBYTE:

			{

				int8 m;

				TIFFReadDirEntryCheckedSbyte(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeLongSbyte(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SHORT:

			{

				uint16 m;

				TIFFReadDirEntryCheckedShort(tif,direntry,&m);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SSHORT:

			{

				int16 m;

				TIFFReadDirEntryCheckedSshort(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeLongSshort(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG:

			TIFFReadDirEntryCheckedLong(tif,direntry,value);

			return(TIFFReadDirEntryErrOk);

		case TIFF_SLONG:

			{

				int32 m;

				TIFFReadDirEntryCheckedSlong(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeLongSlong(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

			{

				uint64 m;

				err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeLongLong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG8:

			{

				int64 m;

				err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeLongSlong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint32)m;

				return(TIFFReadDirEntryErrOk);

			}

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_BYTE:

			{

				uint8 m;

				TIFFReadDirEntryCheckedByte(tif,direntry,&m);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SBYTE:

			{

				int8 m;

				TIFFReadDirEntryCheckedSbyte(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeLong8Sbyte(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SHORT:

			{

				uint16 m;

				TIFFReadDirEntryCheckedShort(tif,direntry,&m);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SSHORT:

			{

				int16 m;

				TIFFReadDirEntryCheckedSshort(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeLong8Sshort(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG:

			{

				uint32 m;

				TIFFReadDirEntryCheckedLong(tif,direntry,&m);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG:

			{

				int32 m;

				TIFFReadDirEntryCheckedSlong(tif,direntry,&m);

				err=TIFFReadDirEntryCheckRangeLong8Slong(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

			err=TIFFReadDirEntryCheckedLong8(tif,direntry,value);

			return(err);

		case TIFF_SLONG8:

			{

				int64 m;

				err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				err=TIFFReadDirEntryCheckRangeLong8Slong8(m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_BYTE:

			{

				uint8 m;

				TIFFReadDirEntryCheckedByte(tif,direntry,&m);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SBYTE:

			{

				int8 m;

				TIFFReadDirEntryCheckedSbyte(tif,direntry,&m);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SHORT:

			{

				uint16 m;

				TIFFReadDirEntryCheckedShort(tif,direntry,&m);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SSHORT:

			{

				int16 m;

				TIFFReadDirEntryCheckedSshort(tif,direntry,&m);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG:

			{

				uint32 m;

				TIFFReadDirEntryCheckedLong(tif,direntry,&m);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG:

			{

				int32 m;

				TIFFReadDirEntryCheckedSlong(tif,direntry,&m);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

			{

				uint64 m;

				err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

#if defined(__WIN32__) && (_MSC_VER < 1500)

				/*

				 * XXX: MSVC 6.0 does not support conversion

				 * of 64-bit integers into floating point

				 * values.

				 */

				*value = _TIFFUInt64ToFloat(m);

#else

				*value=(float)m;

#endif

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG8:

			{

				int64 m;

				err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_RATIONAL:

			{

				double m;

				err=TIFFReadDirEntryCheckedRational(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SRATIONAL:

			{

				double m;

				err=TIFFReadDirEntryCheckedSrational(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_FLOAT:

			TIFFReadDirEntryCheckedFloat(tif,direntry,value);

			return(TIFFReadDirEntryErrOk);

		case TIFF_DOUBLE:

			{

				double m;

				err=TIFFReadDirEntryCheckedDouble(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(float)m;

				return(TIFFReadDirEntryErrOk);

			}

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_BYTE:

			{

				uint8 m;

				TIFFReadDirEntryCheckedByte(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SBYTE:

			{

				int8 m;

				TIFFReadDirEntryCheckedSbyte(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SHORT:

			{

				uint16 m;

				TIFFReadDirEntryCheckedShort(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SSHORT:

			{

				int16 m;

				TIFFReadDirEntryCheckedSshort(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG:

			{

				uint32 m;

				TIFFReadDirEntryCheckedLong(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG:

			{

				int32 m;

				TIFFReadDirEntryCheckedSlong(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

			{

				uint64 m;

				err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

#if defined(__WIN32__) && (_MSC_VER < 1500)

				/*

				 * XXX: MSVC 6.0 does not support conversion

				 * of 64-bit integers into floating point

				 * values.

				 */

				*value = _TIFFUInt64ToDouble(m);

#else

				*value = (double)m;

#endif

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_SLONG8:

			{

				int64 m;

				err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m);

				if (err!=TIFFReadDirEntryErrOk)

					return(err);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_RATIONAL:

			err=TIFFReadDirEntryCheckedRational(tif,direntry,value);

			return(err);

		case TIFF_SRATIONAL:

			err=TIFFReadDirEntryCheckedSrational(tif,direntry,value);

			return(err);

		case TIFF_FLOAT:

			{

				float m;

				TIFFReadDirEntryCheckedFloat(tif,direntry,&m);

				*value=(double)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_DOUBLE:

			err=TIFFReadDirEntryCheckedDouble(tif,direntry,value);

			return(err);

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value)

{

	enum TIFFReadDirEntryErr err;

	if (direntry->tdir_count!=1)

		return(TIFFReadDirEntryErrCount);

	switch (direntry->tdir_type)

	{

		case TIFF_LONG:

		case TIFF_IFD:

			{

				uint32 m;

				TIFFReadDirEntryCheckedLong(tif,direntry,&m);

				*value=(uint64)m;

				return(TIFFReadDirEntryErrOk);

			}

		case TIFF_LONG8:

		case TIFF_IFD8:

			err=TIFFReadDirEntryCheckedLong8(tif,direntry,value);

			return(err);

		default:

			return(TIFFReadDirEntryErrType);

	}

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, void** value)

{

	int typesize;

	uint32 datasize;

	void* data;

	typesize=TIFFDataWidth(direntry->tdir_type);

	if ((direntry->tdir_count==0)||(typesize==0))

	{

		*value=0;

		return(TIFFReadDirEntryErrOk);

	}

        (void) desttypesize;

        /* 

         * As a sanity check, make sure we have no more than a 2GB tag array 

         * in either the current data type or the dest data type.  This also

         * avoids problems with overflow of tmsize_t on 32bit systems.

         */

	if ((uint64)(2147483647/typesize)<direntry->tdir_count)

		return(TIFFReadDirEntryErrSizesan);

	if ((uint64)(2147483647/desttypesize)<direntry->tdir_count)

		return(TIFFReadDirEntryErrSizesan);

	*count=(uint32)direntry->tdir_count;

	datasize=(*count)*typesize;

	assert((tmsize_t)datasize>0);

	data=_TIFFCheckMalloc(tif, *count, typesize, "ReadDirEntryArray");

	if (data==0)

		return(TIFFReadDirEntryErrAlloc);

	if (!(tif->tif_flags&TIFF_BIGTIFF))

	{

		if (datasize<=4)

			_TIFFmemcpy(data,&direntry->tdir_offset,datasize);

		else

		{

			enum TIFFReadDirEntryErr err;

			uint32 offset = direntry->tdir_offset.toff_long;

			if (tif->tif_flags&TIFF_SWAB)

				TIFFSwabLong(&offset);

			err=TIFFReadDirEntryData(tif,(uint64)offset,(tmsize_t)datasize,data);

			if (err!=TIFFReadDirEntryErrOk)

			{

				_TIFFfree(data);

				return(err);

			}

		}

	}

	else

	{

		if (datasize<=8)

			_TIFFmemcpy(data,&direntry->tdir_offset,datasize);

		else

		{

			enum TIFFReadDirEntryErr err;

			uint64 offset = direntry->tdir_offset.toff_long8;

			if (tif->tif_flags&TIFF_SWAB)

				TIFFSwabLong8(&offset);

			err=TIFFReadDirEntryData(tif,offset,(tmsize_t)datasize,data);

			if (err!=TIFFReadDirEntryErrOk)

			{

				_TIFFfree(data);

				return(err);

			}

		}

	}

	*value=data;

	return(TIFFReadDirEntryErrOk);

}

static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8** value)

{

	enum TIFFReadDirEntryErr err;

	uint32 count;

	void* origdata;

	uint8* data;

	switch (direntry->tdir_type)

	{

		case TIFF_ASCII:

		case TIFF_UNDEFINED:

		case TIFF_BYTE:

		case TIFF_SBYTE:

		case TIFF_SHORT:

		case TIFF_SSHORT:

		case TIFF_LONG:

		case TIFF_SLONG:

		case TIFF_LONG8:

		case TIFF_SLONG8:

			break;

		default:

			return(TIFFReadDirEntryErrType);

	}

	err=TIFFReadDirEntryArray(tif,direntry,&count,1,&origdata);

	if ((err!=TIFFReadDirEntryErrOk)||(origdata==0))

	{

		*value=0;

		return(err);

	}

	switch (direntry->tdir_type)

	{

		case TIFF_ASCII:

		case TIFF_UNDEFINED:

		case TIFF_BYTE:

			*value=(uint8*)origdata;

			return(TIFFReadDirEntryErrOk);

		case TIFF_SBYTE:

			{

				int8* m;

				uint32 n;

				m=(int8*)origdata;

				for (n=0; n

				{

					err=TIFFReadDirEntryCheckRangeByteSbyte(*m);

					if (err!=TIFFReadDirEntryErrOk)

					{