src/tiff/libtiff/tif_stream.cxx

/* $Id$ */

/*
 * Copyright (c) 1988-1996 Sam Leffler
 * Copyright (c) 1991-1996 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 UNIX-specific Routines.
 */
#include "tiffiop.h"
#include <iostream>

#ifndef __VMS
using namespace std;
#endif

/*
  ISO C++ uses a 'std::streamsize' type to define counts.  This makes
  it similar to, (but perhaps not the same as) size_t.

  The std::ios::pos_type is used to represent stream positions as used
  by tellg(), tellp(), seekg(), and seekp().  This makes it similar to
  (but perhaps not the same as) 'off_t'.  The std::ios::streampos type
  is used for character streams, but is documented to not be an
  integral type anymore, so it should *not* be assigned to an integral
  type.

  The std::ios::off_type is used to specify relative offsets needed by
  the variants of seekg() and seekp() which accept a relative offset
  argument.

  Useful prototype knowledge:

  Obtain read position
    ios::pos_type basic_istream::tellg()

  Set read position
    basic_istream& basic_istream::seekg(ios::pos_type)
    basic_istream& basic_istream::seekg(ios::off_type, ios_base::seekdir)

  Read data
    basic_istream& istream::read(char *str, streamsize count)

  Number of characters read in last unformatted read
    streamsize istream::gcount();

  Obtain write position
    ios::pos_type basic_ostream::tellp()

  Set write position
    basic_ostream& basic_ostream::seekp(ios::pos_type)
    basic_ostream& basic_ostream::seekp(ios::off_type, ios_base::seekdir)

  Write data
    basic_ostream& ostream::write(const char *str, streamsize count)
*/

struct tiffis_data;
struct tiffos_data;

extern "C" {

	static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t);
	static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size);
	static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size);
	static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t);
	static uint64   _tiffosSeekProc(thandle_t fd, uint64 off, int whence);
	static uint64   _tiffisSeekProc(thandle_t fd, uint64 off, int whence);
	static uint64   _tiffosSizeProc(thandle_t fd);
	static uint64   _tiffisSizeProc(thandle_t fd);
	static int      _tiffosCloseProc(thandle_t fd);
	static int      _tiffisCloseProc(thandle_t fd);
	static int 	_tiffDummyMapProc(thandle_t , void** base, toff_t* size );
	static void     _tiffDummyUnmapProc(thandle_t , void* base, toff_t size );
	static TIFF*    _tiffStreamOpen(const char* name, const char* mode, void *fd);

struct tiffis_data
{
	istream	*stream;
        ios::pos_type start_pos;
};

struct tiffos_data
{
	ostream	*stream;
	ios::pos_type start_pos;
};

static tmsize_t
_tiffosReadProc(thandle_t, void*, tmsize_t)
{
        return 0;
}

static tmsize_t
_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size)
{
        tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);

        // Verify that type does not overflow.
        streamsize request_size = size;
        if (static_cast<tmsize_t>(request_size) != size)
          return static_cast<tmsize_t>(-1);

        data->stream->read((char *) buf, request_size);

        return static_cast<tmsize_t>(data->stream->gcount());
}

static tmsize_t
_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size)
{
	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
	ostream		*os = data->stream;
	ios::pos_type	pos = os->tellp();

        // Verify that type does not overflow.
        streamsize request_size = size;
        if (static_cast<tmsize_t>(request_size) != size)
          return static_cast<tmsize_t>(-1);

	os->write(reinterpret_cast<const char *>(buf), request_size);

	return static_cast<tmsize_t>(os->tellp() - pos);
}

static tmsize_t
_tiffisWriteProc(thandle_t, void*, tmsize_t)
{
	return 0;
}

static uint64
_tiffosSeekProc(thandle_t fd, uint64 off, int whence)
{
	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
	ostream		*os = data->stream;

	// if the stream has already failed, don't do anything
	if( os->fail() )
		return static_cast<uint64>(-1);

	switch(whence) {
	case SEEK_SET:
		{
			// Compute 64-bit offset
			uint64 new_offset = static_cast<uint64>(data->start_pos) + off;

			// Verify that value does not overflow
			ios::off_type offset = static_cast<ios::off_type>(new_offset);
			if (static_cast<uint64>(offset) != new_offset)
				return static_cast<uint64>(-1);

			os->seekp(offset, ios::beg);
		break;
		}
	case SEEK_CUR:
		{
			// Verify that value does not overflow
			ios::off_type offset = static_cast<ios::off_type>(off);
			if (static_cast<uint64>(offset) != off)
				return static_cast<uint64>(-1);

			os->seekp(offset, ios::cur);
			break;
		}
	case SEEK_END:
		{
			// Verify that value does not overflow
			ios::off_type offset = static_cast<ios::off_type>(off);
			if (static_cast<uint64>(offset) != off)
				return static_cast<uint64>(-1);

			os->seekp(offset, ios::end);
			break;
		}
	}

	// Attempt to workaround problems with seeking past the end of the
	// stream.  ofstream doesn't have a problem with this but
	// ostrstream/ostringstream does. In that situation, add intermediate
	// '\0' characters.
	if( os->fail() ) {
#ifdef __VMS
		int		old_state;
#else
		ios::iostate	old_state;
#endif
		ios::pos_type	origin;

		old_state = os->rdstate();
		// reset the fail bit or else tellp() won't work below
		os->clear(os->rdstate() & ~ios::failbit);
		switch( whence ) {
			case SEEK_SET:
                        default:
				origin = data->start_pos;
				break;
			case SEEK_CUR:
				origin = os->tellp();
				break;
			case SEEK_END:
				os->seekp(0, ios::end);
				origin = os->tellp();
				break;
		}
		// restore original stream state
		os->clear(old_state);

		// only do something if desired seek position is valid
		if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) {
			uint64	num_fill;

			// clear the fail bit
			os->clear(os->rdstate() & ~ios::failbit);

			// extend the stream to the expected size
			os->seekp(0, ios::end);
			num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
			for( uint64 i = 0; i < num_fill; i++ )
				os->put('\0');

			// retry the seek
			os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg);
		}
	}

	return static_cast<uint64>(os->tellp());
}

static uint64
_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
{
	tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);

	switch(whence) {
	case SEEK_SET:
		{
			// Compute 64-bit offset
			uint64 new_offset = static_cast<uint64>(data->start_pos) + off;

			// Verify that value does not overflow
			ios::off_type offset = static_cast<ios::off_type>(new_offset);
			if (static_cast<uint64>(offset) != new_offset)
				return static_cast<uint64>(-1);

			data->stream->seekg(offset, ios::beg);
			break;
		}
	case SEEK_CUR:
		{
			// Verify that value does not overflow
			ios::off_type offset = static_cast<ios::off_type>(off);
			if (static_cast<uint64>(offset) != off)
				return static_cast<uint64>(-1);

			data->stream->seekg(offset, ios::cur);
			break;
		}
	case SEEK_END:
		{
			// Verify that value does not overflow
			ios::off_type offset = static_cast<ios::off_type>(off);
			if (static_cast<uint64>(offset) != off)
				return static_cast<uint64>(-1);

			data->stream->seekg(offset, ios::end);
			break;
		}
	}

	return (uint64) (data->stream->tellg() - data->start_pos);
}

static uint64
_tiffosSizeProc(thandle_t fd)
{
	tiffos_data	*data = reinterpret_cast<tiffos_data *>(fd);
	ostream		*os = data->stream;
	ios::pos_type	pos = os->tellp();
	ios::pos_type	len;

	os->seekp(0, ios::end);
	len = os->tellp();
	os->seekp(pos);

	return (uint64) len;
}

static uint64
_tiffisSizeProc(thandle_t fd)
{
	tiffis_data	*data = reinterpret_cast<tiffis_data *>(fd);
	ios::pos_type	pos = data->stream->tellg();
	ios::pos_type	len;

	data->stream->seekg(0, ios::end);
	len = data->stream->tellg();
	data->stream->seekg(pos);

	return (uint64) len;
}

static int
_tiffosCloseProc(thandle_t fd)
{
	// Our stream was not allocated by us, so it shouldn't be closed by us.
	delete reinterpret_cast<tiffos_data *>(fd);
	return 0;
}

static int
_tiffisCloseProc(thandle_t fd)
{
	// Our stream was not allocated by us, so it shouldn't be closed by us.
	delete reinterpret_cast<tiffis_data *>(fd);
	return 0;
}

static int
_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
{
	return (0);
}

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

/*
 * Open a TIFF file descriptor for read/writing.
 */
static TIFF*
_tiffStreamOpen(const char* name, const char* mode, void *fd)
{
	TIFF*	tif;

	if( strchr(mode, 'w') ) {
		tiffos_data	*data = new tiffos_data;
		data->stream = reinterpret_cast<ostream *>(fd);
		data->start_pos = data->stream->tellp();

		// Open for writing.
		tif = TIFFClientOpen(name, mode,
				reinterpret_cast<thandle_t>(data),
				_tiffosReadProc,
                                _tiffosWriteProc,
				_tiffosSeekProc,
                                _tiffosCloseProc,
				_tiffosSizeProc,
				_tiffDummyMapProc,
                                _tiffDummyUnmapProc);
	} else {
		tiffis_data	*data = new tiffis_data;
		data->stream = reinterpret_cast<istream *>(fd);
		data->start_pos = data->stream->tellg();
		// Open for reading.
		tif = TIFFClientOpen(name, mode,
				reinterpret_cast<thandle_t>(data),
				_tiffisReadProc,
                                _tiffisWriteProc,
				_tiffisSeekProc,
                                _tiffisCloseProc,
				_tiffisSizeProc,
				_tiffDummyMapProc,
                                _tiffDummyUnmapProc);
	}

	return (tif);
}

} /* extern "C" */

TIFF*
TIFFStreamOpen(const char* name, ostream *os)
{
	// If os is either a ostrstream or ostringstream, and has no data
	// written to it yet, then tellp() will return -1 which will break us.
	// We workaround this by writing out a dummy character and
	// then seek back to the beginning.
	if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) {
		*os << '\0';
		os->seekp(0);
	}

	// NB: We don't support mapped files with streams so add 'm'
	return _tiffStreamOpen(name, "wm", os);
}

TIFF*
TIFFStreamOpen(const char* name, istream *is)
{
	// NB: We don't support mapped files with streams so add 'm'
	return _tiffStreamOpen(name, "rm", is);
}

/* vim: set ts=8 sts=8 sw=8 noet: */
/*
  Local Variables:
  mode: c
  indent-tabs-mode: true
  c-basic-offset: 8
  End:
*/
Commit	Line	Data
	1	/* $Id$ */
	2
	3	/*
	4	* Copyright (c) 1988-1996 Sam Leffler
	5	* Copyright (c) 1991-1996 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 UNIX-specific Routines.
	29	*/
	30	#include "tiffiop.h"
	31	#include <iostream>
	32
	33	#ifndef __VMS
	34	using namespace std;
	35	#endif
	36
	37	/*
	38	ISO C++ uses a 'std::streamsize' type to define counts. This makes
	39	it similar to, (but perhaps not the same as) size_t.
	40
	41	The std::ios::pos_type is used to represent stream positions as used
	42	by tellg(), tellp(), seekg(), and seekp(). This makes it similar to
	43	(but perhaps not the same as) 'off_t'. The std::ios::streampos type
	44	is used for character streams, but is documented to not be an
	45	integral type anymore, so it should not be assigned to an integral
	46	type.
	47
	48	The std::ios::off_type is used to specify relative offsets needed by
	49	the variants of seekg() and seekp() which accept a relative offset
	50	argument.
	51
	52	Useful prototype knowledge:
	53
	54	Obtain read position
	55	ios::pos_type basic_istream::tellg()
	56
	57	Set read position
	58	basic_istream& basic_istream::seekg(ios::pos_type)
	59	basic_istream& basic_istream::seekg(ios::off_type, ios_base::seekdir)
	60
	61	Read data
	62	basic_istream& istream::read(char *str, streamsize count)
	63
	64	Number of characters read in last unformatted read
	65	streamsize istream::gcount();
	66
	67	Obtain write position
	68	ios::pos_type basic_ostream::tellp()
	69
	70	Set write position
	71	basic_ostream& basic_ostream::seekp(ios::pos_type)
	72	basic_ostream& basic_ostream::seekp(ios::off_type, ios_base::seekdir)
	73
	74	Write data
	75	basic_ostream& ostream::write(const char *str, streamsize count)
	76	*/
	77
	78	struct tiffis_data;
	79	struct tiffos_data;
	80
	81	extern "C" {
	82
	83	static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t);
	84	static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size);
	85	static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size);
	86	static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t);
	87	static uint64 _tiffosSeekProc(thandle_t fd, uint64 off, int whence);
	88	static uint64 _tiffisSeekProc(thandle_t fd, uint64 off, int whence);
	89	static uint64 _tiffosSizeProc(thandle_t fd);
	90	static uint64 _tiffisSizeProc(thandle_t fd);
	91	static int _tiffosCloseProc(thandle_t fd);
	92	static int _tiffisCloseProc(thandle_t fd);
	93	static int _tiffDummyMapProc(thandle_t , void** base, toff_t* size );
	94	static void _tiffDummyUnmapProc(thandle_t , void* base, toff_t size );
	95	static TIFF* _tiffStreamOpen(const char* name, const char* mode, void *fd);
	96
	97	struct tiffis_data
	98	{
	99	istream *stream;
	100	ios::pos_type start_pos;
	101	};
	102
	103	struct tiffos_data
	104	{
	105	ostream *stream;
	106	ios::pos_type start_pos;
	107	};
	108
	109	static tmsize_t
	110	_tiffosReadProc(thandle_t, void*, tmsize_t)
	111	{
	112	return 0;
	113	}
	114
	115	static tmsize_t
	116	_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size)
	117	{
	118	tiffis_data data = reinterpret_cast<tiffis_data >(fd);
	119
	120	// Verify that type does not overflow.
	121	streamsize request_size = size;
	122	if (static_cast<tmsize_t>(request_size) != size)
	123	return static_cast<tmsize_t>(-1);
	124
	125	data->stream->read((char *) buf, request_size);
	126
	127	return static_cast<tmsize_t>(data->stream->gcount());
	128	}
	129
	130	static tmsize_t
	131	_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size)
	132	{
	133	tiffos_data data = reinterpret_cast<tiffos_data >(fd);
	134	ostream *os = data->stream;
	135	ios::pos_type pos = os->tellp();
	136
	137	// Verify that type does not overflow.
	138	streamsize request_size = size;
	139	if (static_cast<tmsize_t>(request_size) != size)
	140	return static_cast<tmsize_t>(-1);
	141
	142	os->write(reinterpret_cast<const char *>(buf), request_size);
	143
	144	return static_cast<tmsize_t>(os->tellp() - pos);
	145	}
	146
	147	static tmsize_t
	148	_tiffisWriteProc(thandle_t, void*, tmsize_t)
	149	{
	150	return 0;
	151	}
	152
	153	static uint64
	154	_tiffosSeekProc(thandle_t fd, uint64 off, int whence)
	155	{
	156	tiffos_data data = reinterpret_cast<tiffos_data >(fd);
	157	ostream *os = data->stream;
	158
	159	// if the stream has already failed, don't do anything
	160	if( os->fail() )
	161	return static_cast<uint64>(-1);
	162
	163	switch(whence) {
	164	case SEEK_SET:
	165	{
	166	// Compute 64-bit offset
	167	uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
	168
	169	// Verify that value does not overflow
	170	ios::off_type offset = static_cast<ios::off_type>(new_offset);
	171	if (static_cast<uint64>(offset) != new_offset)
	172	return static_cast<uint64>(-1);
	173
	174	os->seekp(offset, ios::beg);
	175	break;
	176	}
	177	case SEEK_CUR:
	178	{
	179	// Verify that value does not overflow
	180	ios::off_type offset = static_cast<ios::off_type>(off);
	181	if (static_cast<uint64>(offset) != off)
	182	return static_cast<uint64>(-1);
	183
	184	os->seekp(offset, ios::cur);
	185	break;
	186	}
	187	case SEEK_END:
	188	{
	189	// Verify that value does not overflow
	190	ios::off_type offset = static_cast<ios::off_type>(off);
	191	if (static_cast<uint64>(offset) != off)
	192	return static_cast<uint64>(-1);
	193
	194	os->seekp(offset, ios::end);
	195	break;
	196	}
	197	}
	198
	199	// Attempt to workaround problems with seeking past the end of the
	200	// stream. ofstream doesn't have a problem with this but
	201	// ostrstream/ostringstream does. In that situation, add intermediate
	202	// '\0' characters.
	203	if( os->fail() ) {
	204	#ifdef __VMS
	205	int old_state;
	206	#else
	207	ios::iostate old_state;
	208	#endif
	209	ios::pos_type origin;
	210
	211	old_state = os->rdstate();
	212	// reset the fail bit or else tellp() won't work below
	213	os->clear(os->rdstate() & ~ios::failbit);
	214	switch( whence ) {
	215	case SEEK_SET:
	216	default:
	217	origin = data->start_pos;
	218	break;
	219	case SEEK_CUR:
	220	origin = os->tellp();
	221	break;
	222	case SEEK_END:
	223	os->seekp(0, ios::end);
	224	origin = os->tellp();
	225	break;
	226	}
	227	// restore original stream state
	228	os->clear(old_state);
	229
	230	// only do something if desired seek position is valid
	231	if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) {
	232	uint64 num_fill;
	233
	234	// clear the fail bit
	235	os->clear(os->rdstate() & ~ios::failbit);
	236
	237	// extend the stream to the expected size
	238	os->seekp(0, ios::end);
	239	num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
	240	for( uint64 i = 0; i < num_fill; i++ )
	241	os->put('\0');
	242
	243	// retry the seek
	244	os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg);
	245	}
	246	}
	247
	248	return static_cast<uint64>(os->tellp());
	249	}
	250
	251	static uint64
	252	_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
	253	{
	254	tiffis_data data = reinterpret_cast<tiffis_data >(fd);
	255
	256	switch(whence) {
	257	case SEEK_SET:
	258	{
	259	// Compute 64-bit offset
	260	uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
	261
	262	// Verify that value does not overflow
	263	ios::off_type offset = static_cast<ios::off_type>(new_offset);
	264	if (static_cast<uint64>(offset) != new_offset)
	265	return static_cast<uint64>(-1);
	266
	267	data->stream->seekg(offset, ios::beg);
	268	break;
	269	}
	270	case SEEK_CUR:
	271	{
	272	// Verify that value does not overflow
	273	ios::off_type offset = static_cast<ios::off_type>(off);
	274	if (static_cast<uint64>(offset) != off)
	275	return static_cast<uint64>(-1);
	276
	277	data->stream->seekg(offset, ios::cur);
	278	break;
	279	}
	280	case SEEK_END:
	281	{
	282	// Verify that value does not overflow
	283	ios::off_type offset = static_cast<ios::off_type>(off);
	284	if (static_cast<uint64>(offset) != off)
	285	return static_cast<uint64>(-1);
	286
	287	data->stream->seekg(offset, ios::end);
	288	break;
	289	}
	290	}
	291
	292	return (uint64) (data->stream->tellg() - data->start_pos);
	293	}
	294
	295	static uint64
	296	_tiffosSizeProc(thandle_t fd)
	297	{
	298	tiffos_data data = reinterpret_cast<tiffos_data >(fd);
	299	ostream *os = data->stream;
	300	ios::pos_type pos = os->tellp();
	301	ios::pos_type len;
	302
	303	os->seekp(0, ios::end);
	304	len = os->tellp();
	305	os->seekp(pos);
	306
	307	return (uint64) len;
	308	}
	309
	310	static uint64
	311	_tiffisSizeProc(thandle_t fd)
	312	{
	313	tiffis_data data = reinterpret_cast<tiffis_data >(fd);
	314	ios::pos_type pos = data->stream->tellg();
	315	ios::pos_type len;
	316
	317	data->stream->seekg(0, ios::end);
	318	len = data->stream->tellg();
	319	data->stream->seekg(pos);
	320
	321	return (uint64) len;
	322	}
	323
	324	static int
	325	_tiffosCloseProc(thandle_t fd)
	326	{
	327	// Our stream was not allocated by us, so it shouldn't be closed by us.
	328	delete reinterpret_cast<tiffos_data *>(fd);
	329	return 0;
	330	}
	331
	332	static int
	333	_tiffisCloseProc(thandle_t fd)
	334	{
	335	// Our stream was not allocated by us, so it shouldn't be closed by us.
	336	delete reinterpret_cast<tiffis_data *>(fd);
	337	return 0;
	338	}
	339
	340	static int
	341	_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
	342	{
	343	return (0);
	344	}
	345
	346	static void
	347	_tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
	348	{
	349	}
	350
	351	/*
	352	* Open a TIFF file descriptor for read/writing.
	353	*/
	354	static TIFF*
	355	_tiffStreamOpen(const char* name, const char* mode, void *fd)
	356	{
	357	TIFF* tif;
	358
	359	if( strchr(mode, 'w') ) {
	360	tiffos_data *data = new tiffos_data;
	361	data->stream = reinterpret_cast<ostream *>(fd);
	362	data->start_pos = data->stream->tellp();
	363
	364	// Open for writing.
	365	tif = TIFFClientOpen(name, mode,
	366	reinterpret_cast<thandle_t>(data),
	367	_tiffosReadProc,
	368	_tiffosWriteProc,
	369	_tiffosSeekProc,
	370	_tiffosCloseProc,
	371	_tiffosSizeProc,
	372	_tiffDummyMapProc,
	373	_tiffDummyUnmapProc);
	374	} else {
	375	tiffis_data *data = new tiffis_data;
	376	data->stream = reinterpret_cast<istream *>(fd);
	377	data->start_pos = data->stream->tellg();
	378	// Open for reading.
	379	tif = TIFFClientOpen(name, mode,
	380	reinterpret_cast<thandle_t>(data),
	381	_tiffisReadProc,
	382	_tiffisWriteProc,
	383	_tiffisSeekProc,
	384	_tiffisCloseProc,
	385	_tiffisSizeProc,
	386	_tiffDummyMapProc,
	387	_tiffDummyUnmapProc);
	388	}
	389
	390	return (tif);
	391	}
	392
	393	} /* extern "C" */
	394
	395	TIFF*
	396	TIFFStreamOpen(const char* name, ostream *os)
	397	{
	398	// If os is either a ostrstream or ostringstream, and has no data
	399	// written to it yet, then tellp() will return -1 which will break us.
	400	// We workaround this by writing out a dummy character and
	401	// then seek back to the beginning.
	402	if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) {
	403	*os << '\0';
	404	os->seekp(0);
	405	}
	406
	407	// NB: We don't support mapped files with streams so add 'm'
	408	return _tiffStreamOpen(name, "wm", os);
	409	}
	410
	411	TIFF*
	412	TIFFStreamOpen(const char* name, istream *is)
	413	{
	414	// NB: We don't support mapped files with streams so add 'm'
	415	return _tiffStreamOpen(name, "rm", is);
	416	}
	417
	418	/* vim: set ts=8 sts=8 sw=8 noet: */
	419	/*
	420	Local Variables:
	421	mode: c
	422	indent-tabs-mode: true
	423	c-basic-offset: 8
	424	End:
	425	*/