[wxWidgets.git] / src / tiff / libtiff / tif_stream.cxx


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