/* $Id: tiffcp.c,v 1.49 2010-12-23 13:38:47 dron Exp $ */

/*

 * Copyright (c) 1988-1997 Sam Leffler

 * Copyright (c) 1991-1997 Silicon Graphics, Inc.

 *

 *  Revised:  2/18/01 BAR -- added syntax for extracting single images from

 *                          multi-image TIFF files.

 *

 *    New syntax is:  sourceFileName,image#

 *

 * image# ranges from 0..<n-1> where n is the # of images in the file.</n-1>

 * There may be no white space between the comma and the filename or

 * image number.

 *

 *    Example:   tiffcp source.tif,1 destination.tif

 *

 * Copies the 2nd image in source.tif to the destination.

 *

 *****

 * 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></stdlib.h>

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

#include <ctype.h></ctype.h>

#include <assert.h></assert.h>

#ifdef HAVE_UNISTD_H

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

#endif

#include "tiffio.h"

#ifndef HAVE_GETOPT

extern int getopt(int, char**, char*);

#endif

#if defined(VMS)

# define unlink delete

#endif

#define	streq(a,b)	(strcmp(a,b) == 0)

#define	strneq(a,b,n)	(strncmp(a,b,n) == 0)

#define	TRUE	1

#define	FALSE	0

static int outtiled = -1;

static uint32 tilewidth;

static uint32 tilelength;

static uint16 config;

static uint16 compression;

static uint16 predictor;

static int preset;

static uint16 fillorder;

static uint16 orientation;

static uint32 rowsperstrip;

static uint32 g3opts;

static int ignore = FALSE;		/* if true, ignore read errors */

static uint32 defg3opts = (uint32) -1;

static int quality = 75;		/* JPEG quality */

static int jpegcolormode = JPEGCOLORMODE_RGB;

static uint16 defcompression = (uint16) -1;

static uint16 defpredictor = (uint16) -1;

static int defpreset =  -1;

static int tiffcp(TIFF*, TIFF*);

static int processCompressOptions(char*);

static void usage(void);

static char comma = ',';  /* (default) comma separator character */

static TIFF* bias = NULL;

static int pageNum = 0;

static int pageInSeq = 0;

static int nextSrcImage (TIFF *tif, char **imageSpec)

/*

  seek to the next image specified in *imageSpec

  returns 1 if success, 0 if no more images to process

  *imageSpec=NULL if subsequent images should be processed in sequence

*/

{

	if (**imageSpec == comma) {  /* if not @comma, we've done all images */

		char *start = *imageSpec + 1;

		tdir_t nextImage = (tdir_t)strtol(start, imageSpec, 0);

		if (start == *imageSpec) nextImage = TIFFCurrentDirectory (tif);

		if (**imageSpec)

		{

			if (**imageSpec == comma) {

				/* a trailing comma denotes remaining images in sequence */

				if ((*imageSpec)[1] == '\0') *imageSpec = NULL;

			}else{

				fprintf (stderr,

				    "Expected a %c separated image # list after %s\n",

				    comma, TIFFFileName (tif));

				exit (-4);   /* syntax error */

			}

		}

		if (TIFFSetDirectory (tif, nextImage)) return 1;

		fprintf (stderr, "%s%c%d not found!\n",

		    TIFFFileName(tif), comma, (int) nextImage);

	}

	return 0;

}

static TIFF* openSrcImage (char **imageSpec)

/*

  imageSpec points to a pointer to a filename followed by optional ,image#'s

  Open the TIFF file and assign *imageSpec to either NULL if there are

  no images specified, or a pointer to the next image number text

*/

{

	TIFF *tif;

	char *fn = *imageSpec;

	*imageSpec = strchr (fn, comma);

	if (*imageSpec) {  /* there is at least one image number specifier */

		**imageSpec = '\0';

		tif = TIFFOpen (fn, "r");

		/* but, ignore any single trailing comma */

		if (!(*imageSpec)[1]) {*imageSpec = NULL; return tif;}

		if (tif) {

			**imageSpec = comma;  /* replace the comma */

			if (!nextSrcImage(tif, imageSpec)) {

				TIFFClose (tif);

				tif = NULL;

			}

		}

	}else

		tif = TIFFOpen (fn, "r");

	return tif;

}

int

main(int argc, char* argv[])

{

	uint16 defconfig = (uint16) -1;

	uint16 deffillorder = 0;

	uint32 deftilewidth = (uint32) -1;

	uint32 deftilelength = (uint32) -1;

	uint32 defrowsperstrip = (uint32) 0;

	uint64 diroff = 0;

	TIFF* in;

	TIFF* out;

	char mode[10];

	char* mp = mode;

	int c;

	extern int optind;

	extern char* optarg;

	*mp++ = 'w';

	*mp = '\0';

	while ((c = getopt(argc, argv, ",:b:c:f:l:o:z:p:r:w:aistBLMC8x")) != -1)

		switch (c) {

		case ',':

			if (optarg[0] != '=') usage();

			comma = optarg[1];

			break;

		case 'b':   /* this file is bias image subtracted from others */

			if (bias) {

				fputs ("Only 1 bias image may be specified\n", stderr);

				exit (-2);

			}

			{

				uint16 samples = (uint16) -1;

				char **biasFn = &optarg;

				bias = openSrcImage (biasFn);

				if (!bias) exit (-5);

				if (TIFFIsTiled (bias)) {

					fputs ("Bias image must be organized in strips\n", stderr);

					exit (-7);

				}

				TIFFGetField(bias, TIFFTAG_SAMPLESPERPIXEL, &samples);

				if (samples != 1) {

					fputs ("Bias image must be monochrome\n", stderr);

					exit (-7);

				}

			}

			break;

		case 'a':   /* append to output */

			mode[0] = 'a';

			break;

		case 'c':   /* compression scheme */

			if (!processCompressOptions(optarg))

				usage();

			break;

		case 'f':   /* fill order */

			if (streq(optarg, "lsb2msb"))

				deffillorder = FILLORDER_LSB2MSB;

			else if (streq(optarg, "msb2lsb"))

				deffillorder = FILLORDER_MSB2LSB;

			else

				usage();

			break;

		case 'i':   /* ignore errors */

			ignore = TRUE;

			break;

		case 'l':   /* tile length */

			outtiled = TRUE;

			deftilelength = atoi(optarg);

			break;

		case 'o':   /* initial directory offset */

			diroff = strtoul(optarg, NULL, 0);

			break;

		case 'p':   /* planar configuration */

			if (streq(optarg, "separate"))

				defconfig = PLANARCONFIG_SEPARATE;

			else if (streq(optarg, "contig"))

				defconfig = PLANARCONFIG_CONTIG;

			else

				usage();

			break;

		case 'r':   /* rows/strip */

			defrowsperstrip = atol(optarg);

			break;

		case 's':   /* generate stripped output */

			outtiled = FALSE;

			break;

		case 't':   /* generate tiled output */

			outtiled = TRUE;

			break;

		case 'w':   /* tile width */

			outtiled = TRUE;

			deftilewidth = atoi(optarg);

			break;

		case 'B':

			*mp++ = 'b'; *mp = '\0';

			break;

		case 'L':

			*mp++ = 'l'; *mp = '\0';

			break;

		case 'M':

			*mp++ = 'm'; *mp = '\0';

			break;

		case 'C':

			*mp++ = 'c'; *mp = '\0';

			break;

		case '8':

			*mp++ = '8'; *mp = '\0';

			break;

		case 'x':

			pageInSeq = 1;

			break;

		case '?':

			usage();

			/*NOTREACHED*/

		}

	if (argc - optind < 2)

		usage();

	out = TIFFOpen(argv[argc-1], mode);

	if (out == NULL)

		return (-2);

	if ((argc - optind) == 2)

		pageNum = -1;

	for (; optind < argc-1 ; optind++) {

		char *imageCursor = argv[optind];

		in = openSrcImage (&imageCursor);

		if (in == NULL) {

			(void) TIFFClose(out);

			return (-3);

		}

		if (diroff != 0 && !TIFFSetSubDirectory(in, diroff)) {

			TIFFError(TIFFFileName(in),

			    "Error, setting subdirectory at " TIFF_UINT64_FORMAT, diroff);

			(void) TIFFClose(in);

			(void) TIFFClose(out);

			return (1);

		}

		for (;;) {

			config = defconfig;

			compression = defcompression;

			predictor = defpredictor;

                        preset = defpreset;

			fillorder = deffillorder;

			rowsperstrip = defrowsperstrip;

			tilewidth = deftilewidth;

			tilelength = deftilelength;

			g3opts = defg3opts;

			if (!tiffcp(in, out) || !TIFFWriteDirectory(out)) {

				(void) TIFFClose(in);

				(void) TIFFClose(out);

				return (1);

			}

			if (imageCursor) { /* seek next image directory */

				if (!nextSrcImage(in, &imageCursor)) break;

			}else

				if (!TIFFReadDirectory(in)) break;

		}

		(void) TIFFClose(in);

	}

	(void) TIFFClose(out);

	return (0);

}

static void

processZIPOptions(char* cp)

{

	if ( (cp = strchr(cp, ':')) ) {

		do {

			cp++;

			if (isdigit((int)*cp))

				defpredictor = atoi(cp);

			else if (*cp == 'p')

				defpreset = atoi(++cp);

			else

				usage();

		} while( (cp = strchr(cp, ':')) );

	}

}

static void

processG3Options(char* cp)

{

	if( (cp = strchr(cp, ':')) ) {

		if (defg3opts == (uint32) -1)

			defg3opts = 0;

		do {

			cp++;

			if (strneq(cp, "1d", 2))

				defg3opts &= ~GROUP3OPT_2DENCODING;

			else if (strneq(cp, "2d", 2))

				defg3opts |= GROUP3OPT_2DENCODING;

			else if (strneq(cp, "fill", 4))

				defg3opts |= GROUP3OPT_FILLBITS;

			else

				usage();

		} while( (cp = strchr(cp, ':')) );

	}

}

static int

processCompressOptions(char* opt)

{

	if (streq(opt, "none")) {

		defcompression = COMPRESSION_NONE;

	} else if (streq(opt, "packbits")) {

		defcompression = COMPRESSION_PACKBITS;

	} else if (strneq(opt, "jpeg", 4)) {

		char* cp = strchr(opt, ':');

		defcompression = COMPRESSION_JPEG;

		while( cp )

		{

			if (isdigit((int)cp[1]))

				quality = atoi(cp+1);

			else if (cp[1] == 'r' )

				jpegcolormode = JPEGCOLORMODE_RAW;

			else

				usage();

			cp = strchr(cp+1,':');

		}

	} else if (strneq(opt, "g3", 2)) {

		processG3Options(opt);

		defcompression = COMPRESSION_CCITTFAX3;

	} else if (streq(opt, "g4")) {

		defcompression = COMPRESSION_CCITTFAX4;

	} else if (strneq(opt, "lzw", 3)) {

		char* cp = strchr(opt, ':');

		if (cp)

			defpredictor = atoi(cp+1);

		defcompression = COMPRESSION_LZW;

	} else if (strneq(opt, "zip", 3)) {

		processZIPOptions(opt);

		defcompression = COMPRESSION_ADOBE_DEFLATE;

	} else if (strneq(opt, "lzma", 4)) {

		processZIPOptions(opt);

		defcompression = COMPRESSION_LZMA;

	} else if (strneq(opt, "jbig", 4)) {

		defcompression = COMPRESSION_JBIG;

	} else if (strneq(opt, "sgilog", 6)) {

		defcompression = COMPRESSION_SGILOG;

	} else

		return (0);

	return (1);

}

char* stuff[] = {

"usage: tiffcp [options] input... output",

"where options are:",

" -a              append to output instead of overwriting",

" -o offset       set initial directory offset",

" -p contig       pack samples contiguously (e.g. RGBRGB...)",

" -p separate     store samples separately (e.g. RRR...GGG...BBB...)",

" -s              write output in strips",

" -t              write output in tiles",

" -8              write BigTIFF instead of default ClassicTIFF",

" -i              ignore read errors",

" -b file[,#]     bias (dark) monochrome image to be subtracted from all others",

" -,=%            use % rather than , to separate image #'s (per Note below)",

"",

" -r #            make each strip have no more than # rows",

" -w #            set output tile width (pixels)",

" -l #            set output tile length (pixels)",

"",

" -f lsb2msb      force lsb-to-msb FillOrder for output",

" -f msb2lsb      force msb-to-lsb FillOrder for output",

"",

" -c lzw[:opts]   compress output with Lempel-Ziv & Welch encoding",

" -c zip[:opts]   compress output with deflate encoding",

" -c lzma[:opts]  compress output with LZMA2 encoding",

" -c jpeg[:opts]  compress output with JPEG encoding",

" -c jbig         compress output with ISO JBIG encoding",

" -c packbits     compress output with packbits encoding",

" -c g3[:opts]    compress output with CCITT Group 3 encoding",

" -c g4           compress output with CCITT Group 4 encoding",

" -c sgilog       compress output with SGILOG encoding",

" -c none         use no compression algorithm on output",

" -x              force the merged tiff pages in sequence",

"",

"Group 3 options:",

" 1d              use default CCITT Group 3 1D-encoding",

" 2d              use optional CCITT Group 3 2D-encoding",

" fill            byte-align EOL codes",

"For example, -c g3:2d:fill to get G3-2D-encoded data with byte-aligned EOLs",

"",

"JPEG options:",

" #               set compression quality level (0-100, default 75)",

" r               output color image as RGB rather than YCbCr",

"For example, -c jpeg:r:50 to get JPEG-encoded RGB data with 50% comp. quality",

"",

"LZW, Deflate (ZIP) and LZMA2 options:",

" #               set predictor value",

" p#              set compression level (preset)",

"For example, -c lzw:2 to get LZW-encoded data with horizontal differencing,",

"-c zip:3:p9 for Deflate encoding with maximum compression level and floating",

"point predictor.",

"",

"Note that input filenames may be of the form filename,x,y,z",

"where x, y, and z specify image numbers in the filename to copy.",

"example:  tiffcp -c none -b esp.tif,1 esp.tif,0 test.tif",

"  subtract 2nd image in esp.tif from 1st yielding uncompressed result test.tif",

NULL

};

static void

usage(void)

{

	char buf[BUFSIZ];

	int i;

	setbuf(stderr, buf);

	fprintf(stderr, "%s\n\n", TIFFGetVersion());

	for (i = 0; stuff[i] != NULL; i++)

		fprintf(stderr, "%s\n", stuff[i]);

	exit(-1);

}

#define	CopyField(tag, v) \

    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)

#define	CopyField2(tag, v1, v2) \

    if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)

#define	CopyField3(tag, v1, v2, v3) \

    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)

#define	CopyField4(tag, v1, v2, v3, v4) \

    if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)

static void

cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)

{

	switch (type) {

	case TIFF_SHORT:

		if (count == 1) {

			uint16 shortv;

			CopyField(tag, shortv);

		} else if (count == 2) {

			uint16 shortv1, shortv2;

			CopyField2(tag, shortv1, shortv2);

		} else if (count == 4) {

			uint16 *tr, *tg, *tb, *ta;

			CopyField4(tag, tr, tg, tb, ta);

		} else if (count == (uint16) -1) {

			uint16 shortv1;

			uint16* shortav;

			CopyField2(tag, shortv1, shortav);

		}

		break;

	case TIFF_LONG:

		{ uint32 longv;

		  CopyField(tag, longv);

		}

		break;

	case TIFF_RATIONAL:

		if (count == 1) {

			float floatv;

			CopyField(tag, floatv);

		} else if (count == (uint16) -1) {

			float* floatav;

			CopyField(tag, floatav);

		}

		break;

	case TIFF_ASCII:

		{ char* stringv;

		  CopyField(tag, stringv);

		}

		break;

	case TIFF_DOUBLE:

		if (count == 1) {

			double doublev;

			CopyField(tag, doublev);

		} else if (count == (uint16) -1) {

			double* doubleav;

			CopyField(tag, doubleav);

		}

		break;

	default:

		TIFFError(TIFFFileName(in),

		    "Data type %d is not supported, tag %d skipped.",

		    tag, type);

	}

}

static struct cpTag {

	uint16 tag;

	uint16 count;

	TIFFDataType type;

} tags[] = {

	{ TIFFTAG_SUBFILETYPE,		1, TIFF_LONG },

	{ TIFFTAG_THRESHHOLDING,	1, TIFF_SHORT },

	{ TIFFTAG_DOCUMENTNAME,		1, TIFF_ASCII },

	{ TIFFTAG_IMAGEDESCRIPTION,	1, TIFF_ASCII },

	{ TIFFTAG_MAKE,			1, TIFF_ASCII },

	{ TIFFTAG_MODEL,		1, TIFF_ASCII },

	{ TIFFTAG_MINSAMPLEVALUE,	1, TIFF_SHORT },

	{ TIFFTAG_MAXSAMPLEVALUE,	1, TIFF_SHORT },

	{ TIFFTAG_XRESOLUTION,		1, TIFF_RATIONAL },

	{ TIFFTAG_YRESOLUTION,		1, TIFF_RATIONAL },

	{ TIFFTAG_PAGENAME,		1, TIFF_ASCII },

	{ TIFFTAG_XPOSITION,		1, TIFF_RATIONAL },

	{ TIFFTAG_YPOSITION,		1, TIFF_RATIONAL },

	{ TIFFTAG_RESOLUTIONUNIT,	1, TIFF_SHORT },

	{ TIFFTAG_SOFTWARE,		1, TIFF_ASCII },

	{ TIFFTAG_DATETIME,		1, TIFF_ASCII },

	{ TIFFTAG_ARTIST,		1, TIFF_ASCII },

	{ TIFFTAG_HOSTCOMPUTER,		1, TIFF_ASCII },

	{ TIFFTAG_WHITEPOINT,		(uint16) -1, TIFF_RATIONAL },

	{ TIFFTAG_PRIMARYCHROMATICITIES,(uint16) -1,TIFF_RATIONAL },

	{ TIFFTAG_HALFTONEHINTS,	2, TIFF_SHORT },

	{ TIFFTAG_INKSET,		1, TIFF_SHORT },

	{ TIFFTAG_DOTRANGE,		2, TIFF_SHORT },

	{ TIFFTAG_TARGETPRINTER,	1, TIFF_ASCII },

	{ TIFFTAG_SAMPLEFORMAT,		1, TIFF_SHORT },

	{ TIFFTAG_YCBCRCOEFFICIENTS,	(uint16) -1,TIFF_RATIONAL },

	{ TIFFTAG_YCBCRSUBSAMPLING,	2, TIFF_SHORT },

	{ TIFFTAG_YCBCRPOSITIONING,	1, TIFF_SHORT },

	{ TIFFTAG_REFERENCEBLACKWHITE,	(uint16) -1,TIFF_RATIONAL },

	{ TIFFTAG_EXTRASAMPLES,		(uint16) -1, TIFF_SHORT },

	{ TIFFTAG_SMINSAMPLEVALUE,	1, TIFF_DOUBLE },

	{ TIFFTAG_SMAXSAMPLEVALUE,	1, TIFF_DOUBLE },

	{ TIFFTAG_STONITS,		1, TIFF_DOUBLE },

};

#define	NTAGS	(sizeof (tags) / sizeof (tags[0]))

#define	CopyTag(tag, count, type)	cpTag(in, out, tag, count, type)

typedef int (*copyFunc)

    (TIFF* in, TIFF* out, uint32 l, uint32 w, uint16 samplesperpixel);

static	copyFunc pickCopyFunc(TIFF*, TIFF*, uint16, uint16);

/* PODD */

static int

tiffcp(TIFF* in, TIFF* out)

{

	uint16 bitspersample, samplesperpixel;

	uint16 input_compression, input_photometric;

	copyFunc cf;

	uint32 width, length;

	struct cpTag* p;

	CopyField(TIFFTAG_IMAGEWIDTH, width);

	CopyField(TIFFTAG_IMAGELENGTH, length);

	CopyField(TIFFTAG_BITSPERSAMPLE, bitspersample);

	CopyField(TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);

	if (compression != (uint16)-1)

		TIFFSetField(out, TIFFTAG_COMPRESSION, compression);

	else

		CopyField(TIFFTAG_COMPRESSION, compression);

	TIFFGetFieldDefaulted(in, TIFFTAG_COMPRESSION, &input_compression);

	TIFFGetFieldDefaulted(in, TIFFTAG_PHOTOMETRIC, &input_photometric);

	if (input_compression == COMPRESSION_JPEG) {

		/* Force conversion to RGB */

		TIFFSetField(in, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);

	} else if (input_photometric == PHOTOMETRIC_YCBCR) {

		/* Otherwise, can't handle subsampled input */

		uint16 subsamplinghor,subsamplingver;

		TIFFGetFieldDefaulted(in, TIFFTAG_YCBCRSUBSAMPLING,

				      &subsamplinghor, &subsamplingver);

		if (subsamplinghor!=1 || subsamplingver!=1) {

			fprintf(stderr, "tiffcp: %s: Can't copy/convert subsampled image.\n",

				TIFFFileName(in));

			return FALSE;

		}

	}

	if (compression == COMPRESSION_JPEG) {

		if (input_photometric == PHOTOMETRIC_RGB &&

		    jpegcolormode == JPEGCOLORMODE_RGB)

		  TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);

		else

		  TIFFSetField(out, TIFFTAG_PHOTOMETRIC, input_photometric);

	}

	else if (compression == COMPRESSION_SGILOG

	    || compression == COMPRESSION_SGILOG24)

		TIFFSetField(out, TIFFTAG_PHOTOMETRIC,

		    samplesperpixel == 1 ?

		    PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV);

	else

		CopyTag(TIFFTAG_PHOTOMETRIC, 1, TIFF_SHORT);

	if (fillorder != 0)

		TIFFSetField(out, TIFFTAG_FILLORDER, fillorder);

	else

		CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT);

	/*

	 * Will copy `Orientation' tag from input image

	 */

	TIFFGetFieldDefaulted(in, TIFFTAG_ORIENTATION, &orientation);

	switch (orientation) {

		case ORIENTATION_BOTRIGHT:

		case ORIENTATION_RIGHTBOT:	/* XXX */

			TIFFWarning(TIFFFileName(in), "using bottom-left orientation");

			orientation = ORIENTATION_BOTLEFT;

		/* fall thru... */

		case ORIENTATION_LEFTBOT:	/* XXX */

		case ORIENTATION_BOTLEFT:

			break;

		case ORIENTATION_TOPRIGHT:

		case ORIENTATION_RIGHTTOP:	/* XXX */

		default:

			TIFFWarning(TIFFFileName(in), "using top-left orientation");

			orientation = ORIENTATION_TOPLEFT;

		/* fall thru... */

		case ORIENTATION_LEFTTOP:	/* XXX */

		case ORIENTATION_TOPLEFT:

			break;

	}

	TIFFSetField(out, TIFFTAG_ORIENTATION, orientation);

	/*

	 * Choose tiles/strip for the output image according to

	 * the command line arguments (-tiles, -strips) and the

	 * structure of the input image.

	 */

	if (outtiled == -1)

		outtiled = TIFFIsTiled(in);

	if (outtiled) {

		/*

		 * Setup output file's tile width&height.  If either

		 * is not specified, use either the value from the

		 * input image or, if nothing is defined, use the

		 * library default.

		 */

		if (tilewidth == (uint32) -1)

			TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth);

		if (tilelength == (uint32) -1)

			TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength);

		TIFFDefaultTileSize(out, &tilewidth, &tilelength);

		TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth);

		TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength);

	} else {

		/*

		 * RowsPerStrip is left unspecified: use either the

		 * value from the input image or, if nothing is defined,

		 * use the library default.

		 */

		if (rowsperstrip == (uint32) 0) {

			if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP,

			    &rowsperstrip)) {

				rowsperstrip =

				    TIFFDefaultStripSize(out, rowsperstrip);

			}

			if (rowsperstrip > length && rowsperstrip != (uint32)-1)

				rowsperstrip = length;

		}

		else if (rowsperstrip == (uint32) -1)

			rowsperstrip = length;

		TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);

	}

	if (config != (uint16) -1)

		TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);

	else

		CopyField(TIFFTAG_PLANARCONFIG, config);

	if (samplesperpixel <= 4)

		CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT);

	CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT);

/* SMinSampleValue & SMaxSampleValue */

	switch (compression) {

		case COMPRESSION_JPEG:

			TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);

			TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);

			break;

		case COMPRESSION_JBIG:

			CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);

			CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);

			CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);

			CopyTag(TIFFTAG_FAXDCS, 1, TIFF_ASCII);

			break;

		case COMPRESSION_LZW:

		case COMPRESSION_ADOBE_DEFLATE:

		case COMPRESSION_DEFLATE:

                case COMPRESSION_LZMA:

			if (predictor != (uint16)-1)

				TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);

			else

				CopyField(TIFFTAG_PREDICTOR, predictor);

			if (preset != -1) {

                                if (compression == COMPRESSION_ADOBE_DEFLATE

                                         || compression == COMPRESSION_DEFLATE)

                                        TIFFSetField(out, TIFFTAG_ZIPQUALITY, preset);

				else if (compression == COMPRESSION_LZMA)

					TIFFSetField(out, TIFFTAG_LZMAPRESET, preset);

                        }

			break;

		case COMPRESSION_CCITTFAX3:

		case COMPRESSION_CCITTFAX4:

			if (compression == COMPRESSION_CCITTFAX3) {

				if (g3opts != (uint32) -1)

					TIFFSetField(out, TIFFTAG_GROUP3OPTIONS,

					    g3opts);

				else

					CopyField(TIFFTAG_GROUP3OPTIONS, g3opts);

			} else

				CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG);

			CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG);

			CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG);

			CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG);

			CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);

			CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);

			CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);

			break;

	}

	{

		uint32 len32;

		void** data;

		if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data))

			TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data);

	}

	{

		uint16 ninks;

		const char* inknames;

		if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) {

			TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks);

			if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) {

				int inknameslen = strlen(inknames) + 1;

				const char* cp = inknames;

				while (ninks > 1) {

					cp = strchr(cp, '\0');

                                        cp++;

                                        inknameslen += (strlen(cp) + 1);

					ninks--;

				}

				TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames);

			}

		}

	}

	{

		unsigned short pg0, pg1;

		if (pageInSeq == 1) {

			if (pageNum < 0) /* only one input file */ {

				if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1))

					TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1);

			} else

				TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0);

		} else {

			if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) {

				if (pageNum < 0) /* only one input file */

					TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1);

				else

					TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0);

			}

		}

	}

	for (p = tags; p < &tags[NTAGS]; p++)

		CopyTag(p->tag, p->count, p->type);

	cf = pickCopyFunc(in, out, bitspersample, samplesperpixel);

	return (cf ? (*cf)(in, out, length, width, samplesperpixel) : FALSE);

}

/*

 * Copy Functions.

 */

#define	DECLAREcpFunc(x) \

static int x(TIFF* in, TIFF* out, \

    uint32 imagelength, uint32 imagewidth, tsample_t spp)

#define	DECLAREreadFunc(x) \

static int x(TIFF* in, \

    uint8* buf, uint32 imagelength, uint32 imagewidth, tsample_t spp)

typedef int (*readFunc)(TIFF*, uint8*, uint32, uint32, tsample_t);

#define	DECLAREwriteFunc(x) \

static int x(TIFF* out, \

    uint8* buf, uint32 imagelength, uint32 imagewidth, tsample_t spp)

typedef int (*writeFunc)(TIFF*, uint8*, uint32, uint32, tsample_t);

/*

 * Contig -> contig by scanline for rows/strip change.

 */

DECLAREcpFunc(cpContig2ContigByRow)

{

	tsize_t scanlinesize = TIFFScanlineSize(in);

	tdata_t buf;

	uint32 row;

	buf = _TIFFmalloc(scanlinesize);

	if (!buf)

		return 0;

	_TIFFmemset(buf, 0, scanlinesize);

	(void) imagewidth; (void) spp;

	for (row = 0; row < imagelength; row++) {

		if (TIFFReadScanline(in, buf, row, 0) < 0 && !ignore) {

			TIFFError(TIFFFileName(in),

				  "Error, can't read scanline %lu",

				  (unsigned long) row);

			goto bad;

		}

		if (TIFFWriteScanline(out, buf, row, 0) < 0) {

			TIFFError(TIFFFileName(out),

				  "Error, can't write scanline %lu",

				  (unsigned long) row);

			goto bad;

		}

	}

	_TIFFfree(buf);

	return 1;

bad:

	_TIFFfree(buf);

	return 0;

}

typedef void biasFn (void *image, void *bias, uint32 pixels);

#define subtract(bits) \

static void subtract##bits (void *i, void *b, uint32 pixels)\

{\

   uint##bits *image = i;\

   uint##bits *bias = b;\

   while (pixels--) {\

     *image = *image > *bias ? *image-*bias : 0;\

     image++, bias++; \

   } \

}

subtract(8)

subtract(16)

subtract(32)

static biasFn *lineSubtractFn (unsigned bits)

{

	switch (bits) {