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_t	_tiffosSeekProc (thandle_t fd, uint64_t off, int whence)
static uint64_t	_tiffisSeekProc (thandle_t fd, uint64_t off, int whence)
static uint64_t	_tiffosSizeProc (thandle_t fd)
static uint64_t	_tiffisSizeProc (thandle_t fd)
static int	_tiffosCloseProc (thandle_t fd)
static int	_tiffisCloseProc (thandle_t fd)
static int	_tiffDummyMapProcCxx (thandle_t, void **base, toff_t *size)
static void	_tiffDummyUnmapProcCxx (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

_tiffDummyMapProcCxx()

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

static

Definition at line 327 of file tif_stream.cxx.

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

Referenced by _tiffStreamOpen().

_tiffDummyUnmapProcCxx()

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

static

Definition at line 334 of file tif_stream.cxx.

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

Referenced by _tiffStreamOpen().

_tiffisCloseProc()

static int _tiffisCloseProc ( thandle_t  fd )

static

Definition at line 320 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 108 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_t _tiffisSeekProc ( thandle_t  fd, uint64_t  off, int  whence  )

static

Definition at line 241 of file tif_stream.cxx.

    {
        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
 
        switch (whence)
        {
            case SEEK_SET:
            {
                // Compute 64-bit offset
                uint64_t new_offset =
                    static_cast<uint64_t>(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_t>(offset) != new_offset)
                    return static_cast<uint64_t>(-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_t>(offset) != off)
                    return static_cast<uint64_t>(-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_t>(offset) != off)
                    return static_cast<uint64_t>(-1);
 
                data->stream->seekg(offset, ios::end);
                break;
            }
        }
 
        return (uint64_t)(data->stream->tellg() - data->start_pos);
    }

Referenced by _tiffStreamOpen().

_tiffisSizeProc()

static uint64_t _tiffisSizeProc ( thandle_t  fd )

static

Definition at line 300 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_t)len;
    }

Referenced by _tiffStreamOpen().

_tiffisWriteProc()

static tmsize_t _tiffisWriteProc ( thandle_t  , void *  , tmsize_t    )

static

Definition at line 138 of file tif_stream.cxx.

{ return 0; }

Referenced by _tiffStreamOpen().

_tiffosCloseProc()

static int _tiffosCloseProc ( thandle_t  fd )

static

Definition at line 313 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 106 of file tif_stream.cxx.

{ return 0; }

Referenced by _tiffStreamOpen().

_tiffosSeekProc()

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

static

Definition at line 140 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_t>(-1);
 
        switch (whence)
        {
            case SEEK_SET:
            {
                // Compute 64-bit offset
                uint64_t new_offset =
                    static_cast<uint64_t>(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_t>(offset) != new_offset)
                    return static_cast<uint64_t>(-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_t>(offset) != off)
                    return static_cast<uint64_t>(-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_t>(offset) != off)
                    return static_cast<uint64_t>(-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())
        {
            ios::iostate old_state;
            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_t>(origin) + off) >
                static_cast<uint64_t>(data->start_pos))
            {
                uint64_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 = (static_cast<uint64_t>(origin)) + off - os->tellp();
                for (uint64_t i = 0; i < num_fill; i++)
                    os->put('\0');
 
                // retry the seek
                os->seekp(static_cast<ios::off_type>(
                              static_cast<uint64_t>(origin) + off),
                          ios::beg);
            }
        }
 
        return static_cast<uint64_t>(os->tellp());
    }

Referenced by _tiffStreamOpen().

_tiffosSizeProc()

static uint64_t _tiffosSizeProc ( thandle_t  fd )

static

Definition at line 286 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_t)len;
    }

Referenced by _tiffStreamOpen().

_tiffosWriteProc()

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

static

Definition at line 122 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 343 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, _tiffDummyMapProcCxx, _tiffDummyUnmapProcCxx);
            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, _tiffDummyMapProcCxx, _tiffDummyUnmapProcCxx);
            if (!tif)
            {
                delete data;
            }
        }
 
        return (tif);
    }

Referenced by TIFFStreamOpen().

TIFFStreamOpen() [1/2]

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

Definition at line 400 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 384 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);
}