/* $Id: tiff2ps.c,v 1.49 2011-05-31 17:10:18 bfriesen Exp $ */

/*

 * 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.

 */

#include "tif_config.h"

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

#include <stdlib.h>			/* for atof */</stdlib.h>

#include <math.h></math.h>

#include <time.h></time.h>

#include <string.h></string.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h></unistd.h>

#endif

#ifdef NEED_LIBPORT

# include "libport.h"

#endif

#include "tiffio.h"

/*

 * Revision history

 *

 * 2010-Sep-17

 *    Richard Nolde: Reinstate code from Feb 2009 that never got

 *    accepted into CVS with major modifications to handle -H and -W

 *    options. Replaced original PlaceImage function with several

 *    new functions that make support for multiple output pages

 *    from a single image easier to understand. Added additional

 *    warning messages for incompatible command line options.

 *    Add new command line options to specify PageOrientation

 *    Document Structuring Comment for landscape or portrait

 *    and code to determine the values from ouput width and height

 *    if not specified on the command line.

 *    Add new command line option to specify document creator

 *    as an alterntive to the string "tiff2ps" following model

 *    of patch submitted by Thomas Jarosch for specifiying a

 *    document title which is also supported now.

 *

 * 2009-Feb-11

 *    Richard Nolde: Added support for rotations of 90, 180, 270

 *    and auto using -r <90|180|270|auto>.  Auto picks the best

 *    fit for the image on the specified paper size (eg portrait

 *    or landscape) if -h or -w is specified. Rotation is in

 *    degrees counterclockwise since that is how Postscript does

 *    it. The auto opption rotates the image 90 degrees ccw to

 *    produce landscape if that is a better fit than portait.

 *

 *    Cleaned up code in TIFF2PS and broke into smaller functions

 *    to simplify rotations.

 *

 *    Identified incompatible options and returned errors, eg

 *    -i for imagemask operator is only available for Level2 or

 *    Level3 Postscript in the current implmentation since there

 *    is a difference in the way the operands are called for Level1

 *    and there is no function to provide the Level1 version.

 *    -H was not handled properly if -h and/or -w were specified.

 *    It should only clip the masked images if the scaled image

 *    exceeds the maxPageHeight specified with -H.

 *  

 *    New design allows for all of the following combinations:

 *    Conversion of TIFF to Postscript with optional rotations

 *    of 90, 180, 270, or auto degrees counterclockwise

 *    Conversion of TIFF to Postscript with entire image scaled

 *    to maximum of values spedified with -h or -w while

 *    maintaining aspect ratio. Same rotations apply.

 *    Conversion of TIFF to Postscript with clipping of output

 *    viewport to height specified with -H, producing multiple

 *    pages at this height and original width as needed.

 *    Same rotations apply.

 *    Conversion of TIFF to Postscript with image scaled to 

 *    maximum specified by -h and -w and the resulting scaled

 *    image is presented in an output viewport clipped by -H height.

 *    The same rotations apply.

 *

 *    Added maxPageWidth option using -W flag. MaxPageHeight and

 *    MaxPageWidth are mutually exclusive since the aspect ratio

 *    cannot be maintained if you set both.

 *    Rewrote PlaceImage to allow maxPageHeight and maxPageWidth

 *    options to work with values smaller or larger than the

 *    physical paper size and still preserve the aspect ratio.

 *    This is accomplished by creating multiple pages across

 *    as well as down if need be.

 *

 * 2001-Mar-21

 *    I (Bruce A. Mallett) added this revision history comment ;)

 *

 *    Fixed PS_Lvl2page() code which outputs non-ASCII85 raw

 *    data.  Moved test for when to output a line break to

 *    *after* the output of a character.  This just serves

 *    to fix an eye-nuisance where the first line of raw

 *    data was one character shorter than subsequent lines.

 *

 *    Added an experimental ASCII85 encoder which can be used

 *    only when there is a single buffer of bytes to be encoded.

 *    This version is much faster at encoding a straight-line

 *    buffer of data because it can avoid a lot of the loop

 *    overhead of the byte-by-byte version.  To use this version

 *    you need to define EXP_ASCII85ENCODER (experimental ...).

 *

 *    Added bug fix given by Michael Schmidt to PS_Lvl2page()

 *    in which an end-of-data marker ('>') was not being output

 *    when producing non-ASCII85 encoded PostScript Level 2

 *    data.

 *

 *    Fixed PS_Lvl2colorspace() so that it no longer assumes that

 *    a TIFF having more than 2 planes is a CMYK.  This routine

 *    no longer looks at the samples per pixel but instead looks

 *    at the "photometric" value.  This change allows support of

 *    CMYK TIFFs.

 *

 *    Modified the PostScript L2 imaging loop so as to test if

 *    the input stream is still open before attempting to do a

 *    flushfile on it.  This was done because some RIPs close

 *    the stream after doing the image operation.

 *

 *    Got rid of the realloc() being done inside a loop in the

 *    PSRawDataBW() routine.  The code now walks through the

 *    byte-size array outside the loop to determine the largest

 *    size memory block that will be needed.

 *

 *    Added "-m" switch to ask tiff2ps to, where possible, use the

 *    "imagemask" operator instead of the "image" operator.

 *

 *    Added the "-i #" switch to allow interpolation to be disabled.

 *

 *    Unrolled a loop or two to improve performance.

 */

/*

 * Define EXP_ASCII85ENCODER if you want to use an experimental

 * version of the ASCII85 encoding routine.  The advantage of

 * using this routine is that tiff2ps will convert to ASCII85

 * encoding at between 3 and 4 times the speed as compared to

 * using the old (non-experimental) encoder.  The disadvantage

 * is that you will be using a new (and unproven) encoding

 * routine.  So user beware, you have been warned!

 */

#define	EXP_ASCII85ENCODER

/*

 * NB: this code assumes uint32 works with printf's %l[ud].

 */

#ifndef TRUE

#define	TRUE	1

#define	FALSE	0

#endif

int	ascii85 = FALSE;		/* use ASCII85 encoding */

int	interpolate = TRUE;		/* interpolate level2 image */

int	level2 = FALSE;			/* generate PostScript level 2 */

int	level3 = FALSE;			/* generate PostScript level 3 */

int	printAll = FALSE;		/* print all images in file */

int	generateEPSF = TRUE;		/* generate Encapsulated PostScript */

int	PSduplex = FALSE;		/* enable duplex printing */

int	PStumble = FALSE;		/* enable top edge binding */

int	PSavoiddeadzone = TRUE;		/* enable avoiding printer deadzone */

double	maxPageHeight = 0;		/* maximum height to select from image and print per page */

double	maxPageWidth  = 0;		/* maximum width  to select from image and print per page */

double	splitOverlap = 0;		/* amount for split pages to overlag */

int	rotation = 0;                   /* optional value for rotation angle */

int     auto_rotate = 0;                /* rotate image for best fit on the page */

char	*filename = NULL;		/* input filename */

char    *title = NULL;                  /* optional document title string */

char    *creator = NULL;                /* optional document creator string */

char    pageOrientation[12];            /* set optional PageOrientation DSC to Landscape or Portrait */

int	useImagemask = FALSE;		/* Use imagemask instead of image operator */

uint16	res_unit = 0;			/* Resolution units: 2 - inches, 3 - cm */

/*

 * ASCII85 Encoding Support.

 */

unsigned char ascii85buf[10];

int	ascii85count;

int	ascii85breaklen;

int	TIFF2PS(FILE*, TIFF*, double, double, double, double, int);

void	PSpage(FILE*, TIFF*, uint32, uint32);

void	PSColorContigPreamble(FILE*, uint32, uint32, int);

void	PSColorSeparatePreamble(FILE*, uint32, uint32, int);

void	PSDataColorContig(FILE*, TIFF*, uint32, uint32, int);

void	PSDataColorSeparate(FILE*, TIFF*, uint32, uint32, int);

void	PSDataPalette(FILE*, TIFF*, uint32, uint32);

void	PSDataBW(FILE*, TIFF*, uint32, uint32);

void	PSRawDataBW(FILE*, TIFF*, uint32, uint32);

void	Ascii85Init(void);

void	Ascii85Put(unsigned char code, FILE* fd);

void	Ascii85Flush(FILE* fd);

void    PSHead(FILE*, double, double, double, double);

void	PSTail(FILE*, int);

int     psStart(FILE *, int, int, int *, double *, double, double, double,

                double, double, double, double, double, double, double);

int     psPageSize(FILE *, int, double, double, double, double, double, double);

int     psRotateImage(FILE *, int, double, double, double, double);

int     psMaskImage(FILE *, TIFF *, int, int, int *, double, double,

		    double, double, double, double, double, double, double);

int     psScaleImage(FILE *, double, int, int, double, double, double, double,

                     double, double);

int     get_viewport (double, double, double, double, double *, double *, int);

int     exportMaskedImage(FILE *, double, double, double, double, int, int,

			  double, double, double, int, int);

#if	defined( EXP_ASCII85ENCODER)

tsize_t Ascii85EncodeBlock( uint8 * ascii85_p, unsigned f_eod, const uint8 * raw_p, tsize_t raw_l );

#endif

static	void usage(int);

int

main(int argc, char* argv[])

{

	int dirnum = -1, c, np = 0;

	int centered = 0;

	double bottommargin = 0;

	double leftmargin = 0;

	double pageWidth = 0;

	double pageHeight = 0;

	uint32 diroff = 0;

	extern char *optarg;

	extern int optind;

	FILE* output = stdout;

        pageOrientation[0] = '\0';

	while ((c = getopt(argc, argv, "b:d:h:H:W:L:i:w:l:o:O:P:C:r:t:acemxyzps1238DT")) != -1)

		switch (c) {

		case 'b':

			bottommargin = atof(optarg);

			break;

		case 'c':

			centered = 1;

			break;

                case 'C':

                        creator = optarg;

                        break;

		case 'd': /* without -a, this only processes one image at this IFD */

			dirnum = atoi(optarg);

			break;

		case 'D':

			PSduplex = TRUE;

			break;

		case 'i':

			interpolate = atoi(optarg) ? TRUE:FALSE;

			break;

		case 'T':

			PStumble = TRUE;

			break;

		case 'e':

                        PSavoiddeadzone = FALSE;

			generateEPSF = TRUE;

			break;

		case 'h':

			pageHeight = atof(optarg);

			break;

		case 'H':

			maxPageHeight = atof(optarg);

			break;

		case 'W':

			maxPageWidth = atof(optarg);

			break;

		case 'L':

			splitOverlap = atof(optarg);

			break;

		case 'm':

			useImagemask = TRUE;

			break;

		case 'o':

		        switch (optarg[0])

                          {

                          case '0':

                          case '1':

                          case '2':

                          case '3':

                          case '4':

                          case '5':

                          case '6':

                          case '7':

                          case '8':

                          case '9': diroff = (uint32) strtoul(optarg, NULL, 0);

			          break;

                          default: TIFFError ("-o", "Offset must be a numeric value.");

			    exit (1);

			  }

			break;

		case 'O':		/* XXX too bad -o is already taken */

			output = fopen(optarg, "w");

			if (output == NULL) {

				fprintf(stderr,

				    "%s: %s: Cannot open output file.\n",

				    argv[0], optarg);

				exit(-2);

			}

			break;

		case 'P':

                        switch (optarg[0])

                          {

                          case 'l':

                          case 'L': strcpy (pageOrientation, "Landscape");

			            break; 

                          case 'p':

                          case 'P': strcpy (pageOrientation, "Portrait");

			            break; 

                          default: TIFFError ("-P", "Page orientation must be Landscape or Portrait");

			           exit (-1);

			  }

			break;

		case 'l':

			leftmargin = atof(optarg);

			break;

		case 'a': /* removed fall through to generate warning below, R Nolde 09-01-2010 */

			printAll = TRUE;

			break;

		case 'p':

			generateEPSF = FALSE;

			break;

		case 'r':

                        if (strcmp (optarg, "auto") == 0)

			  {

                          rotation = 0;

                          auto_rotate = TRUE;

                          }

                        else

			  {

 			  rotation = atoi(optarg);

                          auto_rotate = FALSE;

			  }

                        switch (rotation)

                          {

			  case   0:

                          case  90:

                          case 180:

                          case 270:

			    break;

			  default:

                            fprintf (stderr, "Rotation angle must be 90, 180, 270 (degrees ccw) or auto\n");

			    exit (-1);

			  }

			break;

		case 's':

			printAll = FALSE;

			break;

                case 't':

                        title = optarg;

                        break;

		case 'w':

			pageWidth = atof(optarg);

			break;

		case 'z':

			PSavoiddeadzone = FALSE;

			break;

		case '1':

			level2 = FALSE;

			level3 = FALSE;

			ascii85 = FALSE;

			break;

		case '2':

			level2 = TRUE;

			ascii85 = TRUE;			/* default to yes */

			break;

		case '3':

			level3 = TRUE;

			ascii85 = TRUE;			/* default to yes */

			break;

		case '8':

			ascii85 = FALSE;

			break;

		case 'x':

			res_unit = RESUNIT_CENTIMETER;

			break;

		case 'y':

			res_unit = RESUNIT_INCH;

			break;

		case '?':

			usage(-1);

		}

        if (useImagemask == TRUE)

          {

	  if ((level2 == FALSE) && (level3 == FALSE))

            {

	    TIFFError ("-m "," imagemask operator requres Postscript Level2 or Level3");

	    exit (1);

            }

          }

        if (pageWidth && (maxPageWidth > pageWidth))

	  {

	  TIFFError ("-W", "Max viewport width cannot exceed page width");

	  exit (1);

          }

	if (pageHeight && (maxPageHeight > pageHeight))

	  {

	  TIFFError ("-H", "Max viewport height cannot exceed page height");

	  exit (1);

          }

        /* auto rotate requires a specified page width and height */

        if (auto_rotate == TRUE)

          {

	  if ((pageWidth == 0) || (pageHeight == 0))

	    TIFFWarning ("-r auto", " requires page height and width specified with -h and -w");

          if ((maxPageWidth > 0) || (maxPageHeight > 0))

            {

	    TIFFError ("-r auto", " is incompatible with maximum page width/height specified by -H or -W");

            exit (1);

            }

          }

        if ((maxPageWidth > 0) && (maxPageHeight > 0))

            {

	    TIFFError ("-H and -W", " Use only one of -H or -W to define a viewport");

            exit (1);

            }

        if ((generateEPSF == TRUE) && (printAll == TRUE))

          {

	  TIFFError(" -e and -a", "Warning: Cannot generate Encapsulated Postscript for multiple images");

	  generateEPSF = FALSE;

          }

        if ((generateEPSF == TRUE) && (PSduplex == TRUE))

          {

	  TIFFError(" -e and -D", "Warning: Encapsulated Postscript does not support Duplex option");

	  PSduplex = FALSE;

          }

        if ((generateEPSF == TRUE) && (PStumble == TRUE))

          {

	  TIFFError(" -e and -T", "Warning: Encapsulated Postscript does not support Top Edge Binding option");

	  PStumble = FALSE;

          }

        if ((generateEPSF == TRUE) && (PSavoiddeadzone == TRUE))

	  PSavoiddeadzone = FALSE;

	for (; argc - optind > 0; optind++) {

		TIFF* tif = TIFFOpen(filename = argv[optind], "r");

		if (tif != NULL) {

			if (dirnum != -1

                            && !TIFFSetDirectory(tif, (tdir_t)dirnum))

				return (-1);

			else if (diroff != 0 &&

			    !TIFFSetSubDirectory(tif, diroff))

				return (-1);

			np = TIFF2PS(output, tif, pageWidth, pageHeight,

				     leftmargin, bottommargin, centered);

                        if (np < 0)

                          {

			  TIFFError("Error", "Unable to process %s", filename);

                          }

			TIFFClose(tif);

		}

	}

	if (np)

		PSTail(output, np);

	else

		usage(-1);

	if (output != stdout)

		fclose(output);

	return (0);

}

static	uint16 samplesperpixel;

static	uint16 bitspersample;

static	uint16 planarconfiguration;

static	uint16 photometric;

static	uint16 compression;

static	uint16 extrasamples;

static	int alpha;

static int

checkImage(TIFF* tif)

{

	switch (photometric) {

	case PHOTOMETRIC_YCBCR:

		if ((compression == COMPRESSION_JPEG || compression == COMPRESSION_OJPEG)

			&& planarconfiguration == PLANARCONFIG_CONTIG) {

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

			TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE,

				     JPEGCOLORMODE_RGB);

			photometric = PHOTOMETRIC_RGB;

		} else {

			if (level2 || level3)

				break;

			TIFFError(filename, "Can not handle image with %s",

			    "PhotometricInterpretation=YCbCr");

			return (0);

		}

		/* fall thru... */

	case PHOTOMETRIC_RGB:

		if (alpha && bitspersample != 8) {

			TIFFError(filename,

			    "Can not handle %d-bit/sample RGB image with alpha",

			    bitspersample);

			return (0);

		}

		/* fall thru... */

	case PHOTOMETRIC_SEPARATED:

	case PHOTOMETRIC_PALETTE:

	case PHOTOMETRIC_MINISBLACK:

	case PHOTOMETRIC_MINISWHITE:

		break;

	case PHOTOMETRIC_LOGL:

	case PHOTOMETRIC_LOGLUV:

		if (compression != COMPRESSION_SGILOG &&

		    compression != COMPRESSION_SGILOG24) {

			TIFFError(filename,

		    "Can not handle %s data with compression other than SGILog",

			    (photometric == PHOTOMETRIC_LOGL) ?

				"LogL" : "LogLuv"

			);

			return (0);

		}

		/* rely on library to convert to RGB/greyscale */

		TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);

		photometric = (photometric == PHOTOMETRIC_LOGL) ?

		    PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB;

		bitspersample = 8;

		break;

	case PHOTOMETRIC_CIELAB:

		/* fall thru... */

	default:

		TIFFError(filename,

		    "Can not handle image with PhotometricInterpretation=%d",

		    photometric);

		return (0);

	}

	switch (bitspersample) {

	case 1: case 2:

	case 4: case 8:

	case 16:

		break;

	default:

		TIFFError(filename, "Can not handle %d-bit/sample image",

		    bitspersample);

		return (0);

	}

	if (planarconfiguration == PLANARCONFIG_SEPARATE && extrasamples > 0)

		TIFFWarning(filename, "Ignoring extra samples");

	return (1);

}

#define PS_UNIT_SIZE	72.0F

#define	PSUNITS(npix,res)	((npix) * (PS_UNIT_SIZE / (res)))

static	char RGBcolorimage[] = "\

/bwproc {\n\

    rgbproc\n\

    dup length 3 idiv string 0 3 0\n\

    5 -1 roll {\n\

	add 2 1 roll 1 sub dup 0 eq {\n\

	    pop 3 idiv\n\

	    3 -1 roll\n\

	    dup 4 -1 roll\n\

	    dup 3 1 roll\n\

	    5 -1 roll put\n\

	    1 add 3 0\n\

	} { 2 1 roll } ifelse\n\

    } forall\n\

    pop pop pop\n\

} def\n\

/colorimage where {pop} {\n\

    /colorimage {pop pop /rgbproc exch def {bwproc} image} bind def\n\

} ifelse\n\

";

/*

 * Adobe Photoshop requires a comment line of the form:

 *

 * %ImageData: <cols> <rows> <depth>  <main channels=""> <pad channels=""></pad></main></depth></rows></cols>

 *	<block size=""> <1 for binary|2 for hex> "data start"</block>

 *

 * It is claimed to be part of some future revision of the EPS spec.

 */

static void

PhotoshopBanner(FILE* fd, uint32 w, uint32 h, int bs, int nc, char* startline)

{

	fprintf(fd, "%%ImageData: %ld %ld %d %d 0 %d 2 \"",

	    (long) w, (long) h, bitspersample, nc, bs);

	fprintf(fd, startline, nc);

	fprintf(fd, "\"\n");

}

/*   Convert pixel width and height pw, ph, to points pprw, pprh 

 *   using image resolution and resolution units from TIFF tags.

 *   pw : image width in pixels

 *   ph : image height in pixels

 * pprw : image width in PS units (72 dpi)

 * pprh : image height in PS units (72 dpi)

 */

static void

setupPageState(TIFF* tif, uint32* pw, uint32* ph, double* pprw, double* pprh)

{

	float xres = 0.0F, yres = 0.0F;

	TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, pw);

	TIFFGetField(tif, TIFFTAG_IMAGELENGTH, ph);

	if (res_unit == 0)	/* Not specified as command line option */

		if (!TIFFGetFieldDefaulted(tif, TIFFTAG_RESOLUTIONUNIT, &res_unit))

			res_unit = RESUNIT_INCH;

	/*

	 * Calculate printable area.

	 */

	if (!TIFFGetField(tif, TIFFTAG_XRESOLUTION, &xres)

            || fabs(xres) < 0.0000001)

		xres = PS_UNIT_SIZE;

	if (!TIFFGetField(tif, TIFFTAG_YRESOLUTION, &yres)

            || fabs(yres) < 0.0000001)

		yres = PS_UNIT_SIZE;

	switch (res_unit) {

	case RESUNIT_CENTIMETER:

		xres *= 2.54F, yres *= 2.54F;

		break;

	case RESUNIT_INCH:

		break;

	case RESUNIT_NONE:	/* Subsequent code assumes we have converted to inches! */

		res_unit = RESUNIT_INCH;

		break;

	default:	/* Last ditch guess for unspecified RESUNIT case

			 * check that the resolution is not inches before scaling it.

			 * Moved to end of function with additional check, RJN, 08-31-2010

			 * if (xres != PS_UNIT_SIZE || yres != PS_UNIT_SIZE)

			 * xres *= PS_UNIT_SIZE, yres *= PS_UNIT_SIZE;

			 */

		break;

	}

	/* This is a hack to deal with images that have no meaningful Resolution Size

	 * but may have x and/or y resolutions of 1 pixel per undefined unit.

	 */

	if ((xres > 1.0) && (xres != PS_UNIT_SIZE))

		*pprw = PSUNITS(*pw, xres);

	else

		*pprw = PSUNITS(*pw, PS_UNIT_SIZE);

	if ((yres > 1.0) && (yres != PS_UNIT_SIZE))

		*pprh = PSUNITS(*ph, yres);

	else

		*pprh = PSUNITS(*ph, PS_UNIT_SIZE);

}

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);

}

static	tsize_t tf_bytesperrow;

static	tsize_t ps_bytesperrow;

static	tsize_t	tf_rowsperstrip;

static	tsize_t	tf_numberstrips;

static	char *hex = "0123456789abcdef";

/*

 * Pagewidth and pageheight are the output size in points,

 * may refer to values specified with -h and -w, or to

 * values read from the image if neither -h nor -w are used.

 * Imagewidth and imageheight are image size in points.

 * Ximages and Yimages are number of pages across and down.

 * Only one of maxPageHeight or maxPageWidth can be used.

 * These are global variables unfortunately.

 */

int get_subimage_count(double pagewidth,  double pageheight,

		       double imagewidth, double imageheight,

		       int *ximages, int *yimages,

		       int rotation, double scale)

{

	int pages = 1;

	double splitheight = 0;  /* Requested Max Height in points */

	double splitwidth  = 0;  /* Requested Max Width in points */

	double overlap     = 0;  /* Repeated edge width in points */

	splitheight = maxPageHeight * PS_UNIT_SIZE;

	splitwidth  = maxPageWidth  * PS_UNIT_SIZE;

	overlap     = splitOverlap  * PS_UNIT_SIZE;

	pagewidth  *= PS_UNIT_SIZE;

	pageheight *= PS_UNIT_SIZE;

	if ((imagewidth < 1.0) || (imageheight < 1.0))

	{

		TIFFError("get_subimage_count", "Invalid image width or height");

		return (0);

	}

  switch (rotation)

    {

    case 0:

    case 180: if (splitheight > 0) /* -H maxPageHeight */

                {

               if (imageheight > splitheight) /* More than one vertical image segment */

                 {

                 if (pagewidth)

                   *ximages = (int)ceil((scale * imagewidth)  / (pagewidth - overlap));

                  else

                   *ximages = 1;

                 *yimages = (int)ceil((scale * imageheight) / (splitheight - overlap)); /* Max vert pages needed */

                 }

                else

                 {

                 if (pagewidth)

                   *ximages = (int)ceil((scale * imagewidth) / (pagewidth - overlap));    /* Max horz pages needed */

                  else

                   *ximages = 1;

                 *yimages = 1;                                                     /* Max vert pages needed */

                 }

               }

              else

               {

                if (splitwidth > 0) /* -W maxPageWidth */

                 {

                 if (imagewidth >splitwidth)

                   {

                   *ximages = (int)ceil((scale * imagewidth)  / (splitwidth - overlap));   /* Max horz pages needed */

                    if (pageheight)

                     *yimages = (int)ceil((scale * imageheight) / (pageheight - overlap)); /* Max vert pages needed */

                    else

                     *yimages = 1;

                   }

                  else

                   {

                   *ximages = 1;                                                     /* Max vert pages needed */

                    if (pageheight)

                     *yimages = (int)ceil((scale * imageheight) / (pageheight - overlap)); /* Max vert pages needed */

                    else

                     *yimages = 1;

                   }

                 }

                else

                 {

                 *ximages = 1;

                 *yimages = 1;

                 }

               }

             break;

    case 90:

    case 270: if (splitheight > 0) /* -H maxPageHeight */

                {

               if (imagewidth > splitheight) /* More than one vertical image segment */

                 {

                 *yimages = (int)ceil((scale * imagewidth) / (splitheight - overlap)); /* Max vert pages needed */

                  if (pagewidth)

                   *ximages = (int)ceil((scale * imageheight) / (pagewidth - overlap));   /* Max horz pages needed */

                  else

                   *ximages = 1;

                 }

                else

                 {

                 *yimages = 1;                                                     /* Max vert pages needed */

                  if (pagewidth)

                   *ximages = (int)ceil((scale * imageheight) / (pagewidth - overlap));    /* Max horz pages needed */

                  else

                   *ximages = 1;

                 }

               }

              else

               {

                if (splitwidth > 0) /* -W maxPageWidth */

                 {

                 if (imageheight > splitwidth)

                   {

                   if (pageheight)

                     *yimages = (int)ceil((scale * imagewidth) / (pageheight - overlap)); /* Max vert pages needed */

                    else

                     *yimages = 1;

                   *ximages = (int)ceil((scale * imageheight)  / (splitwidth - overlap));   /* Max horz pages needed */

                   }

                  else

                   {

                   if (pageheight)

                     *yimages = (int)ceil((scale * imagewidth) / (pageheight - overlap));  /* Max horz pages needed */

                    else

                     *yimages = 1;

                   *ximages = 1;                                                     /* Max vert pages needed */

                   }

                 }

                else

                 {

                 *ximages = 1;

                 *yimages = 1;

                 }

               }

             break;

    default:  *ximages = 1;

             *yimages = 1;

  }

  pages = (*ximages) * (*yimages);

  return (pages);

  }

/* New version of PlaceImage that handles only the translation and rotation

 * for a single output page.

 */

int exportMaskedImage(FILE *fp, double pagewidth, double pageheight,

                     double imagewidth, double imageheight,

                      int row, int column,

                      double left_offset, double bott_offset,

                     double scale, int center, int rotation)

  {

  double xtran = 0.0;

  double ytran = 0.0;

  double xscale = 1.0;

  double yscale = 1.0;

  double splitheight    = 0;  /* Requested Max Height in points */

  double splitwidth     = 0;  /* Requested Max Width in points */

  double overlap        = 0;  /* Repeated edge width in points */

  double subimage_height = 0.0;

  splitheight = maxPageHeight * PS_UNIT_SIZE;

  splitwidth  = maxPageWidth  * PS_UNIT_SIZE;

  overlap     = splitOverlap  * PS_UNIT_SIZE;

  xscale = scale * imagewidth;

  yscale = scale * imageheight;

  if ((xscale < 0.0) || (yscale < 0.0))

    {

    TIFFError("exportMaskedImage", "Invalid parameters.");

    return (-1);

    }

  /* If images are cropped to a vewport with -H or -W, the output pages are shifted to

   * the top of each output page rather than the Postscript default lower edge.

   */

  switch (rotation)

    {

    case 0:

    case 180: if (splitheight > 0) /* -H maxPageHeight */

                {

               if (splitheight < imageheight) /* More than one vertical image segments */

                 {

                 xtran = -1.0 * column * (pagewidth - overlap);

                  subimage_height = imageheight - ((splitheight - overlap) * row);

                 ytran  = pageheight - subimage_height * (pageheight / splitheight);

                  }

                else  /* Only one page in vertical direction */

                 {

                 xtran = -1.0 * column * (pagewidth - overlap);

                  ytran = splitheight - imageheight;

                 }

               }

              else

               {

                if (splitwidth > 0) /* maxPageWidth */

                 {

                 if (splitwidth < imagewidth)

                   {

                   xtran = -1.0  * column * splitwidth;

                   ytran = -1.0 * row * (pageheight - overlap);