[wxWidgets.git] / src / tiff / tif_read.c

/* $Header$ */

/*
 * Copyright (c) 1988-1997 Sam Leffler
 * Copyright (c) 1991-1997 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.
 * Scanline-oriented Read Support
 */
#include "tiffiop.h"
#include <stdio.h>
#include <assert.h>

	int TIFFFillStrip(TIFF*, tstrip_t);
	int TIFFFillTile(TIFF*, ttile_t);
static	int TIFFStartStrip(TIFF*, tstrip_t);
static	int TIFFStartTile(TIFF*, ttile_t);
static	int TIFFCheckRead(TIFF*, int);

#define	NOSTRIP	((tstrip_t) -1)			/* undefined state */
#define	NOTILE	((ttile_t) -1)			/* undefined state */

/*
 * Seek to a random row+sample in a file.
 */
static int
TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
{
	register TIFFDirectory *td = &tif->tif_dir;
	tstrip_t strip;

	if (row >= td->td_imagelength) {	/* out of range */
		TIFFError(tif->tif_name, "%lu: Row out of range, max %lu",
		    (u_long) row, (u_long) td->td_imagelength);
		return (0);
	}
	if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
		if (sample >= td->td_samplesperpixel) {
			TIFFError(tif->tif_name,
			    "%lu: Sample out of range, max %lu",
			    (u_long) sample, (u_long) td->td_samplesperpixel);
			return (0);
		}
		strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
	} else
		strip = row / td->td_rowsperstrip;
	if (strip != tif->tif_curstrip) { 	/* different strip, refill */
		if (!TIFFFillStrip(tif, strip))
			return (0);
	} else if (row < tif->tif_row) {
		/*
		 * Moving backwards within the same strip: backup
		 * to the start and then decode forward (below).
		 *
		 * NB: If you're planning on lots of random access within a
		 * strip, it's better to just read and decode the entire
		 * strip, and then access the decoded data in a random fashion.
		 */
		if (!TIFFStartStrip(tif, strip))
			return (0);
	}
	if (row != tif->tif_row) {
		/*
		 * Seek forward to the desired row.
		 */
		if (!(*tif->tif_seek)(tif, row - tif->tif_row))
			return (0);
		tif->tif_row = row;
	}
	return (1);
}

int
TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
{
	int e;

	if (!TIFFCheckRead(tif, 0))
		return (-1);
	if( (e = TIFFSeek(tif, row, sample)) != 0) {
		/*
		 * Decompress desired row into user buffer.
		 */
		e = (*tif->tif_decoderow)
		    (tif, (tidata_t) buf, tif->tif_scanlinesize, sample);

                /* we are now poised at the beginning of the next row */
                tif->tif_row = row + 1;

		if (e)
			(*tif->tif_postdecode)(tif, (tidata_t) buf,
			    tif->tif_scanlinesize);
	}
	return (e > 0 ? 1 : -1);
}

/*
 * Read a strip of data and decompress the specified
 * amount into the user-supplied buffer.
 */
tsize_t
TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
{
	TIFFDirectory *td = &tif->tif_dir;
	uint32 nrows;
	tsize_t stripsize;
        tstrip_t sep_strip, strips_per_sep;

	if (!TIFFCheckRead(tif, 0))
		return (-1);
	if (strip >= td->td_nstrips) {
		TIFFError(tif->tif_name, "%ld: Strip out of range, max %ld",
		    (long) strip, (long) td->td_nstrips);
		return (-1);
	}
	/*
	 * Calculate the strip size according to the number of
	 * rows in the strip (check for truncated last strip on any
         * of the separations).
	 */
        if( td->td_rowsperstrip >= td->td_imagelength )
            strips_per_sep = 1;
        else
            strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
                / td->td_rowsperstrip;

        sep_strip = strip % strips_per_sep;

	if (sep_strip != strips_per_sep-1 ||
	    (nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
		nrows = td->td_rowsperstrip;

	stripsize = TIFFVStripSize(tif, nrows);
	if (size == (tsize_t) -1)
		size = stripsize;
	else if (size > stripsize)
		size = stripsize;
	if (TIFFFillStrip(tif, strip) 
            && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size, 
                         (tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
		(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
		return (size);
	} else
		return ((tsize_t) -1);
}

static tsize_t
TIFFReadRawStrip1(TIFF* tif,
    tstrip_t strip, tdata_t buf, tsize_t size, const char* module)
{
	TIFFDirectory *td = &tif->tif_dir;

	if (!isMapped(tif)) {
		tsize_t cc;

		if (!SeekOK(tif, td->td_stripoffset[strip])) {
			TIFFError(module,
			    "%s: Seek error at scanline %lu, strip %lu",
			    tif->tif_name,
			    (u_long) tif->tif_row, (u_long) strip);
			return (-1);
		}
		cc = TIFFReadFile(tif, buf, size);
		if (cc != size) {
			TIFFError(module,
		"%s: Read error at scanline %lu; got %lu bytes, expected %lu",
			    tif->tif_name,
			    (u_long) tif->tif_row,
			    (u_long) cc,
			    (u_long) size);
			return (-1);
		}
	} else {
		if (td->td_stripoffset[strip] + size > tif->tif_size) {
			TIFFError(module,
    "%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu",
			    tif->tif_name,
			    (u_long) tif->tif_row,
			    (u_long) strip,
			    (u_long) tif->tif_size - td->td_stripoffset[strip],
			    (u_long) size);
			return (-1);
		}
		_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip], size);
	}
	return (size);
}

/*
 * Read a strip of data from the file.
 */
tsize_t
TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
{
	static const char module[] = "TIFFReadRawStrip";
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t bytecount;

	if (!TIFFCheckRead(tif, 0))
		return ((tsize_t) -1);
	if (strip >= td->td_nstrips) {
		TIFFError(tif->tif_name, "%lu: Strip out of range, max %lu",
		    (u_long) strip, (u_long) td->td_nstrips);
		return ((tsize_t) -1);
	}
	bytecount = td->td_stripbytecount[strip];
	if (bytecount <= 0) {
		TIFFError(tif->tif_name,
		    "%lu: Invalid strip byte count, strip %lu",
		    (u_long) bytecount, (u_long) strip);
		return ((tsize_t) -1);
	}
	if (size != (tsize_t)-1 && size < bytecount)
		bytecount = size;
	return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
}

/*
 * Read the specified strip and setup for decoding. 
 * The data buffer is expanded, as necessary, to
 * hold the strip's data.
 */
int
TIFFFillStrip(TIFF* tif, tstrip_t strip)
{
	static const char module[] = "TIFFFillStrip";
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t bytecount;

	bytecount = td->td_stripbytecount[strip];
	if (bytecount <= 0) {
		TIFFError(tif->tif_name,
		    "%lu: Invalid strip byte count, strip %lu",
		    (u_long) bytecount, (u_long) strip);
		return (0);
	}
	if (isMapped(tif) &&
	    (isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) {
		/*
		 * The image is mapped into memory and we either don't
		 * need to flip bits or the compression routine is going
		 * to handle this operation itself.  In this case, avoid
		 * copying the raw data and instead just reference the
		 * data from the memory mapped file image.  This assumes
		 * that the decompression routines do not modify the
		 * contents of the raw data buffer (if they try to,
		 * the application will get a fault since the file is
		 * mapped read-only).
		 */
		if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
			_TIFFfree(tif->tif_rawdata);
		tif->tif_flags &= ~TIFF_MYBUFFER;
		if ( td->td_stripoffset[strip] + bytecount > tif->tif_size) {
			/*
			 * This error message might seem strange, but it's
			 * what would happen if a read were done instead.
			 */
			TIFFError(module,
		    "%s: Read error on strip %lu; got %lu bytes, expected %lu",
			    tif->tif_name,
			    (u_long) strip,
			    (u_long) tif->tif_size - td->td_stripoffset[strip],
			    (u_long) bytecount);
			tif->tif_curstrip = NOSTRIP;
			return (0);
		}
		tif->tif_rawdatasize = bytecount;
		tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
	} else {
		/*
		 * Expand raw data buffer, if needed, to
		 * hold data strip coming from file
		 * (perhaps should set upper bound on
		 *  the size of a buffer we'll use?).
		 */
		if (bytecount > tif->tif_rawdatasize) {
			tif->tif_curstrip = NOSTRIP;
			if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
				TIFFError(module,
				"%s: Data buffer too small to hold strip %lu",
				    tif->tif_name, (u_long) strip);
				return (0);
			}
			if (!TIFFReadBufferSetup(tif, 0,
			    TIFFroundup(bytecount, 1024)))
				return (0);
		}
		if (TIFFReadRawStrip1(tif, strip, (u_char *)tif->tif_rawdata,
		    bytecount, module) != bytecount)
			return (0);
		if (!isFillOrder(tif, td->td_fillorder) &&
		    (tif->tif_flags & TIFF_NOBITREV) == 0)
			TIFFReverseBits(tif->tif_rawdata, bytecount);
	}
	return (TIFFStartStrip(tif, strip));
}

/*
 * Tile-oriented Read Support
 * Contributed by Nancy Cam (Silicon Graphics).
 */

/*
 * Read and decompress a tile of data.  The
 * tile is selected by the (x,y,z,s) coordinates.
 */
tsize_t
TIFFReadTile(TIFF* tif,
    tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
{
	if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
		return (-1);
	return (TIFFReadEncodedTile(tif,
	    TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
}

/*
 * Read a tile of data and decompress the specified
 * amount into the user-supplied buffer.
 */
tsize_t
TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
{
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t tilesize = tif->tif_tilesize;

	if (!TIFFCheckRead(tif, 1))
		return (-1);
	if (tile >= td->td_nstrips) {
		TIFFError(tif->tif_name, "%ld: Tile out of range, max %ld",
		    (long) tile, (u_long) td->td_nstrips);
		return (-1);
	}
	if (size == (tsize_t) -1)
		size = tilesize;
	else if (size > tilesize)
		size = tilesize;
	if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
	    (tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) {
		(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
		return (size);
	} else
		return (-1);
}

static tsize_t
TIFFReadRawTile1(TIFF* tif,
    ttile_t tile, tdata_t buf, tsize_t size, const char* module)
{
	TIFFDirectory *td = &tif->tif_dir;

	if (!isMapped(tif)) {
		tsize_t cc;

		if (!SeekOK(tif, td->td_stripoffset[tile])) {
			TIFFError(module,
			    "%s: Seek error at row %ld, col %ld, tile %ld",
			    tif->tif_name,
			    (long) tif->tif_row,
			    (long) tif->tif_col,
			    (long) tile);
			return ((tsize_t) -1);
		}
		cc = TIFFReadFile(tif, buf, size);
		if (cc != size) {
			TIFFError(module,
	    "%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu",
			    tif->tif_name,
			    (long) tif->tif_row,
			    (long) tif->tif_col,
			    (u_long) cc,
			    (u_long) size);
			return ((tsize_t) -1);
		}
	} else {
		if (td->td_stripoffset[tile] + size > tif->tif_size) {
			TIFFError(module,
    "%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu",
			    tif->tif_name,
			    (long) tif->tif_row,
			    (long) tif->tif_col,
			    (long) tile,
			    (u_long) tif->tif_size - td->td_stripoffset[tile],
			    (u_long) size);
			return ((tsize_t) -1);
		}
		_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size);
	}
	return (size);
}

/*
 * Read a tile of data from the file.
 */
tsize_t
TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
{
	static const char module[] = "TIFFReadRawTile";
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t bytecount;

	if (!TIFFCheckRead(tif, 1))
		return ((tsize_t) -1);
	if (tile >= td->td_nstrips) {
		TIFFError(tif->tif_name, "%lu: Tile out of range, max %lu",
		    (u_long) tile, (u_long) td->td_nstrips);
		return ((tsize_t) -1);
	}
	bytecount = td->td_stripbytecount[tile];
	if (size != (tsize_t) -1 && size < bytecount)
		bytecount = size;
	return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
}

/*
 * Read the specified tile and setup for decoding. 
 * The data buffer is expanded, as necessary, to
 * hold the tile's data.
 */
int
TIFFFillTile(TIFF* tif, ttile_t tile)
{
	static const char module[] = "TIFFFillTile";
	TIFFDirectory *td = &tif->tif_dir;
	tsize_t bytecount;

	bytecount = td->td_stripbytecount[tile];
	if (bytecount <= 0) {
		TIFFError(tif->tif_name,
		    "%lu: Invalid tile byte count, tile %lu",
		    (u_long) bytecount, (u_long) tile);
		return (0);
	}
	if (isMapped(tif) &&
	    (isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) {
		/*
		 * The image is mapped into memory and we either don't
		 * need to flip bits or the compression routine is going
		 * to handle this operation itself.  In this case, avoid
		 * copying the raw data and instead just reference the
		 * data from the memory mapped file image.  This assumes
		 * that the decompression routines do not modify the
		 * contents of the raw data buffer (if they try to,
		 * the application will get a fault since the file is
		 * mapped read-only).
		 */
		if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
			_TIFFfree(tif->tif_rawdata);
		tif->tif_flags &= ~TIFF_MYBUFFER;
		if ( td->td_stripoffset[tile] + bytecount > tif->tif_size) {
			tif->tif_curtile = NOTILE;
			return (0);
		}
		tif->tif_rawdatasize = bytecount;
		tif->tif_rawdata = tif->tif_base + td->td_stripoffset[tile];
	} else {
		/*
		 * Expand raw data buffer, if needed, to
		 * hold data tile coming from file
		 * (perhaps should set upper bound on
		 *  the size of a buffer we'll use?).
		 */
		if (bytecount > tif->tif_rawdatasize) {
			tif->tif_curtile = NOTILE;
			if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
				TIFFError(module,
				"%s: Data buffer too small to hold tile %ld",
				    tif->tif_name, (long) tile);
				return (0);
			}
			if (!TIFFReadBufferSetup(tif, 0,
			    TIFFroundup(bytecount, 1024)))
				return (0);
		}
		if (TIFFReadRawTile1(tif, tile, (u_char *)tif->tif_rawdata,
		    bytecount, module) != bytecount)
			return (0);
		if (!isFillOrder(tif, td->td_fillorder) &&
		    (tif->tif_flags & TIFF_NOBITREV) == 0)
			TIFFReverseBits(tif->tif_rawdata, bytecount);
	}
	return (TIFFStartTile(tif, tile));
}

/*
 * Setup the raw data buffer in preparation for
 * reading a strip of raw data.  If the buffer
 * is specified as zero, then a buffer of appropriate
 * size is allocated by the library.  Otherwise,
 * the client must guarantee that the buffer is
 * large enough to hold any individual strip of
 * raw data.
 */
int
TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
{
	static const char module[] = "TIFFReadBufferSetup";

	if (tif->tif_rawdata) {
		if (tif->tif_flags & TIFF_MYBUFFER)
			_TIFFfree(tif->tif_rawdata);
		tif->tif_rawdata = NULL;
	}
	if (bp) {
		tif->tif_rawdatasize = size;
		tif->tif_rawdata = (tidata_t) bp;
		tif->tif_flags &= ~TIFF_MYBUFFER;
	} else {
		tif->tif_rawdatasize = TIFFroundup(size, 1024);
		tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize);
		tif->tif_flags |= TIFF_MYBUFFER;
	}
	if (tif->tif_rawdata == NULL) {
		TIFFError(module,
		    "%s: No space for data buffer at scanline %ld",
		    tif->tif_name, (long) tif->tif_row);
		tif->tif_rawdatasize = 0;
		return (0);
	}
	return (1);
}

/*
 * Set state to appear as if a
 * strip has just been read in.
 */
static int
TIFFStartStrip(TIFF* tif, tstrip_t strip)
{
	TIFFDirectory *td = &tif->tif_dir;

	if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
		if (!(*tif->tif_setupdecode)(tif))
			return (0);
		tif->tif_flags |= TIFF_CODERSETUP;
	}
	tif->tif_curstrip = strip;
	tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
	tif->tif_rawcp = tif->tif_rawdata;
	tif->tif_rawcc = td->td_stripbytecount[strip];
	return ((*tif->tif_predecode)(tif,
			(tsample_t)(strip / td->td_stripsperimage)));
}

/*
 * Set state to appear as if a
 * tile has just been read in.
 */
static int
TIFFStartTile(TIFF* tif, ttile_t tile)
{
	TIFFDirectory *td = &tif->tif_dir;

	if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
		if (!(*tif->tif_setupdecode)(tif))
			return (0);
		tif->tif_flags |= TIFF_CODERSETUP;
	}
	tif->tif_curtile = tile;
	tif->tif_row =
	    (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) *
		td->td_tilelength;
	tif->tif_col =
	    (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
		td->td_tilewidth;
	tif->tif_rawcp = tif->tif_rawdata;
	tif->tif_rawcc = td->td_stripbytecount[tile];
	return ((*tif->tif_predecode)(tif,
			(tsample_t)(tile/td->td_stripsperimage)));
}

static int
TIFFCheckRead(TIFF* tif, int tiles)
{
	if (tif->tif_mode == O_WRONLY) {
		TIFFError(tif->tif_name, "File not open for reading");
		return (0);
	}
	if (tiles ^ isTiled(tif)) {
		TIFFError(tif->tif_name, tiles ?
		    "Can not read tiles from a stripped image" :
		    "Can not read scanlines from a tiled image");
		return (0);
	}
	return (1);
}

void
_TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
{
    (void) tif; (void) buf; (void) cc;
}

void
_TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc)
{
    (void) tif;
    assert((cc & 1) == 0);
    TIFFSwabArrayOfShort((uint16*) buf, cc/2);
}

void
_TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc)
{
    (void) tif;
    assert((cc & 3) == 0);
    TIFFSwabArrayOfLong((uint32*) buf, cc/4);
}

void
_TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc)
{
    (void) tif;
    assert((cc & 7) == 0);
    TIFFSwabArrayOfDouble((double*) buf, cc/8);
}
Commit	Line	Data
b47c832e RR	1	/* $Header$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 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.
	29	* Scanline-oriented Read Support
	30	*/
	31	#include "tiffiop.h"
	32	#include <stdio.h>
	33	#include <assert.h>
	34
00cb87b4 VZ	35	int TIFFFillStrip(TIFF*, tstrip_t);
00cb87b4 VZ	36	int TIFFFillTile(TIFF*, ttile_t);
b47c832e RR	37	static int TIFFStartStrip(TIFF*, tstrip_t);
	38	static int TIFFStartTile(TIFF*, ttile_t);
	39	static int TIFFCheckRead(TIFF*, int);
	40
	41	#define NOSTRIP ((tstrip_t) -1) /* undefined state */
	42	#define NOTILE ((ttile_t) -1) /* undefined state */
	43
	44	/*
	45	* Seek to a random row+sample in a file.
	46	*/
	47	static int
	48	TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
	49	{
	50	register TIFFDirectory *td = &tif->tif_dir;
	51	tstrip_t strip;
	52
	53	if (row >= td->td_imagelength) { /* out of range */
	54	TIFFError(tif->tif_name, "%lu: Row out of range, max %lu",
	55	(u_long) row, (u_long) td->td_imagelength);
	56	return (0);
	57	}
	58	if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
	59	if (sample >= td->td_samplesperpixel) {
	60	TIFFError(tif->tif_name,
	61	"%lu: Sample out of range, max %lu",
	62	(u_long) sample, (u_long) td->td_samplesperpixel);
	63	return (0);
	64	}
	65	strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
	66	} else
	67	strip = row / td->td_rowsperstrip;
	68	if (strip != tif->tif_curstrip) { /* different strip, refill */
	69	if (!TIFFFillStrip(tif, strip))
	70	return (0);
	71	} else if (row < tif->tif_row) {
	72	/*
	73	* Moving backwards within the same strip: backup
	74	* to the start and then decode forward (below).
	75	*
	76	* NB: If you're planning on lots of random access within a
	77	* strip, it's better to just read and decode the entire
	78	* strip, and then access the decoded data in a random fashion.
	79	*/
	80	if (!TIFFStartStrip(tif, strip))
	81	return (0);
	82	}
	83	if (row != tif->tif_row) {
	84	/*
	85	* Seek forward to the desired row.
	86	*/
	87	if (!(*tif->tif_seek)(tif, row - tif->tif_row))
	88	return (0);
	89	tif->tif_row = row;
	90	}
	91	return (1);
	92	}
	93
	94	int
	95	TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
	96	{
	97	int e;
	98
	99	if (!TIFFCheckRead(tif, 0))
	100	return (-1);
101	if( (e = TIFFSeek(tif, row, sample)) != 0) {
102	/*
103	* Decompress desired row into user buffer.
104	*/
105	e = (*tif->tif_decoderow)
106	(tif, (tidata_t) buf, tif->tif_scanlinesize, sample);
00cb87b4 VZ	107
	108	/* we are now poised at the beginning of the next row */
	109	tif->tif_row = row + 1;
	110
b47c832e RR	111	if (e)
	112	(*tif->tif_postdecode)(tif, (tidata_t) buf,
	113	tif->tif_scanlinesize);
	114	}
	115	return (e > 0 ? 1 : -1);
	116	}
	117
	118	/*
	119	* Read a strip of data and decompress the specified
	120	* amount into the user-supplied buffer.
	121	*/
	122	tsize_t
	123	TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
	124	{
	125	TIFFDirectory *td = &tif->tif_dir;
	126	uint32 nrows;
	127	tsize_t stripsize;
00cb87b4	128	tstrip_t sep_strip, strips_per_sep;
b47c832e RR	129
	130	if (!TIFFCheckRead(tif, 0))
	131	return (-1);
	132	if (strip >= td->td_nstrips) {
	133	TIFFError(tif->tif_name, "%ld: Strip out of range, max %ld",
	134	(long) strip, (long) td->td_nstrips);
	135	return (-1);
	136	}
	137	/*
	138	* Calculate the strip size according to the number of
00cb87b4 VZ	139	* rows in the strip (check for truncated last strip on any
00cb87b4 VZ	140	* of the separations).
b47c832e	141	*/
00cb87b4 VZ	142	if( td->td_rowsperstrip >= td->td_imagelength )
	143	strips_per_sep = 1;
	144	else
	145	strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
	146	/ td->td_rowsperstrip;
	147
	148	sep_strip = strip % strips_per_sep;
	149
	150	if (sep_strip != strips_per_sep-1 \|\|
b47c832e RR	151	(nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
b47c832e RR	152	nrows = td->td_rowsperstrip;
00cb87b4	153
b47c832e RR	154	stripsize = TIFFVStripSize(tif, nrows);
	155	if (size == (tsize_t) -1)
	156	size = stripsize;
	157	else if (size > stripsize)
	158	size = stripsize;
00cb87b4 VZ	159	if (TIFFFillStrip(tif, strip)
	160	&& (*tif->tif_decodestrip)(tif, (tidata_t) buf, size,
	161	(tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
b47c832e RR	162	(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
	163	return (size);
	164	} else
	165	return ((tsize_t) -1);
	166	}
	167
	168	static tsize_t
	169	TIFFReadRawStrip1(TIFF* tif,
	170	tstrip_t strip, tdata_t buf, tsize_t size, const char* module)
	171	{
	172	TIFFDirectory *td = &tif->tif_dir;
	173
	174	if (!isMapped(tif)) {
	175	tsize_t cc;
	176
	177	if (!SeekOK(tif, td->td_stripoffset[strip])) {
	178	TIFFError(module,
	179	"%s: Seek error at scanline %lu, strip %lu",
	180	tif->tif_name,
	181	(u_long) tif->tif_row, (u_long) strip);
	182	return (-1);
	183	}
	184	cc = TIFFReadFile(tif, buf, size);
	185	if (cc != size) {
	186	TIFFError(module,
	187	"%s: Read error at scanline %lu; got %lu bytes, expected %lu",
	188	tif->tif_name,
	189	(u_long) tif->tif_row,
	190	(u_long) cc,
	191	(u_long) size);
	192	return (-1);
	193	}
	194	} else {
	195	if (td->td_stripoffset[strip] + size > tif->tif_size) {
	196	TIFFError(module,
	197	"%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu",
	198	tif->tif_name,
	199	(u_long) tif->tif_row,
	200	(u_long) strip,
	201	(u_long) tif->tif_size - td->td_stripoffset[strip],
	202	(u_long) size);
	203	return (-1);
	204	}
	205	_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip], size);
	206	}
	207	return (size);
	208	}
	209
	210	/*
	211	* Read a strip of data from the file.
	212	*/
	213	tsize_t
	214	TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
	215	{
	216	static const char module[] = "TIFFReadRawStrip";
	217	TIFFDirectory *td = &tif->tif_dir;
	218	tsize_t bytecount;
	219
	220	if (!TIFFCheckRead(tif, 0))
	221	return ((tsize_t) -1);
	222	if (strip >= td->td_nstrips) {
	223	TIFFError(tif->tif_name, "%lu: Strip out of range, max %lu",
	224	(u_long) strip, (u_long) td->td_nstrips);
	225	return ((tsize_t) -1);
226	}
227	bytecount = td->td_stripbytecount[strip];
228	if (bytecount <= 0) {
229	TIFFError(tif->tif_name,
230	"%lu: Invalid strip byte count, strip %lu",
231	(u_long) bytecount, (u_long) strip);
232	return ((tsize_t) -1);
233	}
234	if (size != (tsize_t)-1 && size < bytecount)
235	bytecount = size;
236	return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
237	}
238
239	/*
240	* Read the specified strip and setup for decoding.
241	* The data buffer is expanded, as necessary, to
242	* hold the strip's data.
243	*/
00cb87b4	244	int
b47c832e RR	245	TIFFFillStrip(TIFF* tif, tstrip_t strip)
	246	{
	247	static const char module[] = "TIFFFillStrip";
	248	TIFFDirectory *td = &tif->tif_dir;
	249	tsize_t bytecount;
	250
	251	bytecount = td->td_stripbytecount[strip];
	252	if (bytecount <= 0) {
	253	TIFFError(tif->tif_name,
	254	"%lu: Invalid strip byte count, strip %lu",
	255	(u_long) bytecount, (u_long) strip);
	256	return (0);
	257	}
	258	if (isMapped(tif) &&
	259	(isFillOrder(tif, td->td_fillorder) \|\| (tif->tif_flags & TIFF_NOBITREV))) {
	260	/*
	261	* The image is mapped into memory and we either don't
	262	* need to flip bits or the compression routine is going
	263	* to handle this operation itself. In this case, avoid
	264	* copying the raw data and instead just reference the
	265	* data from the memory mapped file image. This assumes
	266	* that the decompression routines do not modify the
	267	* contents of the raw data buffer (if they try to,
	268	* the application will get a fault since the file is
	269	* mapped read-only).
	270	*/
	271	if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
	272	_TIFFfree(tif->tif_rawdata);
	273	tif->tif_flags &= ~TIFF_MYBUFFER;
00cb87b4	274	if ( td->td_stripoffset[strip] + bytecount > tif->tif_size) {
b47c832e RR	275	/*
	276	* This error message might seem strange, but it's
	277	* what would happen if a read were done instead.
	278	*/
	279	TIFFError(module,
	280	"%s: Read error on strip %lu; got %lu bytes, expected %lu",
	281	tif->tif_name,
	282	(u_long) strip,
	283	(u_long) tif->tif_size - td->td_stripoffset[strip],
	284	(u_long) bytecount);
	285	tif->tif_curstrip = NOSTRIP;
	286	return (0);
	287	}
	288	tif->tif_rawdatasize = bytecount;
	289	tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
	290	} else {
	291	/*
	292	* Expand raw data buffer, if needed, to
	293	* hold data strip coming from file
	294	* (perhaps should set upper bound on
	295	* the size of a buffer we'll use?).
	296	*/
	297	if (bytecount > tif->tif_rawdatasize) {
	298	tif->tif_curstrip = NOSTRIP;
	299	if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
	300	TIFFError(module,
	301	"%s: Data buffer too small to hold strip %lu",
	302	tif->tif_name, (u_long) strip);
	303	return (0);
	304	}
	305	if (!TIFFReadBufferSetup(tif, 0,
	306	TIFFroundup(bytecount, 1024)))
	307	return (0);
	308	}
	309	if (TIFFReadRawStrip1(tif, strip, (u_char *)tif->tif_rawdata,
	310	bytecount, module) != bytecount)
	311	return (0);
	312	if (!isFillOrder(tif, td->td_fillorder) &&
	313	(tif->tif_flags & TIFF_NOBITREV) == 0)
	314	TIFFReverseBits(tif->tif_rawdata, bytecount);
	315	}
	316	return (TIFFStartStrip(tif, strip));
	317	}
	318
	319	/*
	320	* Tile-oriented Read Support
	321	* Contributed by Nancy Cam (Silicon Graphics).
	322	*/
	323
	324	/*
	325	* Read and decompress a tile of data. The
	326	* tile is selected by the (x,y,z,s) coordinates.
	327	*/
	328	tsize_t
	329	TIFFReadTile(TIFF* tif,
	330	tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
	331	{
	332	if (!TIFFCheckRead(tif, 1) \|\| !TIFFCheckTile(tif, x, y, z, s))
	333	return (-1);
	334	return (TIFFReadEncodedTile(tif,
	335	TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
	336	}
	337
	338	/*
339	* Read a tile of data and decompress the specified
340	* amount into the user-supplied buffer.
341	*/
342	tsize_t
343	TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
344	{
345	TIFFDirectory *td = &tif->tif_dir;
346	tsize_t tilesize = tif->tif_tilesize;
347
348	if (!TIFFCheckRead(tif, 1))
349	return (-1);
350	if (tile >= td->td_nstrips) {
351	TIFFError(tif->tif_name, "%ld: Tile out of range, max %ld",
352	(long) tile, (u_long) td->td_nstrips);
353	return (-1);
354	}
355	if (size == (tsize_t) -1)
356	size = tilesize;
357	else if (size > tilesize)
358	size = tilesize;
359	if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
360	(tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) {
361	(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
362	return (size);
363	} else
364	return (-1);
365	}
366
367	static tsize_t
368	TIFFReadRawTile1(TIFF* tif,
369	ttile_t tile, tdata_t buf, tsize_t size, const char* module)
370	{
371	TIFFDirectory *td = &tif->tif_dir;
372
373	if (!isMapped(tif)) {
374	tsize_t cc;
375
376	if (!SeekOK(tif, td->td_stripoffset[tile])) {
377	TIFFError(module,
378	"%s: Seek error at row %ld, col %ld, tile %ld",
379	tif->tif_name,
380	(long) tif->tif_row,
381	(long) tif->tif_col,
382	(long) tile);
383	return ((tsize_t) -1);
384	}
385	cc = TIFFReadFile(tif, buf, size);
386	if (cc != size) {
387	TIFFError(module,
388	"%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu",
389	tif->tif_name,
390	(long) tif->tif_row,
391	(long) tif->tif_col,
392	(u_long) cc,
393	(u_long) size);
394	return ((tsize_t) -1);
395	}
396	} else {
397	if (td->td_stripoffset[tile] + size > tif->tif_size) {
398	TIFFError(module,
399	"%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu",
400	tif->tif_name,
401	(long) tif->tif_row,
402	(long) tif->tif_col,
403	(long) tile,
404	(u_long) tif->tif_size - td->td_stripoffset[tile],
405	(u_long) size);
406	return ((tsize_t) -1);
407	}
408	_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size);
409	}
410	return (size);
411	}
412
413	/*
414	* Read a tile of data from the file.
415	*/
416	tsize_t
417	TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
418	{
419	static const char module[] = "TIFFReadRawTile";
420	TIFFDirectory *td = &tif->tif_dir;
421	tsize_t bytecount;
422
423	if (!TIFFCheckRead(tif, 1))
424	return ((tsize_t) -1);
425	if (tile >= td->td_nstrips) {
426	TIFFError(tif->tif_name, "%lu: Tile out of range, max %lu",
427	(u_long) tile, (u_long) td->td_nstrips);
428	return ((tsize_t) -1);
429	}
430	bytecount = td->td_stripbytecount[tile];
431	if (size != (tsize_t) -1 && size < bytecount)
432	bytecount = size;
433	return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
434	}
435
436	/*
437	* Read the specified tile and setup for decoding.
438	* The data buffer is expanded, as necessary, to
439	* hold the tile's data.
440	*/
00cb87b4	441	int
b47c832e RR	442	TIFFFillTile(TIFF* tif, ttile_t tile)
	443	{
	444	static const char module[] = "TIFFFillTile";
	445	TIFFDirectory *td = &tif->tif_dir;
	446	tsize_t bytecount;
	447
	448	bytecount = td->td_stripbytecount[tile];
	449	if (bytecount <= 0) {
	450	TIFFError(tif->tif_name,
	451	"%lu: Invalid tile byte count, tile %lu",
	452	(u_long) bytecount, (u_long) tile);
	453	return (0);
	454	}
	455	if (isMapped(tif) &&
	456	(isFillOrder(tif, td->td_fillorder) \|\| (tif->tif_flags & TIFF_NOBITREV))) {
	457	/*
	458	* The image is mapped into memory and we either don't
	459	* need to flip bits or the compression routine is going
	460	* to handle this operation itself. In this case, avoid
	461	* copying the raw data and instead just reference the
	462	* data from the memory mapped file image. This assumes
	463	* that the decompression routines do not modify the
	464	* contents of the raw data buffer (if they try to,
	465	* the application will get a fault since the file is
	466	* mapped read-only).
	467	*/
	468	if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
	469	_TIFFfree(tif->tif_rawdata);
	470	tif->tif_flags &= ~TIFF_MYBUFFER;
00cb87b4	471	if ( td->td_stripoffset[tile] + bytecount > tif->tif_size) {
b47c832e RR	472	tif->tif_curtile = NOTILE;
	473	return (0);
	474	}
	475	tif->tif_rawdatasize = bytecount;
	476	tif->tif_rawdata = tif->tif_base + td->td_stripoffset[tile];
	477	} else {
	478	/*
	479	* Expand raw data buffer, if needed, to
	480	* hold data tile coming from file
	481	* (perhaps should set upper bound on
	482	* the size of a buffer we'll use?).
	483	*/
	484	if (bytecount > tif->tif_rawdatasize) {
	485	tif->tif_curtile = NOTILE;
	486	if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
	487	TIFFError(module,
	488	"%s: Data buffer too small to hold tile %ld",
	489	tif->tif_name, (long) tile);
	490	return (0);
	491	}
	492	if (!TIFFReadBufferSetup(tif, 0,
	493	TIFFroundup(bytecount, 1024)))
	494	return (0);
	495	}
	496	if (TIFFReadRawTile1(tif, tile, (u_char *)tif->tif_rawdata,
	497	bytecount, module) != bytecount)
	498	return (0);
	499	if (!isFillOrder(tif, td->td_fillorder) &&
	500	(tif->tif_flags & TIFF_NOBITREV) == 0)
	501	TIFFReverseBits(tif->tif_rawdata, bytecount);
	502	}
	503	return (TIFFStartTile(tif, tile));
	504	}
	505
	506	/*
	507	* Setup the raw data buffer in preparation for
	508	* reading a strip of raw data. If the buffer
	509	* is specified as zero, then a buffer of appropriate
	510	* size is allocated by the library. Otherwise,
	511	* the client must guarantee that the buffer is
	512	* large enough to hold any individual strip of
	513	* raw data.
	514	*/
	515	int
	516	TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
	517	{
	518	static const char module[] = "TIFFReadBufferSetup";
	519
	520	if (tif->tif_rawdata) {
	521	if (tif->tif_flags & TIFF_MYBUFFER)
	522	_TIFFfree(tif->tif_rawdata);
	523	tif->tif_rawdata = NULL;
	524	}
	525	if (bp) {
	526	tif->tif_rawdatasize = size;
	527	tif->tif_rawdata = (tidata_t) bp;
	528	tif->tif_flags &= ~TIFF_MYBUFFER;
	529	} else {
	530	tif->tif_rawdatasize = TIFFroundup(size, 1024);
	531	tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize);
	532	tif->tif_flags \|= TIFF_MYBUFFER;
	533	}
	534	if (tif->tif_rawdata == NULL) {
	535	TIFFError(module,
536	"%s: No space for data buffer at scanline %ld",
537	tif->tif_name, (long) tif->tif_row);
538	tif->tif_rawdatasize = 0;
539	return (0);
540	}
541	return (1);
542	}
543
544	/*
545	* Set state to appear as if a
546	* strip has just been read in.
547	*/
548	static int
549	TIFFStartStrip(TIFF* tif, tstrip_t strip)
550	{
551	TIFFDirectory *td = &tif->tif_dir;
552
553	if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
554	if (!(*tif->tif_setupdecode)(tif))
555	return (0);
556	tif->tif_flags \|= TIFF_CODERSETUP;
557	}
558	tif->tif_curstrip = strip;
559	tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
560	tif->tif_rawcp = tif->tif_rawdata;
561	tif->tif_rawcc = td->td_stripbytecount[strip];
562	return ((*tif->tif_predecode)(tif,
563	(tsample_t)(strip / td->td_stripsperimage)));
564	}
565
566	/*
567	* Set state to appear as if a
568	* tile has just been read in.
569	*/
570	static int
571	TIFFStartTile(TIFF* tif, ttile_t tile)
572	{
573	TIFFDirectory *td = &tif->tif_dir;
574
575	if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
576	if (!(*tif->tif_setupdecode)(tif))
577	return (0);
578	tif->tif_flags \|= TIFF_CODERSETUP;
579	}
580	tif->tif_curtile = tile;
581	tif->tif_row =
582	(tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) *
583	td->td_tilelength;
584	tif->tif_col =
585	(tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
586	td->td_tilewidth;
587	tif->tif_rawcp = tif->tif_rawdata;
588	tif->tif_rawcc = td->td_stripbytecount[tile];
589	return ((*tif->tif_predecode)(tif,
590	(tsample_t)(tile/td->td_stripsperimage)));
591	}
592
593	static int
594	TIFFCheckRead(TIFF* tif, int tiles)
595	{
596	if (tif->tif_mode == O_WRONLY) {
597	TIFFError(tif->tif_name, "File not open for reading");
598	return (0);
599	}
600	if (tiles ^ isTiled(tif)) {
601	TIFFError(tif->tif_name, tiles ?
602	"Can not read tiles from a stripped image" :
603	"Can not read scanlines from a tiled image");
604	return (0);
605	}
606	return (1);
607	}
608
609	void
610	_TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
611	{
612	(void) tif; (void) buf; (void) cc;
613	}
614
615	void
616	_TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc)
617	{
618	(void) tif;
619	assert((cc & 1) == 0);
620	TIFFSwabArrayOfShort((uint16*) buf, cc/2);
621	}
622
623	void
624	_TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc)
625	{
626	(void) tif;
627	assert((cc & 3) == 0);
628	TIFFSwabArrayOfLong((uint32*) buf, cc/4);
629	}
630
631	void
632	_TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc)
633	{
634	(void) tif;
635	assert((cc & 7) == 0);
636	TIFFSwabArrayOfDouble((double*) buf, cc/8);
637	}