[wxWidgets.git] / src / tiff / tif_open.c

/* $Header$ */

/*
 * 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.
 */
#include "tiffiop.h"

void _TIFFSetDefaultCompressionState(TIFF* tif);

static const long typemask[13] = {
	(long)0L,		/* TIFF_NOTYPE */
	(long)0x000000ffL,	/* TIFF_BYTE */
	(long)0xffffffffL,	/* TIFF_ASCII */
	(long)0x0000ffffL,	/* TIFF_SHORT */
	(long)0xffffffffL,	/* TIFF_LONG */
	(long)0xffffffffL,	/* TIFF_RATIONAL */
	(long)0x000000ffL,	/* TIFF_SBYTE */
	(long)0x000000ffL,	/* TIFF_UNDEFINED */
	(long)0x0000ffffL,	/* TIFF_SSHORT */
	(long)0xffffffffL,	/* TIFF_SLONG */
	(long)0xffffffffL,	/* TIFF_SRATIONAL */
	(long)0xffffffffL,	/* TIFF_FLOAT */
	(long)0xffffffffL,	/* TIFF_DOUBLE */
};
static const int bigTypeshift[13] = {
	0,		/* TIFF_NOTYPE */
	24,		/* TIFF_BYTE */
	0,		/* TIFF_ASCII */
	16,		/* TIFF_SHORT */
	0,		/* TIFF_LONG */
	0,		/* TIFF_RATIONAL */
	24,		/* TIFF_SBYTE */
	24,		/* TIFF_UNDEFINED */
	16,		/* TIFF_SSHORT */
	0,		/* TIFF_SLONG */
	0,		/* TIFF_SRATIONAL */
	0,		/* TIFF_FLOAT */
	0,		/* TIFF_DOUBLE */
};
static const int litTypeshift[13] = {
	0,		/* TIFF_NOTYPE */
	0,		/* TIFF_BYTE */
	0,		/* TIFF_ASCII */
	0,		/* TIFF_SHORT */
	0,		/* TIFF_LONG */
	0,		/* TIFF_RATIONAL */
	0,		/* TIFF_SBYTE */
	0,		/* TIFF_UNDEFINED */
	0,		/* TIFF_SSHORT */
	0,		/* TIFF_SLONG */
	0,		/* TIFF_SRATIONAL */
	0,		/* TIFF_FLOAT */
	0,		/* TIFF_DOUBLE */
};

/*
 * Initialize the shift & mask tables, and the
 * byte swapping state according to the file
 * contents and the machine architecture.
 */
static void
TIFFInitOrder(TIFF* tif, int magic, int bigendian)
{
	tif->tif_typemask = typemask;
	if (magic == TIFF_BIGENDIAN) {
		tif->tif_typeshift = bigTypeshift;
		if (!bigendian)
			tif->tif_flags |= TIFF_SWAB;
	} else {
		tif->tif_typeshift = litTypeshift;
		if (bigendian)
			tif->tif_flags |= TIFF_SWAB;
	}
}

int
_TIFFgetMode(const char* mode, const char* module)
{
	int m = -1;

	switch (mode[0]) {
	case 'r':
		m = O_RDONLY;
		if (mode[1] == '+')
			m = O_RDWR;
		break;
	case 'w':
	case 'a':
		m = O_RDWR|O_CREAT;
		if (mode[0] == 'w')
			m |= O_TRUNC;
		break;
	default:
		TIFFError(module, "\"%s\": Bad mode", mode);
		break;
	}
	return (m);
}

TIFF*
TIFFClientOpen(
	const char* name, const char* mode,
	thandle_t clientdata,
	TIFFReadWriteProc readproc,
	TIFFReadWriteProc writeproc,
	TIFFSeekProc seekproc,
	TIFFCloseProc closeproc,
	TIFFSizeProc sizeproc,
	TIFFMapFileProc mapproc,
	TIFFUnmapFileProc unmapproc
)
{
	static const char module[] = "TIFFClientOpen";
	TIFF *tif;
	int m, bigendian;
	const char* cp;

	m = _TIFFgetMode(mode, module);
	if (m == -1)
		goto bad2;
	tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
	if (tif == NULL) {
		TIFFError(module, "%s: Out of memory (TIFF structure)", name);
		goto bad2;
	}
	_TIFFmemset(tif, 0, sizeof (*tif));
	tif->tif_name = (char *)tif + sizeof (TIFF);
	strcpy(tif->tif_name, name);
	tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
	tif->tif_curdir = (tdir_t) -1;		/* non-existent directory */
	tif->tif_curoff = 0;
	tif->tif_curstrip = (tstrip_t) -1;	/* invalid strip */
	tif->tif_row = (uint32) -1;		/* read/write pre-increment */
	tif->tif_clientdata = clientdata;
	if (!readproc || !writeproc || !seekproc || !closeproc
			|| !sizeproc || !mapproc || !unmapproc) {
		TIFFError(module, "One of the client procedures are NULL pointer");
		goto bad3;
	}
	tif->tif_readproc = readproc;
	tif->tif_writeproc = writeproc;
	tif->tif_seekproc = seekproc;
	tif->tif_closeproc = closeproc;
	tif->tif_sizeproc = sizeproc;
	tif->tif_mapproc = mapproc;
	tif->tif_unmapproc = unmapproc;
	_TIFFSetDefaultCompressionState(tif);	/* setup default state */
	/*
	 * Default is to return data MSB2LSB and enable the
	 * use of memory-mapped files and strip chopping when
	 * a file is opened read-only.
	 */
	tif->tif_flags = FILLORDER_MSB2LSB;
	if (m == O_RDONLY )
            tif->tif_flags |= TIFF_MAPPED;

#ifdef STRIPCHOP_DEFAULT
	if (m == O_RDONLY || m == O_RDWR)
		tif->tif_flags |= STRIPCHOP_DEFAULT;
#endif

	{ union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; }
	/*
	 * Process library-specific flags in the open mode string.
	 * The following flags may be used to control intrinsic library
	 * behaviour that may or may not be desirable (usually for
	 * compatibility with some application that claims to support
	 * TIFF but only supports some braindead idea of what the
	 * vendor thinks TIFF is):
	 *
	 * 'l'		use little-endian byte order for creating a file
	 * 'b'		use big-endian byte order for creating a file
	 * 'L'		read/write information using LSB2MSB bit order
	 * 'B'		read/write information using MSB2LSB bit order
	 * 'H'		read/write information using host bit order
	 * 'M'		enable use of memory-mapped files when supported
	 * 'm'		disable use of memory-mapped files
	 * 'C'		enable strip chopping support when reading
	 * 'c'		disable strip chopping support
	 *
	 * The use of the 'l' and 'b' flags is strongly discouraged.
	 * These flags are provided solely because numerous vendors,
	 * typically on the PC, do not correctly support TIFF; they
	 * only support the Intel little-endian byte order.  This
	 * support is not configured by default because it supports
	 * the violation of the TIFF spec that says that readers *MUST*
	 * support both byte orders.  It is strongly recommended that
	 * you not use this feature except to deal with busted apps
	 * that write invalid TIFF.  And even in those cases you should
	 * bang on the vendors to fix their software.
	 *
	 * The 'L', 'B', and 'H' flags are intended for applications
	 * that can optimize operations on data by using a particular
	 * bit order.  By default the library returns data in MSB2LSB
	 * bit order for compatibiltiy with older versions of this
	 * library.  Returning data in the bit order of the native cpu
	 * makes the most sense but also requires applications to check
	 * the value of the FillOrder tag; something they probabyl do
	 * not do right now.
	 *
	 * The 'M' and 'm' flags are provided because some virtual memory
	 * systems exhibit poor behaviour when large images are mapped.
	 * These options permit clients to control the use of memory-mapped
	 * files on a per-file basis.
	 *
	 * The 'C' and 'c' flags are provided because the library support
	 * for chopping up large strips into multiple smaller strips is not
	 * application-transparent and as such can cause problems.  The 'c'
	 * option permits applications that only want to look at the tags,
	 * for example, to get the unadulterated TIFF tag information.
	 */
	for (cp = mode; *cp; cp++)
		switch (*cp) {
		case 'b':
			if ((m&O_CREAT) && !bigendian)
				tif->tif_flags |= TIFF_SWAB;
			break;
		case 'l':
			if ((m&O_CREAT) && bigendian)
				tif->tif_flags |= TIFF_SWAB;
			break;
		case 'B':
			tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
			    FILLORDER_MSB2LSB;
			break;
		case 'L':
			tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
			    FILLORDER_LSB2MSB;
			break;
		case 'H':
			tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
			    HOST_FILLORDER;
			break;
		case 'M':
			if (m == O_RDONLY)
				tif->tif_flags |= TIFF_MAPPED;
			break;
		case 'm':
			if (m == O_RDONLY)
				tif->tif_flags &= ~TIFF_MAPPED;
			break;
		case 'C':
			if (m == O_RDONLY)
				tif->tif_flags |= TIFF_STRIPCHOP;
			break;
		case 'c':
			if (m == O_RDONLY)
				tif->tif_flags &= ~TIFF_STRIPCHOP;
			break;
		}
	/*
	 * Read in TIFF header.
	 */
	if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
		if (tif->tif_mode == O_RDONLY) {
			TIFFError(name, "Cannot read TIFF header");
			goto bad;
		}
		/*
		 * Setup header and write.
		 */
		tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
		    ? (bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN)
		    : (bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN);
		tif->tif_header.tiff_version = TIFF_VERSION;
		if (tif->tif_flags & TIFF_SWAB)
			TIFFSwabShort(&tif->tif_header.tiff_version);
		tif->tif_header.tiff_diroff = 0;	/* filled in later */

                /*
                 * This seek shouldn't be necessary, but I have had some
                 * crazy problems with a failed fseek() on Solaris leaving
                 * the current file pointer out of whack when an fwrite()
                 * is done. 
                 */
                TIFFSeekFile( tif, 0, SEEK_SET );

		if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
			TIFFError(name, "Error writing TIFF header");
			goto bad;
		}
		/*
		 * Setup the byte order handling.
		 */
		TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
		/*
		 * Setup default directory.
		 */
		if (!TIFFDefaultDirectory(tif))
			goto bad;
		tif->tif_diroff = 0;
		tif->tif_dirlist = NULL;
		tif->tif_dirnumber = 0;
		return (tif);
	}
	/*
	 * Setup the byte order handling.
	 */
	if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
	    tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) {
		TIFFError(name,  "Not a TIFF file, bad magic number %d (0x%x)",
		    tif->tif_header.tiff_magic,
		    tif->tif_header.tiff_magic);
		goto bad;
	}
	TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
	/*
	 * Swap header if required.
	 */
	if (tif->tif_flags & TIFF_SWAB) {
		TIFFSwabShort(&tif->tif_header.tiff_version);
		TIFFSwabLong(&tif->tif_header.tiff_diroff);
	}
	/*
	 * Now check version (if needed, it's been byte-swapped).
	 * Note that this isn't actually a version number, it's a
	 * magic number that doesn't change (stupid).
	 */
	if (tif->tif_header.tiff_version != TIFF_VERSION) {
		TIFFError(name,
		    "Not a TIFF file, bad version number %d (0x%x)",
		    tif->tif_header.tiff_version,
		    tif->tif_header.tiff_version); 
		goto bad;
	}
	tif->tif_flags |= TIFF_MYBUFFER;
	tif->tif_rawcp = tif->tif_rawdata = 0;
	tif->tif_rawdatasize = 0;
	/*
	 * Setup initial directory.
	 */
	switch (mode[0]) {
	case 'r':
		tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
		/*
		 * Try to use a memory-mapped file if the client
		 * has not explicitly suppressed usage with the
		 * 'm' flag in the open mode (see above).
		 */
		if ((tif->tif_flags & TIFF_MAPPED) &&
	!TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
			tif->tif_flags &= ~TIFF_MAPPED;
		if (TIFFReadDirectory(tif)) {
			tif->tif_rawcc = -1;
			tif->tif_flags |= TIFF_BUFFERSETUP;
			return (tif);
		}
		break;
	case 'a':
		/*
		 * New directories are automatically append
		 * to the end of the directory chain when they
		 * are written out (see TIFFWriteDirectory).
		 */
		if (!TIFFDefaultDirectory(tif))
			goto bad;
		return (tif);
	}
bad:
	tif->tif_mode = O_RDONLY;	/* XXX avoid flush */
	TIFFClose(tif);
	return ((TIFF*)0);
bad2:
	(void) (*closeproc)(clientdata);
bad3:
	return ((TIFF*)0);
}

/*
 * Query functions to access private data.
 */

/*
 * Return open file's name.
 */
const char *
TIFFFileName(TIFF* tif)
{
	return (tif->tif_name);
}

/*
 * Return open file's I/O descriptor.
 */
int
TIFFFileno(TIFF* tif)
{
	return (tif->tif_fd);
}

/*
 * Return read/write mode.
 */
int
TIFFGetMode(TIFF* tif)
{
	return (tif->tif_mode);
}

/*
 * Return nonzero if file is organized in
 * tiles; zero if organized as strips.
 */
int
TIFFIsTiled(TIFF* tif)
{
	return (isTiled(tif));
}

/*
 * Return current row being read/written.
 */
uint32
TIFFCurrentRow(TIFF* tif)
{
	return (tif->tif_row);
}

/*
 * Return index of the current directory.
 */
tdir_t
TIFFCurrentDirectory(TIFF* tif)
{
	return (tif->tif_curdir);
}

/*
 * Return current strip.
 */
tstrip_t
TIFFCurrentStrip(TIFF* tif)
{
	return (tif->tif_curstrip);
}

/*
 * Return current tile.
 */
ttile_t
TIFFCurrentTile(TIFF* tif)
{
	return (tif->tif_curtile);
}

/*
 * Return nonzero if the file has byte-swapped data.
 */
int
TIFFIsByteSwapped(TIFF* tif)
{
	return ((tif->tif_flags & TIFF_SWAB) != 0);
}

/*
 * Return nonzero if the data is returned up-sampled.
 */
int
TIFFIsUpSampled(TIFF* tif)
{
	return (isUpSampled(tif));
}

/*
 * Return nonzero if the data is returned in MSB-to-LSB bit order.
 */
int
TIFFIsMSB2LSB(TIFF* tif)
{
	return (isFillOrder(tif, FILLORDER_MSB2LSB));
}
Commit	Line	Data
b47c832e RR	1	/* $Header$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	6	*
00cb87b4	7	* Permission to use, copy, modify, distribute, and sell this software and
b47c832e RR	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.
00cb87b4 VZ	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	*
b47c832e RR	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,
00cb87b4 VZ	22	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
00cb87b4 VZ	23	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
b47c832e RR	24	* OF THIS SOFTWARE.
	25	*/
	26
	27	/*
	28	* TIFF Library.
	29	*/
	30	#include "tiffiop.h"
	31
00cb87b4	32	void _TIFFSetDefaultCompressionState(TIFF* tif);
b47c832e RR	33
b47c832e RR	34	static const long typemask[13] = {
00cb87b4 VZ	35	(long)0L, /* TIFF_NOTYPE */
	36	(long)0x000000ffL, /* TIFF_BYTE */
	37	(long)0xffffffffL, /* TIFF_ASCII */
	38	(long)0x0000ffffL, /* TIFF_SHORT */
	39	(long)0xffffffffL, /* TIFF_LONG */
	40	(long)0xffffffffL, /* TIFF_RATIONAL */
	41	(long)0x000000ffL, /* TIFF_SBYTE */
	42	(long)0x000000ffL, /* TIFF_UNDEFINED */
	43	(long)0x0000ffffL, /* TIFF_SSHORT */
	44	(long)0xffffffffL, /* TIFF_SLONG */
	45	(long)0xffffffffL, /* TIFF_SRATIONAL */
	46	(long)0xffffffffL, /* TIFF_FLOAT */
	47	(long)0xffffffffL, /* TIFF_DOUBLE */
b47c832e RR	48	};
	49	static const int bigTypeshift[13] = {
	50	0, /* TIFF_NOTYPE */
	51	24, /* TIFF_BYTE */
	52	0, /* TIFF_ASCII */
	53	16, /* TIFF_SHORT */
	54	0, /* TIFF_LONG */
	55	0, /* TIFF_RATIONAL */
	56	24, /* TIFF_SBYTE */
	57	24, /* TIFF_UNDEFINED */
	58	16, /* TIFF_SSHORT */
	59	0, /* TIFF_SLONG */
	60	0, /* TIFF_SRATIONAL */
	61	0, /* TIFF_FLOAT */
	62	0, /* TIFF_DOUBLE */
	63	};
	64	static const int litTypeshift[13] = {
	65	0, /* TIFF_NOTYPE */
	66	0, /* TIFF_BYTE */
	67	0, /* TIFF_ASCII */
	68	0, /* TIFF_SHORT */
	69	0, /* TIFF_LONG */
	70	0, /* TIFF_RATIONAL */
	71	0, /* TIFF_SBYTE */
	72	0, /* TIFF_UNDEFINED */
	73	0, /* TIFF_SSHORT */
	74	0, /* TIFF_SLONG */
	75	0, /* TIFF_SRATIONAL */
	76	0, /* TIFF_FLOAT */
	77	0, /* TIFF_DOUBLE */
	78	};
	79
	80	/*
	81	* Initialize the shift & mask tables, and the
	82	* byte swapping state according to the file
	83	* contents and the machine architecture.
	84	*/
	85	static void
	86	TIFFInitOrder(TIFF* tif, int magic, int bigendian)
	87	{
	88	tif->tif_typemask = typemask;
	89	if (magic == TIFF_BIGENDIAN) {
	90	tif->tif_typeshift = bigTypeshift;
	91	if (!bigendian)
	92	tif->tif_flags \|= TIFF_SWAB;
	93	} else {
	94	tif->tif_typeshift = litTypeshift;
	95	if (bigendian)
	96	tif->tif_flags \|= TIFF_SWAB;
	97	}
	98	}
	99
	100	int
	101	_TIFFgetMode(const char* mode, const char* module)
	102	{
	103	int m = -1;
	104
	105	switch (mode[0]) {
	106	case 'r':
	107	m = O_RDONLY;
	108	if (mode[1] == '+')
	109	m = O_RDWR;
	110	break;
	111	case 'w':
112	case 'a':
113	m = O_RDWR\|O_CREAT;
114	if (mode[0] == 'w')
115	m \|= O_TRUNC;
116	break;
117	default:
118	TIFFError(module, "\"%s\": Bad mode", mode);
119	break;
120	}
121	return (m);
122	}
123
124	TIFF*
125	TIFFClientOpen(
126	const char* name, const char* mode,
127	thandle_t clientdata,
128	TIFFReadWriteProc readproc,
129	TIFFReadWriteProc writeproc,
130	TIFFSeekProc seekproc,
131	TIFFCloseProc closeproc,
132	TIFFSizeProc sizeproc,
133	TIFFMapFileProc mapproc,
134	TIFFUnmapFileProc unmapproc
135	)
136	{
137	static const char module[] = "TIFFClientOpen";
138	TIFF *tif;
139	int m, bigendian;
140	const char* cp;
141
142	m = _TIFFgetMode(mode, module);
143	if (m == -1)
144	goto bad2;
145	tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
146	if (tif == NULL) {
147	TIFFError(module, "%s: Out of memory (TIFF structure)", name);
148	goto bad2;
149	}
150	_TIFFmemset(tif, 0, sizeof (*tif));
151	tif->tif_name = (char *)tif + sizeof (TIFF);
152	strcpy(tif->tif_name, name);
153	tif->tif_mode = m &~ (O_CREAT\|O_TRUNC);
154	tif->tif_curdir = (tdir_t) -1; /* non-existent directory */
155	tif->tif_curoff = 0;
156	tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */
157	tif->tif_row = (uint32) -1; /* read/write pre-increment */
158	tif->tif_clientdata = clientdata;
00cb87b4 VZ	159	if (!readproc \|\| !writeproc \|\| !seekproc \|\| !closeproc
	160	\|\| !sizeproc \|\| !mapproc \|\| !unmapproc) {
	161	TIFFError(module, "One of the client procedures are NULL pointer");
	162	goto bad3;
	163	}
b47c832e RR	164	tif->tif_readproc = readproc;
	165	tif->tif_writeproc = writeproc;
	166	tif->tif_seekproc = seekproc;
	167	tif->tif_closeproc = closeproc;
	168	tif->tif_sizeproc = sizeproc;
	169	tif->tif_mapproc = mapproc;
	170	tif->tif_unmapproc = unmapproc;
	171	_TIFFSetDefaultCompressionState(tif); /* setup default state */
	172	/*
	173	* Default is to return data MSB2LSB and enable the
	174	* use of memory-mapped files and strip chopping when
	175	* a file is opened read-only.
	176	*/
	177	tif->tif_flags = FILLORDER_MSB2LSB;
00cb87b4 VZ	178	if (m == O_RDONLY )
	179	tif->tif_flags \|= TIFF_MAPPED;
	180
b47c832e	181	#ifdef STRIPCHOP_DEFAULT
00cb87b4 VZ	182	if (m == O_RDONLY \|\| m == O_RDWR)
00cb87b4 VZ	183	tif->tif_flags \|= STRIPCHOP_DEFAULT;
b47c832e RR	184	#endif
	185
	186	{ union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; }
	187	/*
	188	* Process library-specific flags in the open mode string.
	189	* The following flags may be used to control intrinsic library
	190	* behaviour that may or may not be desirable (usually for
	191	* compatibility with some application that claims to support
	192	* TIFF but only supports some braindead idea of what the
	193	* vendor thinks TIFF is):
	194	*
	195	* 'l' use little-endian byte order for creating a file
	196	* 'b' use big-endian byte order for creating a file
	197	* 'L' read/write information using LSB2MSB bit order
	198	* 'B' read/write information using MSB2LSB bit order
	199	* 'H' read/write information using host bit order
	200	* 'M' enable use of memory-mapped files when supported
	201	* 'm' disable use of memory-mapped files
	202	* 'C' enable strip chopping support when reading
	203	* 'c' disable strip chopping support
	204	*
	205	* The use of the 'l' and 'b' flags is strongly discouraged.
	206	* These flags are provided solely because numerous vendors,
	207	* typically on the PC, do not correctly support TIFF; they
	208	* only support the Intel little-endian byte order. This
	209	* support is not configured by default because it supports
	210	* the violation of the TIFF spec that says that readers MUST
	211	* support both byte orders. It is strongly recommended that
	212	* you not use this feature except to deal with busted apps
	213	* that write invalid TIFF. And even in those cases you should
	214	* bang on the vendors to fix their software.
	215	*
	216	* The 'L', 'B', and 'H' flags are intended for applications
	217	* that can optimize operations on data by using a particular
	218	* bit order. By default the library returns data in MSB2LSB
	219	* bit order for compatibiltiy with older versions of this
	220	* library. Returning data in the bit order of the native cpu
	221	* makes the most sense but also requires applications to check
	222	* the value of the FillOrder tag; something they probabyl do
	223	* not do right now.
	224	*
	225	* The 'M' and 'm' flags are provided because some virtual memory
	226	* systems exhibit poor behaviour when large images are mapped.
	227	* These options permit clients to control the use of memory-mapped
	228	* files on a per-file basis.
	229	*
	230	* The 'C' and 'c' flags are provided because the library support
	231	* for chopping up large strips into multiple smaller strips is not
	232	* application-transparent and as such can cause problems. The 'c'
	233	* option permits applications that only want to look at the tags,
	234	* for example, to get the unadulterated TIFF tag information.
	235	*/
	236	for (cp = mode; *cp; cp++)
	237	switch (*cp) {
	238	case 'b':
	239	if ((m&O_CREAT) && !bigendian)
	240	tif->tif_flags \|= TIFF_SWAB;
	241	break;
	242	case 'l':
	243	if ((m&O_CREAT) && bigendian)
	244	tif->tif_flags \|= TIFF_SWAB;
	245	break;
	246	case 'B':
	247	tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) \|
248	FILLORDER_MSB2LSB;
249	break;
250	case 'L':
251	tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) \|
252	FILLORDER_LSB2MSB;
253	break;
254	case 'H':
255	tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) \|
256	HOST_FILLORDER;
257	break;
258	case 'M':
259	if (m == O_RDONLY)
260	tif->tif_flags \|= TIFF_MAPPED;
261	break;
262	case 'm':
263	if (m == O_RDONLY)
264	tif->tif_flags &= ~TIFF_MAPPED;
265	break;
266	case 'C':
267	if (m == O_RDONLY)
268	tif->tif_flags \|= TIFF_STRIPCHOP;
269	break;
270	case 'c':
271	if (m == O_RDONLY)
272	tif->tif_flags &= ~TIFF_STRIPCHOP;
273	break;
274	}
275	/*
276	* Read in TIFF header.
277	*/
278	if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
279	if (tif->tif_mode == O_RDONLY) {
280	TIFFError(name, "Cannot read TIFF header");
281	goto bad;
282	}
283	/*
284	* Setup header and write.
285	*/
286	tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
287	? (bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN)
288	: (bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN);
289	tif->tif_header.tiff_version = TIFF_VERSION;
290	if (tif->tif_flags & TIFF_SWAB)
291	TIFFSwabShort(&tif->tif_header.tiff_version);
292	tif->tif_header.tiff_diroff = 0; /* filled in later */
00cb87b4 VZ	293
	294	/*
	295	* This seek shouldn't be necessary, but I have had some
	296	* crazy problems with a failed fseek() on Solaris leaving
	297	* the current file pointer out of whack when an fwrite()
	298	* is done.
	299	*/
	300	TIFFSeekFile( tif, 0, SEEK_SET );
	301
b47c832e RR	302	if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
	303	TIFFError(name, "Error writing TIFF header");
	304	goto bad;
	305	}
	306	/*
	307	* Setup the byte order handling.
	308	*/
	309	TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
	310	/*
	311	* Setup default directory.
	312	*/
	313	if (!TIFFDefaultDirectory(tif))
	314	goto bad;
	315	tif->tif_diroff = 0;
00cb87b4 VZ	316	tif->tif_dirlist = NULL;
00cb87b4 VZ	317	tif->tif_dirnumber = 0;
b47c832e RR	318	return (tif);
	319	}
	320	/*
	321	* Setup the byte order handling.
	322	*/
	323	if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
	324	tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) {
	325	TIFFError(name, "Not a TIFF file, bad magic number %d (0x%x)",
	326	tif->tif_header.tiff_magic,
	327	tif->tif_header.tiff_magic);
	328	goto bad;
	329	}
	330	TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
	331	/*
	332	* Swap header if required.
	333	*/
	334	if (tif->tif_flags & TIFF_SWAB) {
	335	TIFFSwabShort(&tif->tif_header.tiff_version);
	336	TIFFSwabLong(&tif->tif_header.tiff_diroff);
	337	}
	338	/*
	339	* Now check version (if needed, it's been byte-swapped).
	340	* Note that this isn't actually a version number, it's a
	341	* magic number that doesn't change (stupid).
	342	*/
	343	if (tif->tif_header.tiff_version != TIFF_VERSION) {
	344	TIFFError(name,
	345	"Not a TIFF file, bad version number %d (0x%x)",
	346	tif->tif_header.tiff_version,
00cb87b4	347	tif->tif_header.tiff_version);
b47c832e RR	348	goto bad;
	349	}
	350	tif->tif_flags \|= TIFF_MYBUFFER;
	351	tif->tif_rawcp = tif->tif_rawdata = 0;
	352	tif->tif_rawdatasize = 0;
	353	/*
	354	* Setup initial directory.
	355	*/
	356	switch (mode[0]) {
	357	case 'r':
	358	tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
	359	/*
	360	* Try to use a memory-mapped file if the client
	361	* has not explicitly suppressed usage with the
	362	* 'm' flag in the open mode (see above).
	363	*/
	364	if ((tif->tif_flags & TIFF_MAPPED) &&
	365	!TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
	366	tif->tif_flags &= ~TIFF_MAPPED;
	367	if (TIFFReadDirectory(tif)) {
	368	tif->tif_rawcc = -1;
	369	tif->tif_flags \|= TIFF_BUFFERSETUP;
	370	return (tif);
	371	}
	372	break;
	373	case 'a':
	374	/*
	375	* New directories are automatically append
	376	* to the end of the directory chain when they
	377	* are written out (see TIFFWriteDirectory).
	378	*/
	379	if (!TIFFDefaultDirectory(tif))
	380	goto bad;
	381	return (tif);
	382	}
	383	bad:
	384	tif->tif_mode = O_RDONLY; /* XXX avoid flush */
	385	TIFFClose(tif);
	386	return ((TIFF*)0);
	387	bad2:
	388	(void) (*closeproc)(clientdata);
00cb87b4	389	bad3:
b47c832e RR	390	return ((TIFF*)0);
	391	}
	392
	393	/*
	394	* Query functions to access private data.
	395	*/
	396
	397	/*
	398	* Return open file's name.
	399	*/
	400	const char *
	401	TIFFFileName(TIFF* tif)
	402	{
	403	return (tif->tif_name);
	404	}
	405
	406	/*
	407	* Return open file's I/O descriptor.
	408	*/
	409	int
	410	TIFFFileno(TIFF* tif)
	411	{
	412	return (tif->tif_fd);
	413	}
	414
	415	/*
	416	* Return read/write mode.
	417	*/
	418	int
	419	TIFFGetMode(TIFF* tif)
	420	{
	421	return (tif->tif_mode);
	422	}
	423
	424	/*
	425	* Return nonzero if file is organized in
	426	* tiles; zero if organized as strips.
	427	*/
	428	int
	429	TIFFIsTiled(TIFF* tif)
	430	{
	431	return (isTiled(tif));
	432	}
	433
	434	/*
	435	* Return current row being read/written.
	436	*/
	437	uint32
	438	TIFFCurrentRow(TIFF* tif)
	439	{
	440	return (tif->tif_row);
	441	}
	442
	443	/*
	444	* Return index of the current directory.
	445	*/
	446	tdir_t
	447	TIFFCurrentDirectory(TIFF* tif)
	448	{
	449	return (tif->tif_curdir);
	450	}
	451
	452	/*
	453	* Return current strip.
454	*/
455	tstrip_t
456	TIFFCurrentStrip(TIFF* tif)
457	{
458	return (tif->tif_curstrip);
459	}
460
461	/*
462	* Return current tile.
463	*/
464	ttile_t
465	TIFFCurrentTile(TIFF* tif)
466	{
467	return (tif->tif_curtile);
468	}
469
470	/*
471	* Return nonzero if the file has byte-swapped data.
472	*/
473	int
474	TIFFIsByteSwapped(TIFF* tif)
475	{
476	return ((tif->tif_flags & TIFF_SWAB) != 0);
477	}
478
479	/*
480	* Return nonzero if the data is returned up-sampled.
481	*/
482	int
483	TIFFIsUpSampled(TIFF* tif)
484	{
485	return (isUpSampled(tif));
486	}
487
488	/*
489	* Return nonzero if the data is returned in MSB-to-LSB bit order.
490	*/
491	int
492	TIFFIsMSB2LSB(TIFF* tif)
493	{
494	return (isFillOrder(tif, FILLORDER_MSB2LSB));
495	}