/*

  Modified tif_getimage.c that takes uint64 as output pixel type

*/

/* $Id: tif_getimage.c,v 1.82 2012-06-06 00:17:49 fwarmerdam Exp $ */

/*

 * Copyright (c) 1991-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

 *

 * Read and return a packed RGBA image.

 */

#include "tiffiop.h"

#include <stdio.h></stdio.h>

typedef int (*gtFunc_32)(TIFFRGBAImage *, uint32 *, uint32, uint32);

typedef int (*gtFunc_64)(TIFFRGBAImage *, uint64 *, uint32, uint32);

typedef void (*tileContigRoutine_64)(TIFFRGBAImage *, uint64 *, uint32, uint32, uint32, uint32, int32, int32,

									 unsigned char *);

typedef void (*tileSeparateRoutine_64)(TIFFRGBAImage *, uint64 *, uint32, uint32, uint32, uint32, int32, int32,

									   unsigned char *, unsigned char *, unsigned char *, unsigned char *);

static int gtTileContig(TIFFRGBAImage *, uint64 *, uint32, uint32);

static int gtTileSeparate(TIFFRGBAImage *, uint64 *, uint32, uint32);

static int gtStripContig(TIFFRGBAImage *, uint64 *, uint32, uint32);

static int gtStripSeparate(TIFFRGBAImage *, uint64 *, uint32, uint32);

static int PickContigCase(TIFFRGBAImage *);

static int PickSeparateCase(TIFFRGBAImage *);

static int BuildMapUaToAa(TIFFRGBAImage *img);

static int BuildMapBitdepth16To8(TIFFRGBAImage *img);

static const char photoTag[] = "PhotometricInterpretation";

/* 

 * Helper constants used in Orientation tag handling

 */

#define FLIP_VERTICALLY 0x01

#define FLIP_HORIZONTALLY 0x02

/*

 * Color conversion constants. We will define display types here.

 */

static const TIFFDisplay display_sRGB = {

	{/* XYZ -> luminance matrix */

	 {3.2410F, -1.5374F, -0.4986F},

	 {-0.9692F, 1.8760F, 0.0416F},

	 {0.0556F, -0.2040F, 1.0570F}},

	100.0F,

	100.0F,

	100.0F, /* Light o/p for reference white */

	255,

	255,

	255, /* Pixel values for ref. white */

	1.0F,

	1.0F,

	1.0F, /* Residual light o/p for black pixel */

	2.4F,

	2.4F,

	2.4F, /* Gamma values for the three guns */

};

static int

isCCITTCompression(TIFF *tif)

{

	uint16 compress;

	TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);

	return (compress == COMPRESSION_CCITTFAX3 ||

			compress == COMPRESSION_CCITTFAX4 ||

			compress == COMPRESSION_CCITTRLE ||

			compress == COMPRESSION_CCITTRLEW);

}

int TIFFRGBAImageBegin_64(TIFFRGBAImage *img, TIFF *tif, int stop, char emsg[1024])

{

	uint16 *sampleinfo;

	uint16 extrasamples;

	uint16 planarconfig;

	uint16 compress;

	int colorchannels;

	uint16 *red_orig, *green_orig, *blue_orig;

	int n_color;

	/* Initialize to normal values */

	img->row_offset = 0;

	img->col_offset = 0;

	img->redcmap = NULL;

	img->greencmap = NULL;

	img->bluecmap = NULL;

	img->req_orientation = ORIENTATION_BOTLEFT; /* It is the default */

	img->tif = tif;

	img->stoponerr = stop;

	TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);

	switch (img->bitspersample) {

	case 1:

	case 2:

	case 4:

	case 8:

	case 16:

		break;

	default:

		sprintf(emsg, "Sorry, can not handle images with %d-bit samples",

				img->bitspersample);

		goto fail_return;

	}

	img->alpha = 0;

	TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);

	TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,

						  &extrasamples, &sampleinfo);

	if (extrasamples >= 1) {

		switch (sampleinfo[0]) {

		case EXTRASAMPLE_UNSPECIFIED:	 /* Workaround for some images without */

			if (img->samplesperpixel > 3) /* correct info about alpha channel */

				img->alpha = EXTRASAMPLE_ASSOCALPHA;

			break;

		case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */

		case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */

			img->alpha = sampleinfo[0];

			break;

		}

	}

#ifdef DEFAULT_EXTRASAMPLE_AS_ALPHA

	if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))

		img->photometric = PHOTOMETRIC_MINISWHITE;

	if (extrasamples == 0 && img->samplesperpixel == 4 && img->photometric == PHOTOMETRIC_RGB) {

		img->alpha = EXTRASAMPLE_ASSOCALPHA;

		extrasamples = 1;

	}

#endif

	colorchannels = img->samplesperpixel - extrasamples;

	TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);

	TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);

	if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {

		switch (colorchannels) {

		case 1:

			if (isCCITTCompression(tif))

				img->photometric = PHOTOMETRIC_MINISWHITE;

			else

				img->photometric = PHOTOMETRIC_MINISBLACK;

			break;

		case 3:

			img->photometric = PHOTOMETRIC_RGB;

			break;

		default:

			sprintf(emsg, "Missing needed %s tag", photoTag);

			goto fail_return;

		}

	}

	switch (img->photometric) {

	case PHOTOMETRIC_PALETTE:

		if (!TIFFGetField(tif, TIFFTAG_COLORMAP,

						  &red_orig, &green_orig, &blue_orig)) {

			sprintf(emsg, "Missing required \"Colormap\" tag");

			goto fail_return;

		}

		/* copy the colormaps so we can modify them */

		n_color = (1L << img->bitspersample);

		img->redcmap = (uint16 *)_TIFFmalloc(sizeof(uint16) * n_color);

		img->greencmap = (uint16 *)_TIFFmalloc(sizeof(uint16) * n_color);

		img->bluecmap = (uint16 *)_TIFFmalloc(sizeof(uint16) * n_color);

		if (!img->redcmap || !img->greencmap || !img->bluecmap) {

			sprintf(emsg, "Out of memory for colormap copy");

			goto fail_return;

		}

		_TIFFmemcpy(img->redcmap, red_orig, n_color * 2);

		_TIFFmemcpy(img->greencmap, green_orig, n_color * 2);

		_TIFFmemcpy(img->bluecmap, blue_orig, n_color * 2);

	/* fall thru... */

	case PHOTOMETRIC_MINISWHITE:

	case PHOTOMETRIC_MINISBLACK:

		if (planarconfig == PLANARCONFIG_CONTIG && img->samplesperpixel != 1 && img->bitspersample < 8) {

			sprintf(emsg,

					"Sorry, can not handle contiguous data with %s=%d, "

					"and %s=%d and Bits/Sample=%d",

					photoTag, img->photometric,

					"Samples/pixel", img->samplesperpixel,

					img->bitspersample);

			goto fail_return;

		}

		break;

	case PHOTOMETRIC_YCBCR:

		/* It would probably be nice to have a reality check here. */

		if (planarconfig == PLANARCONFIG_CONTIG)

			/* can rely on libjpeg to convert to RGB */

			/* XXX should restore current state on exit */

			switch (compress) {

			case COMPRESSION_JPEG:

				/*

						 * TODO: when complete tests verify complete desubsampling

						 * and YCbCr handling, remove use of TIFFTAG_JPEGCOLORMODE in

						 * favor of tif_getimage.c native handling

						 */

				TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);

				img->photometric = PHOTOMETRIC_RGB;

				break;

			default:

				/* do nothing */;

				break;

			}

		/*

			 * TODO: if at all meaningful and useful, make more complete

			 * support check here, or better still, refactor to let supporting

			 * code decide whether there is support and what meaningfull

			 * error to return

			 */

		break;

	case PHOTOMETRIC_RGB:

		if (colorchannels < 3) {

			sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",

					"Color channels", colorchannels);

			goto fail_return;

		}

		break;

	case PHOTOMETRIC_SEPARATED: {

		uint16 inkset;

		TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);

		if (inkset != INKSET_CMYK) {

			sprintf(emsg, "Sorry, can not handle separated image with %s=%d",

					"InkSet", inkset);

			goto fail_return;

		}

		if (img->samplesperpixel < 4) {

			sprintf(emsg, "Sorry, can not handle separated image with %s=%d",

					"Samples/pixel", img->samplesperpixel);

			goto fail_return;

		}

	} break;

	case PHOTOMETRIC_LOGL:

		if (compress != COMPRESSION_SGILOG) {

			sprintf(emsg, "Sorry, LogL data must have %s=%d",

					"Compression", COMPRESSION_SGILOG);

			goto fail_return;

		}

		TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);

		img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */

		img->bitspersample = 8;

		break;

	case PHOTOMETRIC_LOGLUV:

		if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) {

			sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",

					"Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);

			goto fail_return;

		}

		if (planarconfig != PLANARCONFIG_CONTIG) {

			sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",

					"Planarconfiguration", planarconfig);

			return (0);

		}

		TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);

		img->photometric = PHOTOMETRIC_RGB; /* little white lie */

		img->bitspersample = 8;

		break;

	case PHOTOMETRIC_CIELAB:

		break;

	default:

		sprintf(emsg, "Sorry, can not handle image with %s=%d",

				photoTag, img->photometric);

		goto fail_return;

	}

	img->Map = NULL;

	img->BWmap = NULL;

	img->PALmap = NULL;

	img->ycbcr = NULL;

	img->cielab = NULL;

	img->UaToAa = NULL;

	img->Bitdepth16To8 = NULL;

	TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);

	TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);

	TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);

	img->isContig =

		!(planarconfig == PLANARCONFIG_SEPARATE && img->samplesperpixel > 1);

	if (img->isContig) {

		if (!PickContigCase(img)) {

			sprintf(emsg, "Sorry, can not handle image");

			goto fail_return;

		}

	} else {

		if (!PickSeparateCase(img)) {

			sprintf(emsg, "Sorry, can not handle image");

			goto fail_return;

		}

	}

	return 1;

fail_return:

	_TIFFfree(img->redcmap);

	_TIFFfree(img->greencmap);

	_TIFFfree(img->bluecmap);

	img->redcmap = img->greencmap = img->bluecmap = NULL;

	return 0;

}

int TIFFRGBAImageGet_64(TIFFRGBAImage *img, uint64 *raster, uint32 w, uint32 h)

{

	gtFunc_64 get = (gtFunc_64)img->get;

	if (img->get == NULL) {

		TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No \"get\" routine setup");

		return (0);

	}

	if (img->put.any == NULL) {

		TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif),

					 "No \"put\" routine setupl; probably can not handle image format");

		return (0);

	}

	// Casting between 2 function pointers is allowed in and C++ and works as expected

	// if re-casted back.

	// See C 6.3.2.3 (8) and 5.2.10 (6)

	return (*get)(img, raster, w, h);

}

static int

setorientation(TIFFRGBAImage *img)

{

	switch (img->orientation) {

	case ORIENTATION_TOPLEFT:

	case ORIENTATION_LEFTTOP:

		if (img->req_orientation == ORIENTATION_TOPRIGHT ||

			img->req_orientation == ORIENTATION_RIGHTTOP)

			return FLIP_HORIZONTALLY;

		else if (img->req_orientation == ORIENTATION_BOTRIGHT ||

				 img->req_orientation == ORIENTATION_RIGHTBOT)

			return FLIP_HORIZONTALLY | FLIP_VERTICALLY;

		else if (img->req_orientation == ORIENTATION_BOTLEFT ||

				 img->req_orientation == ORIENTATION_LEFTBOT)

			return FLIP_VERTICALLY;

		else

			return 0;

	case ORIENTATION_TOPRIGHT:

	case ORIENTATION_RIGHTTOP:

		if (img->req_orientation == ORIENTATION_TOPLEFT ||

			img->req_orientation == ORIENTATION_LEFTTOP)

			return FLIP_HORIZONTALLY;

		else if (img->req_orientation == ORIENTATION_BOTRIGHT ||

				 img->req_orientation == ORIENTATION_RIGHTBOT)

			return FLIP_VERTICALLY;

		else if (img->req_orientation == ORIENTATION_BOTLEFT ||

				 img->req_orientation == ORIENTATION_LEFTBOT)

			return FLIP_HORIZONTALLY | FLIP_VERTICALLY;

		else

			return 0;

	case ORIENTATION_BOTRIGHT:

	case ORIENTATION_RIGHTBOT:

		if (img->req_orientation == ORIENTATION_TOPLEFT ||

			img->req_orientation == ORIENTATION_LEFTTOP)

			return FLIP_HORIZONTALLY | FLIP_VERTICALLY;

		else if (img->req_orientation == ORIENTATION_TOPRIGHT ||

				 img->req_orientation == ORIENTATION_RIGHTTOP)

			return FLIP_VERTICALLY;

		else if (img->req_orientation == ORIENTATION_BOTLEFT ||

				 img->req_orientation == ORIENTATION_LEFTBOT)

			return FLIP_HORIZONTALLY;

		else

			return 0;

	case ORIENTATION_BOTLEFT:

	case ORIENTATION_LEFTBOT:

		if (img->req_orientation == ORIENTATION_TOPLEFT ||

			img->req_orientation == ORIENTATION_LEFTTOP)

			return FLIP_VERTICALLY;

		else if (img->req_orientation == ORIENTATION_TOPRIGHT ||

				 img->req_orientation == ORIENTATION_RIGHTTOP)

			return FLIP_HORIZONTALLY | FLIP_VERTICALLY;

		else if (img->req_orientation == ORIENTATION_BOTRIGHT ||

				 img->req_orientation == ORIENTATION_RIGHTBOT)

			return FLIP_HORIZONTALLY;

		else

			return 0;

	default: /* NOTREACHED */

		return 0;

	}

}

/*

 * Get an tile-organized image that has

 *	PlanarConfiguration contiguous if SamplesPerPixel > 1

 * or

 *	SamplesPerPixel == 1

 */

static int

gtTileContig(TIFFRGBAImage *img, uint64 *raster, uint32 w, uint32 h)

{

	TIFF *tif = img->tif;

	tileContigRoutine_64 put = (tileContigRoutine_64)img->put.contig;

	uint32 col, row, y, rowstoread;

	tmsize_t pos;

	uint32 tw, th;

	unsigned char *buf;

	int32 fromskew, toskew;

	uint32 nrow;

	int ret = 1, flip;

	buf = (unsigned char *)_TIFFmalloc(TIFFTileSize(tif));

	if (buf == 0) {

		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer");

		return (0);

	}

	_TIFFmemset(buf, 0, TIFFTileSize(tif));

	TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);

	TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);

	flip = setorientation(img);

	if (flip & FLIP_VERTICALLY) {

		y = h - 1;

		toskew = -(int32)(tw + w);

	} else {

		y = 0;

		toskew = -(int32)(tw - w);

	}

	for (row = 0; row < h; row += nrow) {

		rowstoread = th - (row + img->row_offset) % th;

		nrow = (row + rowstoread > h ? h - row : rowstoread);

		for (col = 0; col < w; col += tw) {

			if (TIFFReadTile(tif, buf, col + img->col_offset,

							 row + img->row_offset, 0, 0) == (tmsize_t)(-1) &&

				img->stoponerr) {

				ret = 0;

				break;

			}

			pos = ((row + img->row_offset) % th) * TIFFTileRowSize(tif);

			if (col + tw > w) {

				/*

                 * Tile is clipped horizontally.  Calculate

                 * visible portion and skewing factors.

                 */

				uint32 npix = w - col;

				fromskew = tw - npix;

				(*put)(img, raster + y * w + col, col, y,

					   npix, nrow, fromskew, toskew + fromskew, buf + pos);

			} else {

				(*put)(img, raster + y * w + col, col, y, tw, nrow, 0, toskew, buf + pos);

			}

		}

		y += (flip & FLIP_VERTICALLY ? -(int32)nrow : (int32)nrow);

	}

	_TIFFfree(buf);

	if (flip & FLIP_HORIZONTALLY) {

		uint32 line;

		for (line = 0; line < h; line++) {

			uint64 *left = raster + (line * w);

			uint64 *right = left + w - 1;

			while (left < right) {

				uint64 temp = *left;

				*left = *right;

				*right = temp;

				left++, right--;

			}

		}

	}

	return (ret);

}

/*

 * Get an tile-organized image that has

 *	 SamplesPerPixel > 1

 *	 PlanarConfiguration separated

 * We assume that all such images are RGB.

 */

static int

gtTileSeparate(TIFFRGBAImage *img, uint64 *raster, uint32 w, uint32 h)

{

	TIFF *tif = img->tif;

	tileSeparateRoutine_64 put = (tileSeparateRoutine_64)img->put.separate;

	uint32 col, row, y, rowstoread;

	tmsize_t pos;

	uint32 tw, th;

	unsigned char *buf;

	unsigned char *p0;

	unsigned char *p1;

	unsigned char *p2;

	unsigned char *pa;

	tmsize_t tilesize;

	tmsize_t bufsize;

	int32 fromskew, toskew;

	int alpha = img->alpha;

	uint32 nrow;

	int ret = 1, flip;

	int colorchannels;

	tilesize = TIFFTileSize(tif);

	bufsize = TIFFSafeMultiply(tmsize_t, alpha ? 4 : 3, tilesize);

	if (bufsize == 0) {

		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Integer overflow in %s", "gtTileSeparate");

		return (0);

	}

	buf = (unsigned char *)_TIFFmalloc(bufsize);

	if (buf == 0) {

		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer");

		return (0);

	}

	_TIFFmemset(buf, 0, bufsize);

	p0 = buf;

	p1 = p0 + tilesize;

	p2 = p1 + tilesize;

	pa = (alpha ? (p2 + tilesize) : NULL);

	TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);

	TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);

	flip = setorientation(img);

	if (flip & FLIP_VERTICALLY) {

		y = h - 1;

		toskew = -(int32)(tw + w);

	} else {

		y = 0;

		toskew = -(int32)(tw - w);

	}

	switch (img->photometric) {

	case PHOTOMETRIC_MINISWHITE:

	case PHOTOMETRIC_MINISBLACK:

	case PHOTOMETRIC_PALETTE:

		colorchannels = 1;

		p2 = p1 = p0;

		break;

	default:

		colorchannels = 3;

		break;

	}

	for (row = 0; row < h; row += nrow) {

		rowstoread = th - (row + img->row_offset) % th;

		nrow = (row + rowstoread > h ? h - row : rowstoread);

		for (col = 0; col < w; col += tw) {

			if (TIFFReadTile(tif, p0, col + img->col_offset,

							 row + img->row_offset, 0, 0) == (tmsize_t)(-1) &&

				img->stoponerr) {

				ret = 0;

				break;

			}

			if (colorchannels > 1 && TIFFReadTile(tif, p1, col + img->col_offset, row + img->row_offset, 0, 1) == (tmsize_t)(-1) && img->stoponerr) {

				ret = 0;

				break;

			}

			if (colorchannels > 1 && TIFFReadTile(tif, p2, col + img->col_offset, row + img->row_offset, 0, 2) == (tmsize_t)(-1) && img->stoponerr) {

				ret = 0;

				break;

			}

			if (alpha && TIFFReadTile(tif, pa, col + img->col_offset, row + img->row_offset, 0, colorchannels) == (tmsize_t)(-1) && img->stoponerr) {

				ret = 0;

				break;

			}

			pos = ((row + img->row_offset) % th) * TIFFTileRowSize(tif);

			if (col + tw > w) {

				/*

				 * Tile is clipped horizontally.  Calculate

				 * visible portion and skewing factors.

				 */

				uint32 npix = w - col;

				fromskew = tw - npix;

				(*put)(img, raster + y * w + col, col, y,

					   npix, nrow, fromskew, toskew + fromskew,

					   p0 + pos, p1 + pos, p2 + pos, (alpha ? (pa + pos) : NULL));

			} else {

				(*put)(img, raster + y * w + col, col, y,

					   tw, nrow, 0, toskew, p0 + pos, p1 + pos, p2 + pos, (alpha ? (pa + pos) : NULL));

			}

		}

		y += (flip & FLIP_VERTICALLY ? -(int32)nrow : (int32)nrow);

	}

	if (flip & FLIP_HORIZONTALLY) {

		uint32 line;

		for (line = 0; line < h; line++) {

			uint64 *left = raster + (line * w);

			uint64 *right = left + w - 1;

			while (left < right) {

				uint64 temp = *left;

				*left = *right;

				*right = temp;

				left++, right--;

			}

		}

	}

	_TIFFfree(buf);

	return (ret);

}

/*

 * Get a strip-organized image that has

 *	PlanarConfiguration contiguous if SamplesPerPixel > 1

 * or

 *	SamplesPerPixel == 1

 */

static int

gtStripContig(TIFFRGBAImage *img, uint64 *raster, uint32 w, uint32 h)

{

	TIFF *tif = img->tif;

	tileContigRoutine_64 put = (tileContigRoutine_64)img->put.contig;

	uint32 row, y, nrow, nrowsub, rowstoread;

	tmsize_t pos;

	unsigned char *buf;

	uint32 rowsperstrip;

	uint16 subsamplinghor, subsamplingver;

	uint32 imagewidth = img->width;

	tmsize_t scanline;

	int32 fromskew, toskew;

	int ret = 1, flip;

	buf = (unsigned char *)_TIFFmalloc(TIFFStripSize(tif));

	if (buf == 0) {

		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");

		return (0);

	}

	_TIFFmemset(buf, 0, TIFFStripSize(tif));

	flip = setorientation(img);

	if (flip & FLIP_VERTICALLY) {

		y = h - 1;

		toskew = -(int32)(w + w);

	} else {

		y = 0;

		toskew = -(int32)(w - w);

	}

	TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);

	TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver);

	scanline = TIFFScanlineSize(tif);

	fromskew = (w < imagewidth ? imagewidth - w : 0);

	for (row = 0; row < h; row += nrow) {

		rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;

		nrow = (row + rowstoread > h ? h - row : rowstoread);

		nrowsub = nrow;

		if ((nrowsub % subsamplingver) != 0)

			nrowsub += subsamplingver - nrowsub % subsamplingver;

		if (TIFFReadEncodedStrip(tif,

								 TIFFComputeStrip(tif, row + img->row_offset, 0),

								 buf,

								 ((row + img->row_offset) % rowsperstrip + nrowsub) * scanline) == (tmsize_t)(-1) &&

			img->stoponerr) {

			ret = 0;

			break;

		}

		pos = ((row + img->row_offset) % rowsperstrip) * scanline;

		(*put)(img, raster + y * w, 0, y, w, nrow, fromskew, toskew, buf + pos);

		y += (flip & FLIP_VERTICALLY ? -(int32)nrow : (int32)nrow);

	}

	if (flip & FLIP_HORIZONTALLY) {

		uint32 line;

		for (line = 0; line < h; line++) {

			uint64 *left = raster + (line * w);

			uint64 *right = left + w - 1;

			while (left < right) {

				uint64 temp = *left;

				*left = *right;

				*right = temp;

				left++, right--;

			}

		}

	}

	_TIFFfree(buf);

	return (ret);

}

/*

 * Get a strip-organized image with

 *	 SamplesPerPixel > 1

 *	 PlanarConfiguration separated

 * We assume that all such images are RGB.

 */

static int

gtStripSeparate(TIFFRGBAImage *img, uint64 *raster, uint32 w, uint32 h)

{

	TIFF *tif = img->tif;

	tileSeparateRoutine_64 put = (tileSeparateRoutine_64)img->put.separate;

	unsigned char *buf;

	unsigned char *p0, *p1, *p2, *pa;

	uint32 row, y, nrow, rowstoread;

	tmsize_t pos;

	tmsize_t scanline;

	uint32 rowsperstrip, offset_row;

	uint32 imagewidth = img->width;

	tmsize_t stripsize;

	tmsize_t bufsize;

	int32 fromskew, toskew;

	int alpha = img->alpha;

	int ret = 1, flip, colorchannels;

	stripsize = TIFFStripSize(tif);

	bufsize = TIFFSafeMultiply(tmsize_t, alpha ? 4 : 3, stripsize);

	if (bufsize == 0) {

		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Integer overflow in %s", "gtStripSeparate");

		return (0);

	}

	p0 = buf = (unsigned char *)_TIFFmalloc(bufsize);

	if (buf == 0) {

		TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");

		return (0);

	}

	_TIFFmemset(buf, 0, bufsize);

	p1 = p0 + stripsize;

	p2 = p1 + stripsize;

	pa = (alpha ? (p2 + stripsize) : NULL);

	flip = setorientation(img);

	if (flip & FLIP_VERTICALLY) {

		y = h - 1;

		toskew = -(int32)(w + w);

	} else {

		y = 0;

		toskew = -(int32)(w - w);

	}

	switch (img->photometric) {

	case PHOTOMETRIC_MINISWHITE:

	case PHOTOMETRIC_MINISBLACK:

	case PHOTOMETRIC_PALETTE:

		colorchannels = 1;

		p2 = p1 = p0;

		break;

	default:

		colorchannels = 3;

		break;

	}

	TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);

	scanline = TIFFScanlineSize(tif);

	fromskew = (w < imagewidth ? imagewidth - w : 0);

	for (row = 0; row < h; row += nrow) {

		rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;

		nrow = (row + rowstoread > h ? h - row : rowstoread);

		offset_row = row + img->row_offset;

		if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),

								 p0, ((row + img->row_offset) % rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) &&

			img->stoponerr) {

			ret = 0;

			break;

		}

		if (colorchannels > 1 && TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), p1, ((row + img->row_offset) % rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) && img->stoponerr) {

			ret = 0;

			break;

		}

		if (colorchannels > 1 && TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), p2, ((row + img->row_offset) % rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) && img->stoponerr) {

			ret = 0;

			break;

		}

		if (alpha) {

			if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, colorchannels),

									 pa, ((row + img->row_offset) % rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) &&

				img->stoponerr) {

				ret = 0;

				break;

			}

		}

		pos = ((row + img->row_offset) % rowsperstrip) * scanline;

		(*put)(img, raster + y * w, 0, y, w, nrow, fromskew, toskew, p0 + pos, p1 + pos,

			   p2 + pos, (alpha ? (pa + pos) : NULL));

		y += (flip & FLIP_VERTICALLY ? -(int32)nrow : (int32)nrow);

	}

	if (flip & FLIP_HORIZONTALLY) {

		uint32 line;

		for (line = 0; line < h; line++) {

			uint64 *left = raster + (line * w);

			uint64 *right = left + w - 1;

			while (left < right) {

				uint64 temp = *left;

				*left = *right;

				*right = temp;

				left++, right--;

			}

		}

	}

	_TIFFfree(buf);

	return (ret);

}

/*

 * The following routines move decoded data returned

 * from the TIFF library into rasters filled with packed

 * ABGR pixels (i.e. suitable for passing to lrecwrite.)

 *

 * The routines have been created according to the most

 * important cases and optimized.  PickContigCase and

 * PickSeparateCase analyze the parameters and select

 * the appropriate "get" and "put" routine to use.

 */

#define REPEAT8(op) \

	REPEAT4(op);    \

	REPEAT4(op)

#define REPEAT4(op) \

	REPEAT2(op);    \

	REPEAT2(op)

#define REPEAT2(op) \

	op;             \

	op

#define CASE8(x, op) \

	switch (x) {     \

	case 7:          \

		op;          \

	case 6:          \

		op;          \

	case 5:          \

		op;          \

	case 4:          \

		op;          \

	case 3:          \

		op;          \

	case 2:          \

		op;          \

	case 1:          \

		op;          \

	}

#define CASE4(x, op) \

	switch (x) {     \

	case 3:          \

		op;          \

	case 2:          \

		op;          \

	case 1:          \

		op;          \

	}

#define NOP

#define UNROLL8(w, op1, op2)             \

	{                                    \

		uint32 _x;                       \

		for (_x = w; _x >= 8; _x -= 8) { \

			op1;                         \

			REPEAT8(op2);                \

		}                                \

		if (_x > 0) {                    \