[wxWidgets.git] / 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
a9a4f229	1	/* $Id$ */
8414a40c VZ	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
80ed523f	33	#ifndef __VMS
8414a40c	34	using namespace std;
80ed523f	35	#endif
8414a40c	36
80ed523f VZ	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
8414a40c	98	{
80ed523f VZ	99	istream *stream;
80ed523f VZ	100	ios::pos_type start_pos;
8414a40c VZ	101	};
8414a40c VZ	102
80ed523f	103	struct tiffos_data
8414a40c	104	{
80ed523f VZ	105	ostream *stream;
80ed523f VZ	106	ios::pos_type start_pos;
8414a40c VZ	107	};
8414a40c VZ	108
80ed523f VZ	109	static tmsize_t
80ed523f VZ	110	_tiffosReadProc(thandle_t, void*, tmsize_t)
8414a40c VZ	111	{
	112	return 0;
	113	}
	114
80ed523f VZ	115	static tmsize_t
80ed523f VZ	116	_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size)
8414a40c	117	{
80ed523f	118	tiffis_data data = reinterpret_cast<tiffis_data >(fd);
8414a40c	119
80ed523f VZ	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);
8414a40c	124
80ed523f VZ	125	data->stream->read((char *) buf, request_size);
	126
	127	return static_cast<tmsize_t>(data->stream->gcount());
8414a40c VZ	128	}
8414a40c VZ	129
80ed523f VZ	130	static tmsize_t
80ed523f VZ	131	_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size)
8414a40c	132	{
80ed523f VZ	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);
8414a40c	141
80ed523f	142	os->write(reinterpret_cast<const char *>(buf), request_size);
8414a40c	143
80ed523f	144	return static_cast<tmsize_t>(os->tellp() - pos);
8414a40c VZ	145	}
8414a40c VZ	146
80ed523f VZ	147	static tmsize_t
80ed523f VZ	148	_tiffisWriteProc(thandle_t, void*, tmsize_t)
8414a40c VZ	149	{
	150	return 0;
	151	}
	152
80ed523f VZ	153	static uint64
80ed523f VZ	154	_tiffosSeekProc(thandle_t fd, uint64 off, int whence)
8414a40c	155	{
80ed523f VZ	156	tiffos_data data = reinterpret_cast<tiffos_data >(fd);
80ed523f VZ	157	ostream *os = data->stream;
8414a40c VZ	158
	159	// if the stream has already failed, don't do anything
	160	if( os->fail() )
80ed523f	161	return static_cast<uint64>(-1);
8414a40c VZ	162
	163	switch(whence) {
	164	case SEEK_SET:
80ed523f VZ	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);
8414a40c	175	break;
80ed523f	176	}
8414a40c	177	case SEEK_CUR:
80ed523f VZ	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	}
8414a40c	187	case SEEK_END:
80ed523f VZ	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	}
8414a40c VZ	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() ) {
80ed523f VZ	204	#ifdef __VMS
	205	int old_state;
	206	#else
8414a40c	207	ios::iostate old_state;
80ed523f VZ	208	#endif
80ed523f VZ	209	ios::pos_type origin;
8414a40c VZ	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:
80ed523f VZ	216	default:
80ed523f VZ	217	origin = data->start_pos;
8414a40c VZ	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
80ed523f VZ	231	if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) {
80ed523f VZ	232	uint64 num_fill;
8414a40c VZ	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);
80ed523f VZ	239	num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
80ed523f VZ	240	for( uint64 i = 0; i < num_fill; i++ )
8414a40c VZ	241	os->put('\0');
	242
	243	// retry the seek
80ed523f	244	os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg);
8414a40c VZ	245	}
	246	}
	247
80ed523f	248	return static_cast<uint64>(os->tellp());
8414a40c VZ	249	}
8414a40c VZ	250
80ed523f VZ	251	static uint64
80ed523f VZ	252	_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
8414a40c	253	{
80ed523f	254	tiffis_data data = reinterpret_cast<tiffis_data >(fd);
8414a40c VZ	255
	256	switch(whence) {
	257	case SEEK_SET:
80ed523f VZ	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	}
8414a40c	270	case SEEK_CUR:
80ed523f VZ	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	}
8414a40c	280	case SEEK_END:
80ed523f VZ	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	}
8414a40c VZ	290	}
8414a40c VZ	291
80ed523f	292	return (uint64) (data->stream->tellg() - data->start_pos);
8414a40c VZ	293	}
8414a40c VZ	294
80ed523f	295	static uint64
8414a40c VZ	296	_tiffosSizeProc(thandle_t fd)
8414a40c VZ	297	{
80ed523f VZ	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;
8414a40c VZ	302
	303	os->seekp(0, ios::end);
	304	len = os->tellp();
	305	os->seekp(pos);
	306
80ed523f	307	return (uint64) len;
8414a40c VZ	308	}
8414a40c VZ	309
80ed523f	310	static uint64
8414a40c VZ	311	_tiffisSizeProc(thandle_t fd)
8414a40c VZ	312	{
80ed523f VZ	313	tiffis_data data = reinterpret_cast<tiffis_data >(fd);
	314	ios::pos_type pos = data->stream->tellg();
	315	ios::pos_type len;
8414a40c	316
80ed523f VZ	317	data->stream->seekg(0, ios::end);
	318	len = data->stream->tellg();
	319	data->stream->seekg(pos);
8414a40c	320
80ed523f	321	return (uint64) len;
8414a40c VZ	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.
80ed523f	328	delete reinterpret_cast<tiffos_data *>(fd);
8414a40c VZ	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.
80ed523f	336	delete reinterpret_cast<tiffis_data *>(fd);
8414a40c VZ	337	return 0;
	338	}
	339
	340	static int
80ed523f	341	_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
8414a40c VZ	342	{
	343	return (0);
	344	}
	345
	346	static void
80ed523f	347	_tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
8414a40c VZ	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;
80ed523f VZ	361	data->stream = reinterpret_cast<ostream *>(fd);
80ed523f VZ	362	data->start_pos = data->stream->tellp();
8414a40c VZ	363
	364	// Open for writing.
	365	tif = TIFFClientOpen(name, mode,
80ed523f VZ	366	reinterpret_cast<thandle_t>(data),
	367	_tiffosReadProc,
	368	_tiffosWriteProc,
	369	_tiffosSeekProc,
	370	_tiffosCloseProc,
8414a40c	371	_tiffosSizeProc,
80ed523f VZ	372	_tiffDummyMapProc,
80ed523f VZ	373	_tiffDummyUnmapProc);
8414a40c VZ	374	} else {
8414a40c VZ	375	tiffis_data *data = new tiffis_data;
80ed523f VZ	376	data->stream = reinterpret_cast<istream *>(fd);
80ed523f VZ	377	data->start_pos = data->stream->tellg();
8414a40c VZ	378	// Open for reading.
8414a40c VZ	379	tif = TIFFClientOpen(name, mode,
80ed523f VZ	380	reinterpret_cast<thandle_t>(data),
	381	_tiffisReadProc,
	382	_tiffisWriteProc,
	383	_tiffisSeekProc,
	384	_tiffisCloseProc,
8414a40c	385	_tiffisSizeProc,
80ed523f VZ	386	_tiffDummyMapProc,
80ed523f VZ	387	_tiffDummyUnmapProc);
8414a40c VZ	388	}
	389
	390	return (tif);
	391	}
	392
80ed523f VZ	393	} /* extern "C" */
80ed523f VZ	394
8414a40c VZ	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.
80ed523f	402	if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) {
8414a40c VZ	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: */
80ed523f VZ	419	/*
	420	Local Variables:
	421	mode: c
	422	indent-tabs-mode: true
	423	c-basic-offset: 8
	424	End:
	425	*/