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

/* $Id$ */

/*
 * 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"

/*
 * Dummy functions to fill the omitted client procedures.
 */
static int
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
	(void) fd; (void) pbase; (void) psize;
	return (0);
}

static void
_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
{
	(void) fd; (void) base; (void) size;
}

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:
		TIFFErrorExt(0, 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;
	const char* cp;

	/* The following are configuration checks. They should be redundant, but should not
	 * compile to any actual code in an optimised release build anyway. If any of them
	 * fail, (makefile-based or other) configuration is not correct */
	assert(sizeof(uint8)==1);
	assert(sizeof(int8)==1);
	assert(sizeof(uint16)==2);
	assert(sizeof(int16)==2);
	assert(sizeof(uint32)==4);
	assert(sizeof(int32)==4);
	assert(sizeof(uint64)==8);
	assert(sizeof(int64)==8);
	assert(sizeof(tmsize_t)==sizeof(void*));
	{
		union{
			uint8 a8[2];
			uint16 a16;
		} n;
		n.a8[0]=1;
		n.a8[1]=0;
		#ifdef WORDS_BIGENDIAN
		assert(n.a16==256);
		#else
		assert(n.a16==1);
		#endif
	}

	m = _TIFFgetMode(mode, module);
	if (m == -1)
		goto bad2;
	tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
	if (tif == NULL) {
		TIFFErrorExt(clientdata, 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 = (uint16) -1;		/* non-existent directory */
	tif->tif_curoff = 0;
	tif->tif_curstrip = (uint32) -1;	/* invalid strip */
	tif->tif_row = (uint32) -1;		/* read/write pre-increment */
	tif->tif_clientdata = clientdata;
	if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
		TIFFErrorExt(clientdata, module,
		    "One of the client procedures is NULL pointer.");
		goto bad2;
	}
	tif->tif_readproc = readproc;
	tif->tif_writeproc = writeproc;
	tif->tif_seekproc = seekproc;
	tif->tif_closeproc = closeproc;
	tif->tif_sizeproc = sizeproc;
	if (mapproc)
		tif->tif_mapproc = mapproc;
	else
		tif->tif_mapproc = _tiffDummyMapProc;
	if (unmapproc)
		tif->tif_unmapproc = unmapproc;
	else
		tif->tif_unmapproc = _tiffDummyUnmapProc;
	_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

	/*
	 * 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
	 * 'h' read TIFF header only, do not load the first IFD
	 * '4' ClassicTIFF for creating a file (default)
	 * '8' BigTIFF for creating a file
	 *
	 * 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 probably 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':
				#ifndef WORDS_BIGENDIAN
				if (m&O_CREAT)
					tif->tif_flags |= TIFF_SWAB;
				#endif
				break;
			case 'l':
				#ifdef WORDS_BIGENDIAN
				if ((m&O_CREAT))
					tif->tif_flags |= TIFF_SWAB;
				#endif
				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;
			case 'h':
				tif->tif_flags |= TIFF_HEADERONLY;
				break;
			case '8':
				if (m&O_CREAT)
					tif->tif_flags |= TIFF_BIGTIFF;
				break;
		}
	/*
	 * Read in TIFF header.
	 */
	if ((m & O_TRUNC) ||
	    !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) {
		if (tif->tif_mode == O_RDONLY) {
			TIFFErrorExt(tif->tif_clientdata, name,
			    "Cannot read TIFF header");
			goto bad;
		}
		/*
		 * Setup header and write.
		 */
		#ifdef WORDS_BIGENDIAN
		tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
		    ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
		#else
		tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
		    ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
		#endif
		if (!(tif->tif_flags&TIFF_BIGTIFF))
		{
			tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
			tif->tif_header.classic.tiff_diroff = 0;
			if (tif->tif_flags & TIFF_SWAB)
				TIFFSwabShort(&tif->tif_header.common.tiff_version);
			tif->tif_header_size = sizeof(TIFFHeaderClassic);
		}
		else
		{
			tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
			tif->tif_header.big.tiff_offsetsize = 8;
			tif->tif_header.big.tiff_unused = 0;
			tif->tif_header.big.tiff_diroff = 0;
			if (tif->tif_flags & TIFF_SWAB)
			{
				TIFFSwabShort(&tif->tif_header.common.tiff_version);
				TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
			}
			tif->tif_header_size = sizeof (TIFFHeaderBig);
		}
		/*
		 * The doc for "fopen" for some STD_C_LIBs says that if you
		 * open a file for modify ("+"), then you must fseek (or
		 * fflush?) between any freads and fwrites.  This is not
		 * necessary on most systems, but has been shown to be needed
		 * on Solaris.
		 */
		TIFFSeekFile( tif, 0, SEEK_SET );
		if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) {
			TIFFErrorExt(tif->tif_clientdata, name,
			    "Error writing TIFF header");
			goto bad;
		}
		/*
		 * Setup the byte order handling.
		 */
		if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
			#ifndef WORDS_BIGENDIAN
			tif->tif_flags |= TIFF_SWAB;
			#endif
		} else {
			#ifdef WORDS_BIGENDIAN
			tif->tif_flags |= TIFF_SWAB;
			#endif
		}
		/*
		 * Setup default directory.
		 */
		if (!TIFFDefaultDirectory(tif))
			goto bad;
		tif->tif_diroff = 0;
		tif->tif_dirlist = NULL;
		tif->tif_dirlistsize = 0;
		tif->tif_dirnumber = 0;
		return (tif);
	}
	/*
	 * Setup the byte order handling.
	 */
	if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
	    tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
	    #if MDI_SUPPORT
	    &&
	    #if HOST_BIGENDIAN
	    tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
	    #else
	    tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
	    #endif
	    ) {
		TIFFErrorExt(tif->tif_clientdata, name,
		    "Not a TIFF or MDI file, bad magic number %d (0x%x)",
	    #else
	    ) {
		TIFFErrorExt(tif->tif_clientdata, name,
		    "Not a TIFF file, bad magic number %d (0x%x)",
	    #endif
		    tif->tif_header.common.tiff_magic,
		    tif->tif_header.common.tiff_magic);
		goto bad;
	}
	if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
		#ifndef WORDS_BIGENDIAN
		tif->tif_flags |= TIFF_SWAB;
		#endif
	} else {
		#ifdef WORDS_BIGENDIAN
		tif->tif_flags |= TIFF_SWAB;
		#endif
	}
	if (tif->tif_flags & TIFF_SWAB) 
		TIFFSwabShort(&tif->tif_header.common.tiff_version);
	if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&&
	    (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) {
		TIFFErrorExt(tif->tif_clientdata, name,
		    "Not a TIFF file, bad version number %d (0x%x)",
		    tif->tif_header.common.tiff_version,
		    tif->tif_header.common.tiff_version);
		goto bad;
	}
	if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
	{
		if (tif->tif_flags & TIFF_SWAB)
			TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
		tif->tif_header_size = sizeof(TIFFHeaderClassic);
	}
	else
	{
		if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
		{
			TIFFErrorExt(tif->tif_clientdata, name,
			    "Cannot read TIFF header");
			goto bad;
		}
		if (tif->tif_flags & TIFF_SWAB)
		{
			TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
			TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
		}
		if (tif->tif_header.big.tiff_offsetsize != 8)
		{
			TIFFErrorExt(tif->tif_clientdata, name,
			    "Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
			    tif->tif_header.big.tiff_offsetsize,
			    tif->tif_header.big.tiff_offsetsize);
			goto bad;
		}
		if (tif->tif_header.big.tiff_unused != 0)
		{
			TIFFErrorExt(tif->tif_clientdata, name,
			    "Not a TIFF file, bad BigTIFF unused %d (0x%x)",
			    tif->tif_header.big.tiff_unused,
			    tif->tif_header.big.tiff_unused);
			goto bad;
		}
		tif->tif_header_size = sizeof(TIFFHeaderBig);
		tif->tif_flags |= TIFF_BIGTIFF;
	}
	tif->tif_flags |= TIFF_MYBUFFER;
	tif->tif_rawcp = tif->tif_rawdata = 0;
	tif->tif_rawdatasize = 0;
        tif->tif_rawdataoff = 0;
        tif->tif_rawdataloaded = 0;

	switch (mode[0]) {
		case 'r':
			if (!(tif->tif_flags&TIFF_BIGTIFF))
				tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
			else
				tif->tif_nextdiroff = tif->tif_header.big.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)
			{
				toff_t n;
				if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n))
				{
					tif->tif_size=(tmsize_t)n;
					assert((toff_t)tif->tif_size==n);
				}
				else
					tif->tif_flags &= ~TIFF_MAPPED;
			}
			/*
			 * Sometimes we do not want to read the first directory (for example,
			 * it may be broken) and want to proceed to other directories. I this
			 * case we use the TIFF_HEADERONLY flag to open file and return
			 * immediately after reading TIFF header.
			 */
			if (tif->tif_flags & TIFF_HEADERONLY)
				return (tif);

			/*
			 * Setup initial directory.
			 */
			if (TIFFReadDirectory(tif)) {
				tif->tif_rawcc = (tmsize_t)-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 */
        TIFFCleanup(tif);
bad2:
	return ((TIFF*)0);
}

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

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

/*
 * Set the file name.
 */
const char *
TIFFSetFileName(TIFF* tif, const char *name)
{
	const char* old_name = tif->tif_name;
	tif->tif_name = (char *)name;
	return (old_name);
}

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

/*
 * Set open file's I/O descriptor, and return previous value.
 */
int
TIFFSetFileno(TIFF* tif, int fd)
{
        int old_fd = tif->tif_fd;
	tif->tif_fd = fd;
	return old_fd;
}

/*
 * Return open file's clientdata.
 */
thandle_t
TIFFClientdata(TIFF* tif)
{
	return (tif->tif_clientdata);
}

/*
 * Set open file's clientdata, and return previous value.
 */
thandle_t
TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
{
	thandle_t m = tif->tif_clientdata;
	tif->tif_clientdata = newvalue;
	return m;
}

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

/*
 * Return read/write mode.
 */
int
TIFFSetMode(TIFF* tif, int mode)
{
	int old_mode = tif->tif_mode;
	tif->tif_mode = mode;
	return (old_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.
 */
uint16
TIFFCurrentDirectory(TIFF* tif)
{
	return (tif->tif_curdir);
}

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

/*
 * Return current tile.
 */
uint32
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));
}

/*
 * Return nonzero if given file was written in big-endian order.
 */
int
TIFFIsBigEndian(TIFF* tif)
{
	return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
}

/*
 * Return pointer to file read method.
 */
TIFFReadWriteProc
TIFFGetReadProc(TIFF* tif)
{
	return (tif->tif_readproc);
}

/*
 * Return pointer to file write method.
 */
TIFFReadWriteProc
TIFFGetWriteProc(TIFF* tif)
{
	return (tif->tif_writeproc);
}

/*
 * Return pointer to file seek method.
 */
TIFFSeekProc
TIFFGetSeekProc(TIFF* tif)
{
	return (tif->tif_seekproc);
}

/*
 * Return pointer to file close method.
 */
TIFFCloseProc
TIFFGetCloseProc(TIFF* tif)
{
	return (tif->tif_closeproc);
}

/*
 * Return pointer to file size requesting method.
 */
TIFFSizeProc
TIFFGetSizeProc(TIFF* tif)
{
	return (tif->tif_sizeproc);
}

/*
 * Return pointer to memory mapping method.
 */
TIFFMapFileProc
TIFFGetMapFileProc(TIFF* tif)
{
	return (tif->tif_mapproc);
}

/*
 * Return pointer to memory unmapping method.
 */
TIFFUnmapFileProc
TIFFGetUnmapFileProc(TIFF* tif)
{
	return (tif->tif_unmapproc);
}

/* vim: set ts=8 sts=8 sw=8 noet: */
/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 8
 * fill-column: 78
 * End:
 */
Commit	Line	Data
8414a40c VZ	1	/* $Id$ */
	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	#include "tiffiop.h"
	31
8414a40c VZ	32	/*
	33	* Dummy functions to fill the omitted client procedures.
	34	*/
	35	static int
80ed523f	36	_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
8414a40c VZ	37	{
	38	(void) fd; (void) pbase; (void) psize;
	39	return (0);
	40	}
	41
	42	static void
80ed523f	43	_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
8414a40c VZ	44	{
	45	(void) fd; (void) base; (void) size;
	46	}
	47
8414a40c VZ	48	int
	49	_TIFFgetMode(const char* mode, const char* module)
	50	{
	51	int m = -1;
	52
	53	switch (mode[0]) {
	54	case 'r':
	55	m = O_RDONLY;
	56	if (mode[1] == '+')
	57	m = O_RDWR;
	58	break;
	59	case 'w':
	60	case 'a':
	61	m = O_RDWR\|O_CREAT;
	62	if (mode[0] == 'w')
	63	m \|= O_TRUNC;
	64	break;
	65	default:
	66	TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);
	67	break;
	68	}
	69	return (m);
	70	}
	71
	72	TIFF*
	73	TIFFClientOpen(
	74	const char* name, const char* mode,
	75	thandle_t clientdata,
	76	TIFFReadWriteProc readproc,
	77	TIFFReadWriteProc writeproc,
	78	TIFFSeekProc seekproc,
	79	TIFFCloseProc closeproc,
	80	TIFFSizeProc sizeproc,
	81	TIFFMapFileProc mapproc,
	82	TIFFUnmapFileProc unmapproc
	83	)
	84	{
	85	static const char module[] = "TIFFClientOpen";
	86	TIFF *tif;
	87	int m;
	88	const char* cp;
	89
80ed523f VZ	90	/* The following are configuration checks. They should be redundant, but should not
	91	* compile to any actual code in an optimised release build anyway. If any of them
	92	* fail, (makefile-based or other) configuration is not correct */
	93	assert(sizeof(uint8)==1);
	94	assert(sizeof(int8)==1);
	95	assert(sizeof(uint16)==2);
	96	assert(sizeof(int16)==2);
	97	assert(sizeof(uint32)==4);
	98	assert(sizeof(int32)==4);
	99	assert(sizeof(uint64)==8);
	100	assert(sizeof(int64)==8);
	101	assert(sizeof(tmsize_t)==sizeof(void*));
	102	{
	103	union{
	104	uint8 a8[2];
	105	uint16 a16;
	106	} n;
	107	n.a8[0]=1;
	108	n.a8[1]=0;
	109	#ifdef WORDS_BIGENDIAN
	110	assert(n.a16==256);
	111	#else
	112	assert(n.a16==1);
	113	#endif
	114	}
	115
8414a40c VZ	116	m = _TIFFgetMode(mode, module);
	117	if (m == -1)
	118	goto bad2;
80ed523f	119	tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
8414a40c VZ	120	if (tif == NULL) {
	121	TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
	122	goto bad2;
	123	}
	124	_TIFFmemset(tif, 0, sizeof (*tif));
	125	tif->tif_name = (char *)tif + sizeof (TIFF);
	126	strcpy(tif->tif_name, name);
	127	tif->tif_mode = m &~ (O_CREAT\|O_TRUNC);
80ed523f	128	tif->tif_curdir = (uint16) -1; /* non-existent directory */
8414a40c	129	tif->tif_curoff = 0;
80ed523f	130	tif->tif_curstrip = (uint32) -1; /* invalid strip */
8414a40c VZ	131	tif->tif_row = (uint32) -1; /* read/write pre-increment */
	132	tif->tif_clientdata = clientdata;
	133	if (!readproc \|\| !writeproc \|\| !seekproc \|\| !closeproc \|\| !sizeproc) {
	134	TIFFErrorExt(clientdata, module,
80ed523f	135	"One of the client procedures is NULL pointer.");
8414a40c VZ	136	goto bad2;
	137	}
	138	tif->tif_readproc = readproc;
	139	tif->tif_writeproc = writeproc;
	140	tif->tif_seekproc = seekproc;
	141	tif->tif_closeproc = closeproc;
	142	tif->tif_sizeproc = sizeproc;
80ed523f	143	if (mapproc)
8414a40c VZ	144	tif->tif_mapproc = mapproc;
	145	else
	146	tif->tif_mapproc = _tiffDummyMapProc;
	147	if (unmapproc)
	148	tif->tif_unmapproc = unmapproc;
	149	else
	150	tif->tif_unmapproc = _tiffDummyUnmapProc;
80ed523f	151	_TIFFSetDefaultCompressionState(tif); /* setup default state */
8414a40c VZ	152	/*
	153	* Default is to return data MSB2LSB and enable the
	154	* use of memory-mapped files and strip chopping when
	155	* a file is opened read-only.
	156	*/
	157	tif->tif_flags = FILLORDER_MSB2LSB;
	158	if (m == O_RDONLY )
80ed523f	159	tif->tif_flags \|= TIFF_MAPPED;
8414a40c	160
80ed523f	161	#ifdef STRIPCHOP_DEFAULT
8414a40c VZ	162	if (m == O_RDONLY \|\| m == O_RDWR)
8414a40c VZ	163	tif->tif_flags \|= STRIPCHOP_DEFAULT;
80ed523f	164	#endif
8414a40c VZ	165
	166	/*
	167	* Process library-specific flags in the open mode string.
	168	* The following flags may be used to control intrinsic library
	169	* behaviour that may or may not be desirable (usually for
	170	* compatibility with some application that claims to support
	171	* TIFF but only supports some braindead idea of what the
	172	* vendor thinks TIFF is):
	173	*
80ed523f VZ	174	* 'l' use little-endian byte order for creating a file
	175	* 'b' use big-endian byte order for creating a file
	176	* 'L' read/write information using LSB2MSB bit order
	177	* 'B' read/write information using MSB2LSB bit order
	178	* 'H' read/write information using host bit order
	179	* 'M' enable use of memory-mapped files when supported
	180	* 'm' disable use of memory-mapped files
	181	* 'C' enable strip chopping support when reading
	182	* 'c' disable strip chopping support
	183	* 'h' read TIFF header only, do not load the first IFD
	184	* '4' ClassicTIFF for creating a file (default)
	185	* '8' BigTIFF for creating a file
8414a40c VZ	186	*
	187	* The use of the 'l' and 'b' flags is strongly discouraged.
	188	* These flags are provided solely because numerous vendors,
	189	* typically on the PC, do not correctly support TIFF; they
	190	* only support the Intel little-endian byte order. This
	191	* support is not configured by default because it supports
	192	* the violation of the TIFF spec that says that readers MUST
	193	* support both byte orders. It is strongly recommended that
	194	* you not use this feature except to deal with busted apps
	195	* that write invalid TIFF. And even in those cases you should
	196	* bang on the vendors to fix their software.
	197	*
	198	* The 'L', 'B', and 'H' flags are intended for applications
	199	* that can optimize operations on data by using a particular
	200	* bit order. By default the library returns data in MSB2LSB
	201	* bit order for compatibiltiy with older versions of this
	202	* library. Returning data in the bit order of the native cpu
	203	* makes the most sense but also requires applications to check
	204	* the value of the FillOrder tag; something they probably do
	205	* not do right now.
	206	*
	207	* The 'M' and 'm' flags are provided because some virtual memory
	208	* systems exhibit poor behaviour when large images are mapped.
	209	* These options permit clients to control the use of memory-mapped
	210	* files on a per-file basis.
	211	*
	212	* The 'C' and 'c' flags are provided because the library support
	213	* for chopping up large strips into multiple smaller strips is not
	214	* application-transparent and as such can cause problems. The 'c'
	215	* option permits applications that only want to look at the tags,
	216	* for example, to get the unadulterated TIFF tag information.
	217	*/
	218	for (cp = mode; *cp; cp++)
	219	switch (*cp) {
80ed523f VZ	220	case 'b':
	221	#ifndef WORDS_BIGENDIAN
	222	if (m&O_CREAT)
	223	tif->tif_flags \|= TIFF_SWAB;
	224	#endif
	225	break;
	226	case 'l':
	227	#ifdef WORDS_BIGENDIAN
	228	if ((m&O_CREAT))
	229	tif->tif_flags \|= TIFF_SWAB;
	230	#endif
	231	break;
	232	case 'B':
	233	tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) \|
	234	FILLORDER_MSB2LSB;
	235	break;
	236	case 'L':
	237	tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) \|
	238	FILLORDER_LSB2MSB;
	239	break;
	240	case 'H':
	241	tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) \|
	242	HOST_FILLORDER;
	243	break;
	244	case 'M':
	245	if (m == O_RDONLY)
	246	tif->tif_flags \|= TIFF_MAPPED;
	247	break;
	248	case 'm':
	249	if (m == O_RDONLY)
	250	tif->tif_flags &= ~TIFF_MAPPED;
	251	break;
	252	case 'C':
	253	if (m == O_RDONLY)
	254	tif->tif_flags \|= TIFF_STRIPCHOP;
	255	break;
	256	case 'c':
	257	if (m == O_RDONLY)
	258	tif->tif_flags &= ~TIFF_STRIPCHOP;
	259	break;
	260	case 'h':
	261	tif->tif_flags \|= TIFF_HEADERONLY;
	262	break;
	263	case '8':
	264	if (m&O_CREAT)
	265	tif->tif_flags \|= TIFF_BIGTIFF;
	266	break;
8414a40c VZ	267	}
	268	/*
	269	* Read in TIFF header.
	270	*/
80ed523f VZ	271	if ((m & O_TRUNC) \|\|
80ed523f VZ	272	!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) {
8414a40c	273	if (tif->tif_mode == O_RDONLY) {
80ed523f VZ	274	TIFFErrorExt(tif->tif_clientdata, name,
80ed523f VZ	275	"Cannot read TIFF header");
8414a40c VZ	276	goto bad;
	277	}
	278	/*
	279	* Setup header and write.
	280	*/
80ed523f VZ	281	#ifdef WORDS_BIGENDIAN
80ed523f VZ	282	tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
8414a40c	283	? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
80ed523f VZ	284	#else
80ed523f VZ	285	tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
8414a40c	286	? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
80ed523f VZ	287	#endif
	288	if (!(tif->tif_flags&TIFF_BIGTIFF))
	289	{
	290	tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
	291	tif->tif_header.classic.tiff_diroff = 0;
	292	if (tif->tif_flags & TIFF_SWAB)
	293	TIFFSwabShort(&tif->tif_header.common.tiff_version);
	294	tif->tif_header_size = sizeof(TIFFHeaderClassic);
	295	}
	296	else
	297	{
	298	tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
	299	tif->tif_header.big.tiff_offsetsize = 8;
	300	tif->tif_header.big.tiff_unused = 0;
	301	tif->tif_header.big.tiff_diroff = 0;
	302	if (tif->tif_flags & TIFF_SWAB)
	303	{
	304	TIFFSwabShort(&tif->tif_header.common.tiff_version);
	305	TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
	306	}
	307	tif->tif_header_size = sizeof (TIFFHeaderBig);
	308	}
	309	/*
	310	* The doc for "fopen" for some STD_C_LIBs says that if you
	311	* open a file for modify ("+"), then you must fseek (or
	312	* fflush?) between any freads and fwrites. This is not
	313	* necessary on most systems, but has been shown to be needed
	314	* on Solaris.
	315	*/
	316	TIFFSeekFile( tif, 0, SEEK_SET );
	317	if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) {
	318	TIFFErrorExt(tif->tif_clientdata, name,
	319	"Error writing TIFF header");
8414a40c VZ	320	goto bad;
	321	}
	322	/*
	323	* Setup the byte order handling.
	324	*/
80ed523f VZ	325	if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
	326	#ifndef WORDS_BIGENDIAN
	327	tif->tif_flags \|= TIFF_SWAB;
	328	#endif
	329	} else {
	330	#ifdef WORDS_BIGENDIAN
	331	tif->tif_flags \|= TIFF_SWAB;
	332	#endif
	333	}
8414a40c VZ	334	/*
	335	* Setup default directory.
	336	*/
	337	if (!TIFFDefaultDirectory(tif))
	338	goto bad;
	339	tif->tif_diroff = 0;
	340	tif->tif_dirlist = NULL;
80ed523f	341	tif->tif_dirlistsize = 0;
8414a40c VZ	342	tif->tif_dirnumber = 0;
	343	return (tif);
	344	}
	345	/*
	346	* Setup the byte order handling.
	347	*/
80ed523f VZ	348	if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
	349	tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
	350	#if MDI_SUPPORT
8414a40c	351	&&
80ed523f VZ	352	#if HOST_BIGENDIAN
	353	tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
	354	#else
	355	tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
	356	#endif
8414a40c	357	) {
80ed523f VZ	358	TIFFErrorExt(tif->tif_clientdata, name,
	359	"Not a TIFF or MDI file, bad magic number %d (0x%x)",
	360	#else
8414a40c	361	) {
8414a40c	362	TIFFErrorExt(tif->tif_clientdata, name,
80ed523f VZ	363	"Not a TIFF file, bad magic number %d (0x%x)",
	364	#endif
	365	tif->tif_header.common.tiff_magic,
	366	tif->tif_header.common.tiff_magic);
8414a40c VZ	367	goto bad;
8414a40c VZ	368	}
80ed523f VZ	369	if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
	370	#ifndef WORDS_BIGENDIAN
	371	tif->tif_flags \|= TIFF_SWAB;
	372	#endif
	373	} else {
	374	#ifdef WORDS_BIGENDIAN
	375	tif->tif_flags \|= TIFF_SWAB;
	376	#endif
	377	}
	378	if (tif->tif_flags & TIFF_SWAB)
	379	TIFFSwabShort(&tif->tif_header.common.tiff_version);
	380	if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&&
	381	(tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) {
8414a40c VZ	382	TIFFErrorExt(tif->tif_clientdata, name,
8414a40c VZ	383	"Not a TIFF file, bad version number %d (0x%x)",
80ed523f VZ	384	tif->tif_header.common.tiff_version,
80ed523f VZ	385	tif->tif_header.common.tiff_version);
8414a40c VZ	386	goto bad;
8414a40c VZ	387	}
80ed523f VZ	388	if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
	389	{
	390	if (tif->tif_flags & TIFF_SWAB)
	391	TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
	392	tif->tif_header_size = sizeof(TIFFHeaderClassic);
	393	}
	394	else
	395	{
	396	if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
	397	{
	398	TIFFErrorExt(tif->tif_clientdata, name,
	399	"Cannot read TIFF header");
	400	goto bad;
	401	}
	402	if (tif->tif_flags & TIFF_SWAB)
	403	{
	404	TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
	405	TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
	406	}
	407	if (tif->tif_header.big.tiff_offsetsize != 8)
	408	{
	409	TIFFErrorExt(tif->tif_clientdata, name,
	410	"Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
	411	tif->tif_header.big.tiff_offsetsize,
	412	tif->tif_header.big.tiff_offsetsize);
	413	goto bad;
	414	}
	415	if (tif->tif_header.big.tiff_unused != 0)
	416	{
	417	TIFFErrorExt(tif->tif_clientdata, name,
	418	"Not a TIFF file, bad BigTIFF unused %d (0x%x)",
	419	tif->tif_header.big.tiff_unused,
	420	tif->tif_header.big.tiff_unused);
	421	goto bad;
	422	}
	423	tif->tif_header_size = sizeof(TIFFHeaderBig);
	424	tif->tif_flags \|= TIFF_BIGTIFF;
	425	}
8414a40c VZ	426	tif->tif_flags \|= TIFF_MYBUFFER;
	427	tif->tif_rawcp = tif->tif_rawdata = 0;
	428	tif->tif_rawdatasize = 0;
80ed523f VZ	429	tif->tif_rawdataoff = 0;
80ed523f VZ	430	tif->tif_rawdataloaded = 0;
8414a40c	431
8414a40c	432	switch (mode[0]) {
80ed523f VZ	433	case 'r':
	434	if (!(tif->tif_flags&TIFF_BIGTIFF))
	435	tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
	436	else
	437	tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
	438	/*
	439	* Try to use a memory-mapped file if the client
	440	* has not explicitly suppressed usage with the
	441	* 'm' flag in the open mode (see above).
	442	*/
	443	if (tif->tif_flags & TIFF_MAPPED)
	444	{
	445	toff_t n;
	446	if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n))
	447	{
	448	tif->tif_size=(tmsize_t)n;
	449	assert((toff_t)tif->tif_size==n);
	450	}
	451	else
	452	tif->tif_flags &= ~TIFF_MAPPED;
	453	}
	454	/*
	455	* Sometimes we do not want to read the first directory (for example,
	456	* it may be broken) and want to proceed to other directories. I this
	457	* case we use the TIFF_HEADERONLY flag to open file and return
	458	* immediately after reading TIFF header.
	459	*/
	460	if (tif->tif_flags & TIFF_HEADERONLY)
	461	return (tif);
	462
	463	/*
	464	* Setup initial directory.
	465	*/
	466	if (TIFFReadDirectory(tif)) {
	467	tif->tif_rawcc = (tmsize_t)-1;
	468	tif->tif_flags \|= TIFF_BUFFERSETUP;
	469	return (tif);
	470	}
	471	break;
	472	case 'a':
	473	/*
	474	* New directories are automatically append
	475	* to the end of the directory chain when they
	476	* are written out (see TIFFWriteDirectory).
	477	*/
	478	if (!TIFFDefaultDirectory(tif))
	479	goto bad;
8414a40c	480	return (tif);
8414a40c VZ	481	}
	482	bad:
	483	tif->tif_mode = O_RDONLY; /* XXX avoid flush */
	484	TIFFCleanup(tif);
	485	bad2:
	486	return ((TIFF*)0);
	487	}
	488
	489	/*
	490	* Query functions to access private data.
	491	*/
	492
	493	/*
	494	* Return open file's name.
	495	*/
	496	const char *
	497	TIFFFileName(TIFF* tif)
	498	{
	499	return (tif->tif_name);
	500	}
	501
	502	/*
	503	* Set the file name.
	504	*/
	505	const char *
	506	TIFFSetFileName(TIFF* tif, const char *name)
	507	{
	508	const char* old_name = tif->tif_name;
	509	tif->tif_name = (char *)name;
	510	return (old_name);
	511	}
	512
	513	/*
	514	* Return open file's I/O descriptor.
	515	*/
	516	int
	517	TIFFFileno(TIFF* tif)
	518	{
	519	return (tif->tif_fd);
	520	}
	521
	522	/*
	523	* Set open file's I/O descriptor, and return previous value.
	524	*/
	525	int
	526	TIFFSetFileno(TIFF* tif, int fd)
	527	{
	528	int old_fd = tif->tif_fd;
	529	tif->tif_fd = fd;
	530	return old_fd;
	531	}
	532
	533	/*
	534	* Return open file's clientdata.
	535	*/
	536	thandle_t
	537	TIFFClientdata(TIFF* tif)
	538	{
	539	return (tif->tif_clientdata);
	540	}
	541
	542	/*
	543	* Set open file's clientdata, and return previous value.
	544	*/
545	thandle_t
546	TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
547	{
548	thandle_t m = tif->tif_clientdata;
549	tif->tif_clientdata = newvalue;
550	return m;
551	}
552
553	/*
554	* Return read/write mode.
555	*/
556	int
557	TIFFGetMode(TIFF* tif)
558	{
559	return (tif->tif_mode);
560	}
561
562	/*
563	* Return read/write mode.
564	*/
565	int
566	TIFFSetMode(TIFF* tif, int mode)
567	{
568	int old_mode = tif->tif_mode;
569	tif->tif_mode = mode;
570	return (old_mode);
571	}
572
573	/*
574	* Return nonzero if file is organized in
575	* tiles; zero if organized as strips.
576	*/
577	int
578	TIFFIsTiled(TIFF* tif)
579	{
580	return (isTiled(tif));
581	}
582
583	/*
584	* Return current row being read/written.
585	*/
586	uint32
587	TIFFCurrentRow(TIFF* tif)
588	{
589	return (tif->tif_row);
590	}
591
592	/*
593	* Return index of the current directory.
594	*/
80ed523f	595	uint16
8414a40c VZ	596	TIFFCurrentDirectory(TIFF* tif)
	597	{
	598	return (tif->tif_curdir);
	599	}
	600
	601	/*
	602	* Return current strip.
	603	*/
80ed523f	604	uint32
8414a40c VZ	605	TIFFCurrentStrip(TIFF* tif)
	606	{
	607	return (tif->tif_curstrip);
	608	}
	609
	610	/*
	611	* Return current tile.
	612	*/
80ed523f	613	uint32
8414a40c VZ	614	TIFFCurrentTile(TIFF* tif)
	615	{
	616	return (tif->tif_curtile);
	617	}
	618
	619	/*
	620	* Return nonzero if the file has byte-swapped data.
	621	*/
	622	int
	623	TIFFIsByteSwapped(TIFF* tif)
	624	{
	625	return ((tif->tif_flags & TIFF_SWAB) != 0);
	626	}
	627
	628	/*
	629	* Return nonzero if the data is returned up-sampled.
	630	*/
	631	int
	632	TIFFIsUpSampled(TIFF* tif)
	633	{
	634	return (isUpSampled(tif));
	635	}
	636
	637	/*
	638	* Return nonzero if the data is returned in MSB-to-LSB bit order.
	639	*/
	640	int
	641	TIFFIsMSB2LSB(TIFF* tif)
	642	{
	643	return (isFillOrder(tif, FILLORDER_MSB2LSB));
	644	}
	645
	646	/*
	647	* Return nonzero if given file was written in big-endian order.
	648	*/
	649	int
	650	TIFFIsBigEndian(TIFF* tif)
	651	{
80ed523f	652	return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
8414a40c VZ	653	}
	654
	655	/*
	656	* Return pointer to file read method.
	657	*/
	658	TIFFReadWriteProc
	659	TIFFGetReadProc(TIFF* tif)
	660	{
	661	return (tif->tif_readproc);
	662	}
	663
	664	/*
	665	* Return pointer to file write method.
	666	*/
	667	TIFFReadWriteProc
	668	TIFFGetWriteProc(TIFF* tif)
	669	{
	670	return (tif->tif_writeproc);
	671	}
	672
	673	/*
	674	* Return pointer to file seek method.
	675	*/
	676	TIFFSeekProc
	677	TIFFGetSeekProc(TIFF* tif)
	678	{
	679	return (tif->tif_seekproc);
	680	}
	681
	682	/*
	683	* Return pointer to file close method.
	684	*/
	685	TIFFCloseProc
	686	TIFFGetCloseProc(TIFF* tif)
	687	{
	688	return (tif->tif_closeproc);
	689	}
	690
	691	/*
	692	* Return pointer to file size requesting method.
	693	*/
	694	TIFFSizeProc
	695	TIFFGetSizeProc(TIFF* tif)
	696	{
	697	return (tif->tif_sizeproc);
	698	}
	699
	700	/*
	701	* Return pointer to memory mapping method.
	702	*/
	703	TIFFMapFileProc
	704	TIFFGetMapFileProc(TIFF* tif)
	705	{
	706	return (tif->tif_mapproc);
	707	}
	708
	709	/*
	710	* Return pointer to memory unmapping method.
	711	*/
	712	TIFFUnmapFileProc
	713	TIFFGetUnmapFileProc(TIFF* tif)
	714	{
	715	return (tif->tif_unmapproc);
	716	}
717
718	/* vim: set ts=8 sts=8 sw=8 noet: */
80ed523f VZ	719	/*
	720	* Local Variables:
	721	* mode: c
	722	* c-basic-offset: 8
	723	* fill-column: 78
	724	* End:
	725	*/