#include "fitz.h"
#include "muxps.h"

int
xps_decode_tiff(xps_context_t *ctx, byte *buf, int len, xps_image_t *image)
{
	return fz_throw("TIFF codec is not available");
}

#if 0

#include "stream.h"
#include "strimpl.h"
#include "gsstate.h"
#include "jpeglib_.h"
#include "sdct.h"
#include "sjpeg.h"
#include "srlx.h"
#include "slzwx.h"
#include "szlibx.h"
#include "scfx.h"
#include "memory_.h"

/*
 * TIFF image loader. Should be enough to support TIFF files in XPS.
 * Baseline TIFF 6.0 plus CMYK, LZW, Flate and JPEG support.
 * Limited bit depths (1,2,4,8).
 * Limited planar configurations (1=chunky).
 * No tiles (easy fix if necessary).
 * TODO: RGBPal images
 */

typedef struct xps_tiff_s xps_tiff_t;

struct xps_tiff_s
{
	/* "file" */
	byte *bp, *rp, *ep;

	/* byte order */
	unsigned order;

	/* where we can find the strips of image data */
	unsigned rowsperstrip;
	unsigned *stripoffsets;
	unsigned *stripbytecounts;

	/* colormap */
	unsigned *colormap;

	/* assorted tags */
	unsigned subfiletype;
	unsigned photometric;
	unsigned compression;
	unsigned imagewidth;
	unsigned imagelength;
	unsigned samplesperpixel;
	unsigned bitspersample;
	unsigned planar;
	unsigned extrasamples;
	unsigned xresolution;
	unsigned yresolution;
	unsigned resolutionunit;
	unsigned fillorder;
	unsigned g3opts;
	unsigned g4opts;
	unsigned predictor;

	unsigned ycbcrsubsamp[2];

	byte *jpegtables;		/* point into "file" buffer */
	unsigned jpegtableslen;

	byte *profile;
	int profilesize;
};

enum
{
	TII = 0x4949, /* 'II' */
	TMM = 0x4d4d, /* 'MM' */
	TBYTE = 1,
	TASCII = 2,
	TSHORT = 3,
	TLONG = 4,
	TRATIONAL = 5
};

#define NewSubfileType							254
#define ImageWidth								256
#define ImageLength								257
#define BitsPerSample							258
#define Compression								259
#define PhotometricInterpretation				262
#define FillOrder								266
#define StripOffsets							273
#define SamplesPerPixel							277
#define RowsPerStrip							278
#define StripByteCounts							279
#define XResolution								282
#define YResolution								283
#define PlanarConfiguration						284
#define T4Options								292
#define T6Options								293
#define ResolutionUnit							296
#define Predictor								317
#define ColorMap								320
#define TileWidth								322
#define TileLength								323
#define TileOffsets								324
#define TileByteCounts							325
#define ExtraSamples							338
#define JPEGTables								347
#define YCbCrSubSampling						520
#define ICCProfile								34675

static const byte bitrev[256] =
{
	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
	0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
	0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
	0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
	0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
	0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
	0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
	0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
	0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
	0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
	0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
	0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
	0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
	0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
	0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
	0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
	0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};

static int
xps_report_error(stream_state * st, const char *str)
{
	(void) fz_throw("%s", str);
	return 0;
}

static inline int
readbyte(xps_tiff_t *tiff)
{
	if (tiff->rp < tiff->ep)
		return *tiff->rp++;
	return EOF;
}

static inline unsigned
readshort(xps_tiff_t *tiff)
{
	unsigned a = readbyte(tiff);
	unsigned b = readbyte(tiff);
	if (tiff->order == TII)
		return (b << 8) | a;
	return (a << 8) | b;
}

static inline unsigned
readlong(xps_tiff_t *tiff)
{
	unsigned a = readbyte(tiff);
	unsigned b = readbyte(tiff);
	unsigned c = readbyte(tiff);
	unsigned d = readbyte(tiff);
	if (tiff->order == TII)
		return (d << 24) | (c << 16) | (b << 8) | a;
	return (a << 24) | (b << 16) | (c << 8) | d;
}

static int
xps_decode_tiff_uncompressed(xps_context_t *ctx, xps_tiff_t *tiff, byte *rp, byte *rl, byte *wp, byte *wl)
{
	memcpy(wp, rp, wl - wp);
	return gs_okay;
}

static int
xps_decode_tiff_packbits(xps_context_t *ctx, xps_tiff_t *tiff, byte *rp, byte *rl, byte *wp, byte *wl)
{
	stream_RLD_state state;
	stream_cursor_read scr;
	stream_cursor_write scw;
	int code;

	s_init_state((stream_state*)&state, &s_RLD_template, ctx->memory);
	state.report_error = xps_report_error;

	s_RLD_template.set_defaults((stream_state*)&state);
	s_RLD_template.init((stream_state*)&state);

	scr.ptr = rp - 1;
	scr.limit = rl - 1;
	scw.ptr = wp - 1;
	scw.limit = wl - 1;

	code = s_RLD_template.process((stream_state*)&state, &scr, &scw, true);
	if (code == ERRC)
		return fz_throw("error in packbits data (code = %d)", code);

	return gs_okay;
}

static int
xps_decode_tiff_lzw(xps_context_t *ctx, xps_tiff_t *tiff, byte *rp, byte *rl, byte *wp, byte *wl)
{
	stream_LZW_state state;
	stream_cursor_read scr;
	stream_cursor_write scw;
	int code;

	s_init_state((stream_state*)&state, &s_LZWD_template, ctx->memory);
	state.report_error = xps_report_error;

	s_LZWD_template.set_defaults((stream_state*)&state);

	/* old-style TIFF 5.0 reversed bit order, late change */
	if (rp[0] == 0 && rp[1] & 0x01)
	{
		state.EarlyChange = 0;
		state.FirstBitLowOrder = 1;
	}

	/* new-style TIFF 6.0 normal bit order, early change */
	else
	{
		state.EarlyChange = 1;
		state.FirstBitLowOrder = 0;
	}

	s_LZWD_template.init((stream_state*)&state);

	scr.ptr = rp - 1;
	scr.limit = rl - 1;
	scw.ptr = wp - 1;
	scw.limit = wl - 1;

	code = s_LZWD_template.process((stream_state*)&state, &scr, &scw, true);
	if (code == ERRC)
	{
		s_LZWD_template.release((stream_state*)&state);
		return fz_throw("error in lzw data (code = %d)", code);
	}

	s_LZWD_template.release((stream_state*)&state);

	return gs_okay;
}

static int
xps_decode_tiff_flate(xps_context_t *ctx, xps_tiff_t *tiff, byte *rp, byte *rl, byte *wp, byte *wl)
{
	stream_zlib_state state;
	stream_cursor_read scr;
	stream_cursor_write scw;
	int code;

	s_init_state((stream_state*)&state, &s_zlibD_template, ctx->memory);
	state.report_error = xps_report_error;

	s_zlibD_template.set_defaults((stream_state*)&state);

	s_zlibD_template.init((stream_state*)&state);

	scr.ptr = rp - 1;
	scr.limit = rl - 1;
	scw.ptr = wp - 1;
	scw.limit = wl - 1;

	code = s_zlibD_template.process((stream_state*)&state, &scr, &scw, true);
	if (code == ERRC)
	{
		s_zlibD_template.release((stream_state*)&state);
		return fz_throw("error in flate data (code = %d)", code);
	}

	s_zlibD_template.release((stream_state*)&state);
	return gs_okay;
}

static int
xps_decode_tiff_fax(xps_context_t *ctx, xps_tiff_t *tiff, int comp, byte *rp, byte *rl, byte *wp, byte *wl)
{
	stream_CFD_state state;
	stream_cursor_read scr;
	stream_cursor_write scw;
	int code;

	s_init_state((stream_state*)&state, &s_CFD_template, ctx->memory);
	state.report_error = xps_report_error;

	s_CFD_template.set_defaults((stream_state*)&state);

	state.EndOfLine = false;
	state.EndOfBlock = false;
	state.Columns = tiff->imagewidth;
	state.Rows = tiff->imagelength;
	state.BlackIs1 = tiff->photometric == 0;

	state.K = 0;
	if (comp == 4)
		state.K = -1;
	if (comp == 2)
		state.EncodedByteAlign = true;

	s_CFD_template.init((stream_state*)&state);

	scr.ptr = rp - 1;
	scr.limit = rl - 1;
	scw.ptr = wp - 1;
	scw.limit = wl - 1;

	code = s_CFD_template.process((stream_state*)&state, &scr, &scw, true);
	if (code == ERRC)
	{
		s_CFD_template.release((stream_state*)&state);
		return fz_throw("error in fax data (code = %d)", code);
	}

	s_CFD_template.release((stream_state*)&state);
	return gs_okay;
}

/*
 * We need more find control over JPEG decoding parameters than
 * the s_DCTD_template filter will give us. So we abuse the
 * filter, and take control after the filter setup (which sets up
 * the memory manager and error handling) and call the gs_jpeg
 * wrappers directly for doing the actual decoding.
 */

static int
xps_decode_tiff_jpeg(xps_context_t *ctx, xps_tiff_t *tiff, byte *rp, byte *rl, byte *wp, byte *wl)
{
	stream_DCT_state state; /* used by gs_jpeg_* wrappers */
	jpeg_decompress_data jddp;
	struct jpeg_source_mgr *srcmgr;
	JSAMPROW scanlines[1];
	int stride;
	int code;

	/*
	 * Set up the JPEG and DCT filter voodoo.
	 */

	s_init_state((stream_state*)&state, &s_DCTD_template, ctx->memory);
	state.report_error = xps_report_error;
	s_DCTD_template.set_defaults((stream_state*)&state);

	state.jpeg_memory = ctx->memory;
	state.data.decompress = &jddp;

	jddp.template = s_DCTD_template;
	jddp.memory = ctx->memory;
	jddp.scanline_buffer = NULL;

	if ((code = gs_jpeg_create_decompress(&state)) < 0)
		return fz_throw("error in gs_jpeg_create_decompress");

	s_DCTD_template.init((stream_state*)&state);

	srcmgr = jddp.dinfo.src;

	/*
	 * Read the abbreviated table file.
	 */

	if (tiff->jpegtables)
	{
		srcmgr->next_input_byte = tiff->jpegtables;
		srcmgr->bytes_in_buffer = tiff->jpegtableslen;

		code = gs_jpeg_read_header(&state, FALSE);
		if (code != JPEG_HEADER_TABLES_ONLY)
			return fz_throw("error in jpeg table data");
	}

	/*
	 * Read the image jpeg header.
	 */

	srcmgr->next_input_byte = rp;
	srcmgr->bytes_in_buffer = rl - rp;

	if ((code = gs_jpeg_read_header(&state, TRUE)) < 0)
		return fz_throw("error in jpeg_read_header");

	/* when TIFF says RGB and libjpeg says YCbCr, libjpeg is wrong */
	if (tiff->photometric == 2 && jddp.dinfo.jpeg_color_space == JCS_YCbCr)
	{
		jddp.dinfo.jpeg_color_space = JCS_RGB;
	}

	/*
	 * Decode the strip image data.
	 */

	if ((code = gs_jpeg_start_decompress(&state)) < 0)
		return fz_throw("error in jpeg_start_decompress");

	stride = jddp.dinfo.output_width * jddp.dinfo.output_components;

	while (wp + stride <= wl && jddp.dinfo.output_scanline < jddp.dinfo.output_height)
	{
		scanlines[0] = wp;
		code = gs_jpeg_read_scanlines(&state, scanlines, 1);
		if (code < 0)
			return gs_throw(01, "error in jpeg_read_scanlines");
		wp += stride;
	}

	/*
	 * Clean up.
	 */

	if ((code = gs_jpeg_finish_decompress(&state)) < 0)
		return fz_throw("error in jpeg_finish_decompress");

	gs_jpeg_destroy(&state);

	return gs_okay;
}

static inline int
getcomp(byte *line, int x, int bpc)
{
	switch (bpc)
	{
	case 1: return line[x / 8] >> (7 - (x % 8)) & 0x01;
	case 2: return line[x / 4] >> ((3 - (x % 4)) * 2) & 0x03;
	case 4: return line[x / 2] >> ((1 - (x % 2)) * 4) & 0x0f;
	case 8: return line[x];
	case 16: return ((line[x * 2 + 0]) << 8) | (line[x * 2 + 1]);
	}
	return 0;
}

static inline void
putcomp(byte *line, int x, int bpc, int value)
{
	int maxval = (1 << bpc) - 1;

	// clear bits first
	switch (bpc)
	{
	case 1: line[x / 8] &= ~(maxval << (7 - (x % 8))); break;
	case 2: line[x / 4] &= ~(maxval << ((3 - (x % 4)) * 2)); break;
	case 4: line[x / 2] &= ~(maxval << ((1 - (x % 2)) * 4)); break;
	}

	switch (bpc)
	{
	case 1: line[x / 8] |= value << (7 - (x % 8)); break;
	case 2: line[x / 4] |= value << ((3 - (x % 4)) * 2); break;
	case 4: line[x / 2] |= value << ((1 - (x % 2)) * 4); break;
	case 8: line[x] = value; break;
	case 16: line[x * 2 + 0] = value >> 8; line[x * 2 + 1] = value & 0xFF; break;
	}
}

static void
xps_unpredict_tiff(byte *line, int width, int comps, int bits)
{
	byte left[32];
	int i, k, v;

	for (k = 0; k < comps; k++)
		left[k] = 0;

	for (i = 0; i < width; i++)
	{
		for (k = 0; k < comps; k++)
		{
			v = getcomp(line, i * comps + k, bits);
			v = v + left[k];
			v = v % (1 << bits);
			putcomp(line, i * comps + k, bits, v);
			left[k] = v;
		}
	}
}

static void
xps_invert_tiff(byte *line, int width, int comps, int bits, int alpha)
{
	int i, k, v;
	int m = (1 << bits) - 1;

	for (i = 0; i < width; i++)
	{
		for (k = 0; k < comps; k++)
		{
			v = getcomp(line, i * comps + k, bits);
			if (!alpha || k < comps - 1)
				v = m - v;
			putcomp(line, i * comps + k, bits, v);
		}
	}
}

static int
xps_expand_colormap(xps_context_t *ctx, xps_tiff_t *tiff, xps_image_t *image)
{
	int maxval = 1 << image->bits;
	byte *samples;
	byte *src, *dst;
	int stride;
	int x, y;

	/* colormap has first all red, then all green, then all blue values */
	/* colormap values are 0..65535, bits is 4 or 8 */
	/* image can be with or without extrasamples: comps is 1 or 2 */

	if (image->comps != 1 && image->comps != 2)
		return fz_throw("invalid number of samples for RGBPal");

	if (image->bits != 4 && image->bits != 8)
		return fz_throw("invalid number of bits for RGBPal");

	stride = image->width * (image->comps + 2);

	samples = xps_alloc(ctx, stride * image->height);
	if (!samples)
		return fz_throw("out of memory: samples");

	for (y = 0; y < image->height; y++)
	{
		src = image->samples + (image->stride * y);
		dst = samples + (stride * y);

		for (x = 0; x < image->width; x++)
		{
			if (tiff->extrasamples)
			{
				int c = getcomp(src, x * 2, image->bits);
				int a = getcomp(src, x * 2 + 1, image->bits);
				*dst++ = tiff->colormap[c + 0] >> 8;
				*dst++ = tiff->colormap[c + maxval] >> 8;
				*dst++ = tiff->colormap[c + maxval * 2] >> 8;
				*dst++ = a << (8 - image->bits);
			}
			else
			{
				int c = getcomp(src, x, image->bits);
				*dst++ = tiff->colormap[c + 0] >> 8;
				*dst++ = tiff->colormap[c + maxval] >> 8;
				*dst++ = tiff->colormap[c + maxval * 2] >> 8;
			}
		}
	}

	image->bits = 8;
	image->stride = stride;
	image->samples = samples;

	return gs_okay;
}

static int
xps_decode_tiff_strips(xps_context_t *ctx, xps_tiff_t *tiff, xps_image_t *image)
{
	int error;

	/* switch on compression to create a filter */
	/* feed each strip to the filter */
	/* read out the data and pack the samples into an xps_image */

	/* type 32773 / packbits -- nothing special (same row-padding as PDF) */
	/* type 2 / ccitt rle -- no EOL, no RTC, rows are byte-aligned */
	/* type 3 and 4 / g3 and g4 -- each strip starts new section */
	/* type 5 / lzw -- each strip is handled separately */

	byte *wp;
	unsigned row;
	unsigned strip;
	unsigned i;

	if (!tiff->rowsperstrip || !tiff->stripoffsets || !tiff->rowsperstrip)
		return fz_throw("no image data in tiff; maybe it is tiled");

	if (tiff->planar != 1)
		return fz_throw("image data is not in chunky format");

	image->width = tiff->imagewidth;
	image->height = tiff->imagelength;
	image->comps = tiff->samplesperpixel;
	image->bits = tiff->bitspersample;
	image->stride = (image->width * image->comps * image->bits + 7) / 8;

	switch (tiff->photometric)
	{
	case 0: /* WhiteIsZero -- inverted */
		image->colorspace = ctx->gray;
		break;
	case 1: /* BlackIsZero */
		image->colorspace = ctx->gray;
		break;
	case 2: /* RGB */
		image->colorspace = ctx->srgb;
		break;
	case 3: /* RGBPal */
		image->colorspace = ctx->srgb;
		break;
	case 5: /* CMYK */
		image->colorspace = ctx->cmyk;
		break;
	case 6: /* YCbCr */
		/* it's probably a jpeg ... we let jpeg convert to rgb */
		image->colorspace = ctx->srgb;
		break;
	default:
		return fz_throw("unknown photometric: %d", tiff->photometric);
	}

	switch (tiff->resolutionunit)
	{
	case 2:
		image->xres = tiff->xresolution;
		image->yres = tiff->yresolution;
		break;
	case 3:
		image->xres = tiff->xresolution * 2.54 + 0.5;
		image->yres = tiff->yresolution * 2.54 + 0.5;

		break;
	default:
		image->xres = 96;
		image->yres = 96;
		break;
	}

	/* Note xres and yres could be 0 even if unit was set. If so default to 96dpi */
	if (image->xres == 0 || image->yres == 0)
	{
		image->xres = 96;
		image->yres = 96;
	}

	image->samples = xps_alloc(ctx, image->stride * image->height);
	if (!image->samples)
		return fz_throw("could not allocate image samples");

	memset(image->samples, 0x55, image->stride * image->height);

	wp = image->samples;

	strip = 0;
	for (row = 0; row < tiff->imagelength; row += tiff->rowsperstrip)
	{
		unsigned offset = tiff->stripoffsets[strip];
		unsigned rlen = tiff->stripbytecounts[strip];
		unsigned wlen = image->stride * tiff->rowsperstrip;
		byte *rp = tiff->bp + offset;

		if (wp + wlen > image->samples + image->stride * image->height)
			wlen = image->samples + image->stride * image->height - wp;

		if (rp + rlen > tiff->ep)
			return fz_throw("strip extends beyond the end of the file");

		/* the bits are in un-natural order */
		if (tiff->fillorder == 2)
			for (i = 0; i < rlen; i++)
				rp[i] = bitrev[rp[i]];

		switch (tiff->compression)
		{
		case 1:
			error = xps_decode_tiff_uncompressed(ctx, tiff, rp, rp + rlen, wp, wp + wlen);
			break;
		case 2:
			error = xps_decode_tiff_fax(ctx, tiff, 2, rp, rp + rlen, wp, wp + wlen);
			break;
		case 3:
			error = xps_decode_tiff_fax(ctx, tiff, 3, rp, rp + rlen, wp, wp + wlen);
			break;
		case 4:
			error = xps_decode_tiff_fax(ctx, tiff, 4, rp, rp + rlen, wp, wp + wlen);
			break;
		case 5:
			error = xps_decode_tiff_lzw(ctx, tiff, rp, rp + rlen, wp, wp + wlen);
			break;
		case 6:
			error = fz_throw("deprecated JPEG in TIFF compression not supported");
			break;
		case 7:
			error = xps_decode_tiff_jpeg(ctx, tiff, rp, rp + rlen, wp, wp + wlen);
			break;
		case 8:
			error = xps_decode_tiff_flate(ctx, tiff, rp, rp + rlen, wp, wp + wlen);
			break;
		case 32773:
			error = xps_decode_tiff_packbits(ctx, tiff, rp, rp + rlen, wp, wp + wlen);
			break;
		default:
			error = fz_throw("unknown TIFF compression: %d", tiff->compression);
		}

		if (error)
			return fz_rethrow(error, "could not decode strip %d", row / tiff->rowsperstrip);

		/* scramble the bits back into original order */
		if (tiff->fillorder == 2)
			for (i = 0; i < rlen; i++)
				rp[i] = bitrev[rp[i]];

		wp += image->stride * tiff->rowsperstrip;
		strip ++;
	}

	/* Predictor (only for LZW and Flate) */
	if ((tiff->compression == 5 || tiff->compression == 8) && tiff->predictor == 2)
	{
		byte *p = image->samples;
		for (i = 0; i < image->height; i++)
		{
			xps_unpredict_tiff(p, image->width, tiff->samplesperpixel, image->bits);
			p += image->stride;
		}
	}

	/* RGBPal */
	if (tiff->photometric == 3 && tiff->colormap)
	{
		error = xps_expand_colormap(ctx, tiff, image);
		if (error)
			return fz_rethrow(error, "could not expand colormap");
	}

	/* WhiteIsZero .. invert */
	if (tiff->photometric == 0)
	{
		byte *p = image->samples;
		for (i = 0; i < image->height; i++)
		{
			xps_invert_tiff(p, image->width, image->comps, image->bits, tiff->extrasamples);
			p += image->stride;
		}
	}

	/* Premultiplied transparency */
	if (tiff->extrasamples == 1)
	{
		image->hasalpha = 1;
	}

	/* Non-pre-multiplied transparency */
	if (tiff->extrasamples == 2)
	{
		image->hasalpha = 1;
	}

	return gs_okay;
}

static void
xps_read_tiff_bytes(unsigned char *p, xps_tiff_t *tiff, unsigned ofs, unsigned n)
{
	tiff->rp = tiff->bp + ofs;
	if (tiff->rp > tiff->ep)
		tiff->rp = tiff->bp;

	while (n--)
	{
		*p++ = readbyte(tiff);
	}
}

static void
xps_read_tiff_tag_value(unsigned *p, xps_tiff_t *tiff, unsigned type, unsigned ofs, unsigned n)
{
	tiff->rp = tiff->bp + ofs;
	if (tiff->rp > tiff->ep)
		tiff->rp = tiff->bp;

	while (n--)
	{
		switch (type)
		{
		case TRATIONAL:
			*p = readlong(tiff);
			*p = *p / readlong(tiff);
			p ++;
			break;
		case TBYTE: *p++ = readbyte(tiff); break;
		case TSHORT: *p++ = readshort(tiff); break;
		case TLONG: *p++ = readlong(tiff); break;
		default: *p++ = 0; break;
		}
	}
}

static int
xps_read_tiff_tag(xps_context_t *ctx, xps_tiff_t *tiff, unsigned offset)
{
	unsigned tag;
	unsigned type;
	unsigned count;
	unsigned value;

	tiff->rp = tiff->bp + offset;

	tag = readshort(tiff);
	type = readshort(tiff);
	count = readlong(tiff);

	if ((type == TBYTE && count <= 4) ||
			(type == TSHORT && count <= 2) ||
			(type == TLONG && count <= 1))
		value = tiff->rp - tiff->bp;
	else
		value = readlong(tiff);

	switch (tag)
	{
	case NewSubfileType:
		xps_read_tiff_tag_value(&tiff->subfiletype, tiff, type, value, 1);
		break;
	case ImageWidth:
		xps_read_tiff_tag_value(&tiff->imagewidth, tiff, type, value, 1);
		break;
	case ImageLength:
		xps_read_tiff_tag_value(&tiff->imagelength, tiff, type, value, 1);
		break;
	case BitsPerSample:
		xps_read_tiff_tag_value(&tiff->bitspersample, tiff, type, value, 1);
		break;
	case Compression:
		xps_read_tiff_tag_value(&tiff->compression, tiff, type, value, 1);
		break;
	case PhotometricInterpretation:
		xps_read_tiff_tag_value(&tiff->photometric, tiff, type, value, 1);
		break;
	case FillOrder:
		xps_read_tiff_tag_value(&tiff->fillorder, tiff, type, value, 1);
		break;
	case SamplesPerPixel:
		xps_read_tiff_tag_value(&tiff->samplesperpixel, tiff, type, value, 1);
		break;
	case RowsPerStrip:
		xps_read_tiff_tag_value(&tiff->rowsperstrip, tiff, type, value, 1);
		break;
	case XResolution:
		xps_read_tiff_tag_value(&tiff->xresolution, tiff, type, value, 1);
		break;
	case YResolution:
		xps_read_tiff_tag_value(&tiff->yresolution, tiff, type, value, 1);
		break;
	case PlanarConfiguration:
		xps_read_tiff_tag_value(&tiff->planar, tiff, type, value, 1);
		break;
	case T4Options:
		xps_read_tiff_tag_value(&tiff->g3opts, tiff, type, value, 1);
		break;
	case T6Options:
		xps_read_tiff_tag_value(&tiff->g4opts, tiff, type, value, 1);
		break;
	case Predictor:
		xps_read_tiff_tag_value(&tiff->predictor, tiff, type, value, 1);
		break;
	case ResolutionUnit:
		xps_read_tiff_tag_value(&tiff->resolutionunit, tiff, type, value, 1);
		break;
	case YCbCrSubSampling:
		xps_read_tiff_tag_value(tiff->ycbcrsubsamp, tiff, type, value, 2);
		break;
	case ExtraSamples:
		xps_read_tiff_tag_value(&tiff->extrasamples, tiff, type, value, 1);
		break;
	case ICCProfile:
		tiff->profile = xps_alloc(ctx, count);
		if (!tiff->profile)
			return fz_throw("could not allocate embedded icc profile");
		/* ICC profile data type is set to UNDEFINED.
		 * TBYTE reading not correct in xps_read_tiff_tag_value */
		xps_read_tiff_bytes(tiff->profile, tiff, value, count);
		tiff->profilesize = count;
		break;

	case JPEGTables:
		tiff->jpegtables = tiff->bp + value;
		tiff->jpegtableslen = count;
		break;

	case StripOffsets:
		tiff->stripoffsets = (unsigned*) xps_alloc(ctx, count * sizeof(unsigned));
		if (!tiff->stripoffsets)
			return fz_throw("could not allocate strip offsets");
		xps_read_tiff_tag_value(tiff->stripoffsets, tiff, type, value, count);
		break;

	case StripByteCounts:
		tiff->stripbytecounts = (unsigned*) xps_alloc(ctx, count * sizeof(unsigned));
		if (!tiff->stripbytecounts)
			return fz_throw("could not allocate strip byte counts");
		xps_read_tiff_tag_value(tiff->stripbytecounts, tiff, type, value, count);
		break;

	case ColorMap:
		tiff->colormap = (unsigned*) xps_alloc(ctx, count * sizeof(unsigned));
		if (!tiff->colormap)
			return fz_throw("could not allocate color map");
		xps_read_tiff_tag_value(tiff->colormap, tiff, type, value, count);
		break;

	case TileWidth:
	case TileLength:
	case TileOffsets:
	case TileByteCounts:
		return fz_throw("tiled tiffs not supported");

	default:
		/* printf("unknown tag: %d t=%d n=%d\n", tag, type, count); */
		break;
	}

	return gs_okay;
}

static void
xps_swap_byte_order(byte *buf, int n)
{
	int i, t;
	for (i = 0; i < n; i++)
	{
		t = buf[i * 2 + 0];
		buf[i * 2 + 0] = buf[i * 2 + 1];
		buf[i * 2 + 1] = t;
	}
}

static int
xps_decode_tiff_header(xps_context_t *ctx, xps_tiff_t *tiff, byte *buf, int len)
{
	unsigned version;
	unsigned offset;
	unsigned count;
	unsigned i;
	int error;

	memset(tiff, 0, sizeof(xps_tiff_t));

	tiff->bp = buf;
	tiff->rp = buf;
	tiff->ep = buf + len;

	/* tag defaults, where applicable */
	tiff->bitspersample = 1;
	tiff->compression = 1;
	tiff->samplesperpixel = 1;
	tiff->resolutionunit = 2;
	tiff->rowsperstrip = 0xFFFFFFFF;
	tiff->fillorder = 1;
	tiff->planar = 1;
	tiff->subfiletype = 0;
	tiff->predictor = 1;
	tiff->ycbcrsubsamp[0] = 2;
	tiff->ycbcrsubsamp[1] = 2;

	/*
	 * Read IFH
	 */

	/* get byte order marker */
	tiff->order = TII;
	tiff->order = readshort(tiff);
	if (tiff->order != TII && tiff->order != TMM)
		return fz_throw("not a TIFF file, wrong magic marker");

	/* check version */
	version = readshort(tiff);
	if (version != 42)
		return fz_throw("not a TIFF file, wrong version marker");

	/* get offset of IFD */
	offset = readlong(tiff);

	/*
	 * Read IFD
	 */

	tiff->rp = tiff->bp + offset;

	count = readshort(tiff);

	offset += 2;
	for (i = 0; i < count; i++)
	{
		error = xps_read_tiff_tag(ctx, tiff, offset);
		if (error)
			return fz_rethrow(error, "could not read TIFF header tag");
		offset += 12;
	}

	return gs_okay;
}

int
xps_decode_tiff(xps_context_t *ctx, byte *buf, int len, xps_image_t *image)
{
	int error;
	xps_tiff_t tiffst;
	xps_tiff_t *tiff = &tiffst;

	error = xps_decode_tiff_header(ctx, tiff, buf, len);
	if (error)
		return fz_rethrow(error, "cannot decode tiff header");

	/*
	 * Decode the image strips
	 */

	if (tiff->rowsperstrip > tiff->imagelength)
		tiff->rowsperstrip = tiff->imagelength;

	error = xps_decode_tiff_strips(ctx, tiff, image);
	if (error)
		return fz_rethrow(error, "could not decode image data");

	/*
	 * Byte swap 16-bit images to big endian if necessary.
	 */
	if (image->bits == 16)
	{
		if (tiff->order == TII)
			xps_swap_byte_order(image->samples, image->width * image->height * image->comps);
	}

	/*
	 * Save ICC profile data
	 */
	image->profile = tiff->profile;
	image->profilesize = tiff->profilesize;

	/*
	 * Clean up scratch memory
	 */

	if (tiff->colormap) xps_free(ctx, tiff->colormap);
	if (tiff->stripoffsets) xps_free(ctx, tiff->stripoffsets);
	if (tiff->stripbytecounts) xps_free(ctx, tiff->stripbytecounts);

	return gs_okay;
}

int
xps_tiff_has_alpha(xps_context_t *ctx, byte *buf, int len)
{
	int error;
	xps_tiff_t tiffst;
	xps_tiff_t *tiff = &tiffst;

	error = xps_decode_tiff_header(ctx, tiff, buf, len);
	if (error)
	{
		gs_catch(error, "cannot decode tiff header");
		return 0;
	}

	if (tiff->profile) xps_free(ctx, tiff->profile);
	if (tiff->colormap) xps_free(ctx, tiff->colormap);
	if (tiff->stripoffsets) xps_free(ctx, tiff->stripoffsets);
	if (tiff->stripbytecounts) xps_free(ctx, tiff->stripbytecounts);

	return tiff->extrasamples == 2 || tiff->extrasamples == 1;
}
#endif