/*

  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