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

/* $Id: tif_stream.cxx,v 1.5 2005/07/26 08:11:13 dron Exp $ */

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

using namespace std;

class tiffis_data
{
  public:

	istream	*myIS;
        long	myStreamStartPos;
};

class tiffos_data
{
  public:

	ostream	*myOS;
	long	myStreamStartPos;
};

static tsize_t
_tiffosReadProc(thandle_t, tdata_t, tsize_t)
{
        return 0;
}

static tsize_t
_tiffisReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
        tiffis_data	*data = (tiffis_data *)fd;

        data->myIS->read((char *)buf, (int)size);

        return data->myIS->gcount();
}

static tsize_t
_tiffosWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
	tiffos_data	*data = (tiffos_data *)fd;
	ostream		*os = data->myOS;
	int		pos = os->tellp();

	os->write((const char *)buf, size);

	return ((int)os->tellp()) - pos;
}

static tsize_t
_tiffisWriteProc(thandle_t, tdata_t, tsize_t)
{
	return 0;
}

static toff_t
_tiffosSeekProc(thandle_t fd, toff_t off, int whence)
{
	tiffos_data	*data = (tiffos_data *)fd;
	ostream	*os = data->myOS;

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

	switch(whence) {
	case SEEK_SET:
	    os->seekp(data->myStreamStartPos + off, ios::beg);
		break;
	case SEEK_CUR:
		os->seekp(off, ios::cur);
		break;
	case SEEK_END:
		os->seekp(off, 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() ) {
		ios::iostate	old_state;
		toff_t		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:
				origin = data->myStreamStartPos;
				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( origin + off > data->myStreamStartPos ) {
			toff_t	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 = origin + off - (toff_t)os->tellp();
			for( toff_t i = 0; i < num_fill; i++ )
				os->put('\0');

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

	return os->tellp();
}

static toff_t
_tiffisSeekProc(thandle_t fd, toff_t off, int whence)
{
	tiffis_data	*data = (tiffis_data *)fd;

	switch(whence) {
	case SEEK_SET:
		data->myIS->seekg(data->myStreamStartPos + off, ios::beg);
		break;
	case SEEK_CUR:
		data->myIS->seekg(off, ios::cur);
		break;
	case SEEK_END:
		data->myIS->seekg(off, ios::end);
		break;
	}

	return ((long)data->myIS->tellg()) - data->myStreamStartPos;
}

static toff_t
_tiffosSizeProc(thandle_t fd)
{
	tiffos_data	*data = (tiffos_data *)fd;
	ostream		*os = data->myOS;
	toff_t		pos = os->tellp();
	toff_t		len;

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

	return len;
}

static toff_t
_tiffisSizeProc(thandle_t fd)
{
	tiffis_data	*data = (tiffis_data *)fd;
	int		pos = data->myIS->tellg();
	int		len;

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

	return len;
}

static int
_tiffosCloseProc(thandle_t fd)
{
	// Our stream was not allocated by us, so it shouldn't be closed by us.
	delete (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 (tiffis_data *)fd;
	return 0;
}

static int
_tiffDummyMapProc(thandle_t , tdata_t* , toff_t* )
{
	return (0);
}

static void
_tiffDummyUnmapProc(thandle_t , tdata_t , toff_t )
{
}

/*
 * 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->myOS = (ostream *)fd;
		data->myStreamStartPos = data->myOS->tellp();

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

	return (tif);
}

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() && (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: */
Commit	Line	Data
8414a40c VZ	1	/* $Id: tif_stream.cxx,v 1.5 2005/07/26 08:11:13 dron Exp $ */
	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	using namespace std;
	34
	35	class tiffis_data
	36	{
	37	public:
	38
	39	istream *myIS;
	40	long myStreamStartPos;
	41	};
	42
	43	class tiffos_data
	44	{
	45	public:
	46
	47	ostream *myOS;
	48	long myStreamStartPos;
	49	};
	50
	51	static tsize_t
	52	_tiffosReadProc(thandle_t, tdata_t, tsize_t)
	53	{
	54	return 0;
	55	}
	56
	57	static tsize_t
	58	_tiffisReadProc(thandle_t fd, tdata_t buf, tsize_t size)
	59	{
	60	tiffis_data data = (tiffis_data )fd;
	61
	62	data->myIS->read((char *)buf, (int)size);
	63
	64	return data->myIS->gcount();
65	}
66
67	static tsize_t
68	_tiffosWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
69	{
70	tiffos_data data = (tiffos_data )fd;
71	ostream *os = data->myOS;
72	int pos = os->tellp();
73
74	os->write((const char *)buf, size);
75
76	return ((int)os->tellp()) - pos;
77	}
78
79	static tsize_t
80	_tiffisWriteProc(thandle_t, tdata_t, tsize_t)
81	{
82	return 0;
83	}
84
85	static toff_t
86	_tiffosSeekProc(thandle_t fd, toff_t off, int whence)
87	{
88	tiffos_data data = (tiffos_data )fd;
89	ostream *os = data->myOS;
90
91	// if the stream has already failed, don't do anything
92	if( os->fail() )
93	return os->tellp();
94
95	switch(whence) {
96	case SEEK_SET:
97	os->seekp(data->myStreamStartPos + off, ios::beg);
98	break;
99	case SEEK_CUR:
100	os->seekp(off, ios::cur);
101	break;
102	case SEEK_END:
103	os->seekp(off, ios::end);
104	break;
105	}
106
107	// Attempt to workaround problems with seeking past the end of the
108	// stream. ofstream doesn't have a problem with this but
109	// ostrstream/ostringstream does. In that situation, add intermediate
110	// '\0' characters.
111	if( os->fail() ) {
112	ios::iostate old_state;
113	toff_t origin;
114
115	old_state = os->rdstate();
116	// reset the fail bit or else tellp() won't work below
117	os->clear(os->rdstate() & ~ios::failbit);
118	switch( whence ) {
119	case SEEK_SET:
120	origin = data->myStreamStartPos;
121	break;
122	case SEEK_CUR:
123	origin = os->tellp();
124	break;
125	case SEEK_END:
126	os->seekp(0, ios::end);
127	origin = os->tellp();
128	break;
129	}
130	// restore original stream state
131	os->clear(old_state);
132
133	// only do something if desired seek position is valid
134	if( origin + off > data->myStreamStartPos ) {
135	toff_t num_fill;
136
137	// clear the fail bit
138	os->clear(os->rdstate() & ~ios::failbit);
139
140	// extend the stream to the expected size
141	os->seekp(0, ios::end);
142	num_fill = origin + off - (toff_t)os->tellp();
143	for( toff_t i = 0; i < num_fill; i++ )
144	os->put('\0');
145
146	// retry the seek
147	os->seekp(origin + off, ios::beg);
148	}
149	}
150
151	return os->tellp();
152	}
153
154	static toff_t
155	_tiffisSeekProc(thandle_t fd, toff_t off, int whence)
156	{
157	tiffis_data data = (tiffis_data )fd;
158
159	switch(whence) {
160	case SEEK_SET:
161	data->myIS->seekg(data->myStreamStartPos + off, ios::beg);
162	break;
163	case SEEK_CUR:
164	data->myIS->seekg(off, ios::cur);
165	break;
166	case SEEK_END:
167	data->myIS->seekg(off, ios::end);
168	break;
169	}
170
171	return ((long)data->myIS->tellg()) - data->myStreamStartPos;
172	}
173
174	static toff_t
175	_tiffosSizeProc(thandle_t fd)
176	{
177	tiffos_data data = (tiffos_data )fd;
178	ostream *os = data->myOS;
179	toff_t pos = os->tellp();
180	toff_t len;
181
182	os->seekp(0, ios::end);
183	len = os->tellp();
184	os->seekp(pos);
185
186	return len;
187	}
188
189	static toff_t
190	_tiffisSizeProc(thandle_t fd)
191	{
192	tiffis_data data = (tiffis_data )fd;
193	int pos = data->myIS->tellg();
194	int len;
195
196	data->myIS->seekg(0, ios::end);
197	len = data->myIS->tellg();
198	data->myIS->seekg(pos);
199
200	return len;
201	}
202
203	static int
204	_tiffosCloseProc(thandle_t fd)
205	{
206	// Our stream was not allocated by us, so it shouldn't be closed by us.
207	delete (tiffos_data *)fd;
208	return 0;
209	}
210
211	static int
212	_tiffisCloseProc(thandle_t fd)
213	{
214	// Our stream was not allocated by us, so it shouldn't be closed by us.
215	delete (tiffis_data *)fd;
216	return 0;
217	}
218
219	static int
220	_tiffDummyMapProc(thandle_t , tdata_t* , toff_t* )
221	{
222	return (0);
223	}
224
225	static void
226	_tiffDummyUnmapProc(thandle_t , tdata_t , toff_t )
227	{
228	}
229
230	/*
231	* Open a TIFF file descriptor for read/writing.
232	*/
233	static TIFF*
234	_tiffStreamOpen(const char* name, const char* mode, void *fd)
235	{
236	TIFF* tif;
237
238	if( strchr(mode, 'w') ) {
239	tiffos_data *data = new tiffos_data;
240	data->myOS = (ostream *)fd;
241	data->myStreamStartPos = data->myOS->tellp();
242
243	// Open for writing.
244	tif = TIFFClientOpen(name, mode,
245	(thandle_t) data,
246	_tiffosReadProc, _tiffosWriteProc,
247	_tiffosSeekProc, _tiffosCloseProc,
248	_tiffosSizeProc,
249	_tiffDummyMapProc, _tiffDummyUnmapProc);
250	} else {
251	tiffis_data *data = new tiffis_data;
252	data->myIS = (istream *)fd;
253	data->myStreamStartPos = data->myIS->tellg();
254	// Open for reading.
255	tif = TIFFClientOpen(name, mode,
256	(thandle_t) data,
257	_tiffisReadProc, _tiffisWriteProc,
258	_tiffisSeekProc, _tiffisCloseProc,
259	_tiffisSizeProc,
260	_tiffDummyMapProc, _tiffDummyUnmapProc);
261	}
262
263	return (tif);
264	}
265
266	TIFF*
267	TIFFStreamOpen(const char* name, ostream *os)
268	{
269	// If os is either a ostrstream or ostringstream, and has no data
270	// written to it yet, then tellp() will return -1 which will break us.
271	// We workaround this by writing out a dummy character and
272	// then seek back to the beginning.
273	if( !os->fail() && (int)os->tellp() < 0 ) {
274	*os << '\0';
275	os->seekp(0);
276	}
277
278	// NB: We don't support mapped files with streams so add 'm'
279	return _tiffStreamOpen(name, "wm", os);
280	}
281
282	TIFF*
283	TIFFStreamOpen(const char* name, istream *is)
284	{
285	// NB: We don't support mapped files with streams so add 'm'
286	return _tiffStreamOpen(name, "rm", is);
287	}
288
289	/* vim: set ts=8 sts=8 sw=8 noet: */