tif_stream.cxx File Reference

#include "tiffiop.h"
#include <iostream>

Include dependency graph for tif_stream.cxx:

Go to the source code of this file.

Classes
struct	tiffis_data
struct	tiffos_data

Functions
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)
TIFF *	TIFFStreamOpen (const char *name, ostream *os)
TIFF *	TIFFStreamOpen (const char *name, istream *is)

Function Documentation

_tiffDummyMapProc()

static int _tiffDummyMapProc ( thandle_t  , void **  base, toff_t *  size  )

static

Definition at line 339 of file tif_stream.cxx.

{
    (void) base;
    (void) size;
    return (0);
}

Referenced by _tiffStreamOpen().

_tiffDummyUnmapProc()

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

static

Definition at line 347 of file tif_stream.cxx.

{
    (void) base;
    (void) size;
}

Referenced by _tiffStreamOpen().

_tiffisCloseProc()

static int _tiffisCloseProc ( thandle_t  fd )

static

Definition at line 331 of file tif_stream.cxx.

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

Referenced by _tiffStreamOpen().

_tiffisReadProc()

static tmsize_t _tiffisReadProc ( thandle_t  fd, void *  buf, tmsize_t  size  )

static

Definition at line 114 of file tif_stream.cxx.

{
        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());
}

Referenced by _tiffStreamOpen().

_tiffisSeekProc()

static uint64 _tiffisSeekProc ( thandle_t  fd, uint64  off, int  whence  )

static

Definition at line 250 of file tif_stream.cxx.

{
    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);
}

Referenced by _tiffStreamOpen().

_tiffisSizeProc()

static uint64 _tiffisSizeProc ( thandle_t  fd )

static

Definition at line 309 of file tif_stream.cxx.

{
    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;
}

Referenced by _tiffStreamOpen().

_tiffisWriteProc()

static tmsize_t _tiffisWriteProc ( thandle_t  , void *  , tmsize_t    )

static

Definition at line 146 of file tif_stream.cxx.

{
    return 0;
}

Referenced by _tiffStreamOpen().

_tiffosCloseProc()

static int _tiffosCloseProc ( thandle_t  fd )

static

Definition at line 323 of file tif_stream.cxx.

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

Referenced by _tiffStreamOpen().

_tiffosReadProc()

static tmsize_t _tiffosReadProc ( thandle_t  , void *  , tmsize_t    )

static

Definition at line 108 of file tif_stream.cxx.

{
        return 0;
}

Referenced by _tiffStreamOpen().

_tiffosSeekProc()

static uint64 _tiffosSeekProc ( thandle_t  fd, uint64  off, int  whence  )

static

Definition at line 152 of file tif_stream.cxx.

{
    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());
}

Referenced by _tiffStreamOpen().

_tiffosSizeProc()

static uint64 _tiffosSizeProc ( thandle_t  fd )

static

Definition at line 294 of file tif_stream.cxx.

{
    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;
}

Referenced by _tiffStreamOpen().

_tiffosWriteProc()

static tmsize_t _tiffosWriteProc ( thandle_t  fd, void *  buf, tmsize_t  size  )

static

Definition at line 129 of file tif_stream.cxx.

{
    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);
}

Referenced by _tiffStreamOpen().

_tiffStreamOpen()

static TIFF * _tiffStreamOpen ( const char *  name, const char *  mode, void *  fd  )

static

Definition at line 357 of file tif_stream.cxx.

{
    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);
        if (!tif) {
            delete data;
        }
    } 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);
        if (!tif) {
            delete data;
        }
    }
 
    return (tif);
}

Referenced by TIFFStreamOpen().

TIFFStreamOpen() [1/2]

TIFF * TIFFStreamOpen	(	const char *	name,
		istream *	is
	)

Definition at line 420 of file tif_stream.cxx.

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

TIFFStreamOpen() [2/2]

TIFF * TIFFStreamOpen	(	const char *	name,
		ostream *	os
	)

Definition at line 404 of file tif_stream.cxx.

{
    // 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);
}