Initial import of argyll version 1.5.1-8debian/1.5.1-8

1 files changed, 465 insertions, 0 deletions

diff --git a/tiff/tools/fax2tiff.c b/tiff/tools/fax2tiff.c
new file mode 100644
index 0000000..951b568
--- /dev/null
+++ b/tiff/tools/fax2tiff.c
@@ -0,0 +1,465 @@
+/* $Id: fax2tiff.c,v 1.19.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
+
+/*
+ * Copyright (c) 1990-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.
+ */
+
+/* 
+ * Convert a CCITT Group 3 or 4 FAX file to TIFF Group 3 or 4 format.
+ */
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>		/* should have atof & getopt */
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#ifdef HAVE_IO_H
+# include <io.h>
+#endif
+
+#include "tiffiop.h"
+
+#ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS	0
+#endif
+#ifndef EXIT_FAILURE
+# define EXIT_FAILURE	1
+#endif
+
+#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
+
+TIFF	*faxTIFF;
+char	*rowbuf;
+char	*refbuf;
+
+uint32	xsize = 1728;
+int	verbose;
+int	stretch;
+uint16	badfaxrun;
+uint32	badfaxlines;
+
+int	copyFaxFile(TIFF* tifin, TIFF* tifout);
+static	void usage(void);
+
+int
+main(int argc, char* argv[])
+{
+	FILE *in;
+	TIFF *out = NULL;
+	TIFFErrorHandler whandler = NULL;
+	int compression_in = COMPRESSION_CCITTFAX3;
+	int compression_out = COMPRESSION_CCITTFAX3;
+	int fillorder_in = FILLORDER_LSB2MSB;
+	int fillorder_out = FILLORDER_LSB2MSB;
+	uint32 group3options_in = 0;	/* 1d-encoded */
+	uint32 group3options_out = 0;	/* 1d-encoded */
+	uint32 group4options_in = 0;	/* compressed */
+	uint32 group4options_out = 0;	/* compressed */
+	uint32 defrowsperstrip = (uint32) 0;
+	uint32 rowsperstrip;
+	int photometric_in = PHOTOMETRIC_MINISWHITE;
+	int photometric_out = PHOTOMETRIC_MINISWHITE;
+	int mode = FAXMODE_CLASSF;
+	int rows;
+	int c;
+	int pn, npages;
+	float resY = 196.0;
+	extern int optind;
+	extern char* optarg;
+
+
+	while ((c = getopt(argc, argv, "R:X:o:1234ABLMPUW5678abcflmprsuvwz?")) != -1)
+		switch (c) {
+			/* input-related options */
+		case '3':		/* input is g3-encoded */
+			compression_in = COMPRESSION_CCITTFAX3;
+			break;
+		case '4':		/* input is g4-encoded */
+			compression_in = COMPRESSION_CCITTFAX4;
+			break;
+		case 'U':		/* input is uncompressed (g3 and g4) */
+			group3options_in |= GROUP3OPT_UNCOMPRESSED;
+			group4options_in |= GROUP4OPT_UNCOMPRESSED;
+			break;
+		case '1':		/* input is 1d-encoded (g3 only) */
+			group3options_in &= ~GROUP3OPT_2DENCODING;
+			break;
+		case '2':		/* input is 2d-encoded (g3 only) */
+			group3options_in |= GROUP3OPT_2DENCODING;
+			break;
+		case 'P':	/* input has not-aligned EOL (g3 only) */
+			group3options_in &= ~GROUP3OPT_FILLBITS;
+			break;
+		case 'A':		/* input has aligned EOL (g3 only) */
+			group3options_in |= GROUP3OPT_FILLBITS;
+			break;
+		case 'W':		/* input has 0 mean white */
+			photometric_in = PHOTOMETRIC_MINISWHITE;
+			break;
+		case 'B':		/* input has 0 mean black */
+			photometric_in = PHOTOMETRIC_MINISBLACK;
+			break;
+		case 'L':		/* input has lsb-to-msb fillorder */
+			fillorder_in = FILLORDER_LSB2MSB;
+			break;
+		case 'M':		/* input has msb-to-lsb fillorder */
+			fillorder_in = FILLORDER_MSB2LSB;
+			break;
+		case 'R':		/* input resolution */
+			resY = (float) atof(optarg);
+			break;
+		case 'X':		/* input width */
+			xsize = (uint32) atoi(optarg);
+			break;
+
+			/* output-related options */
+		case '7':		/* generate g3-encoded output */
+			compression_out = COMPRESSION_CCITTFAX3;
+			break;
+		case '8':		/* generate g4-encoded output */
+			compression_out = COMPRESSION_CCITTFAX4;
+			break;
+		case 'u':	/* generate uncompressed output (g3 and g4) */
+			group3options_out |= GROUP3OPT_UNCOMPRESSED;
+			group4options_out |= GROUP4OPT_UNCOMPRESSED;
+			break;
+		case '5':	/* generate 1d-encoded output (g3 only) */
+			group3options_out &= ~GROUP3OPT_2DENCODING;
+			break;
+		case '6':	/* generate 2d-encoded output (g3 only) */
+			group3options_out |= GROUP3OPT_2DENCODING;
+			break;
+		case 'c':		/* generate "classic" g3 format */
+			mode = FAXMODE_CLASSIC;
+			break;
+		case 'f':		/* generate Class F format */
+			mode = FAXMODE_CLASSF;
+			break;
+		case 'm':		/* output's fillorder is msb-to-lsb */
+			fillorder_out = FILLORDER_MSB2LSB;
+			break;
+		case 'l':		/* output's fillorder is lsb-to-msb */
+			fillorder_out = FILLORDER_LSB2MSB;
+			break;
+		case 'o':
+			out = TIFFOpen(optarg, "w");
+			if (out == NULL) {
+				fprintf(stderr,
+				    "%s: Can not create or open %s\n",
+				    argv[0], optarg);
+				return EXIT_FAILURE;
+			}
+			break;
+		case 'a':	/* generate EOL-aligned output (g3 only) */
+			group3options_out |= GROUP3OPT_FILLBITS;
+			break;
+		case 'p':	/* generate not EOL-aligned output (g3 only) */
+			group3options_out &= ~GROUP3OPT_FILLBITS;
+			break;
+		case 'r':		/* rows/strip */
+			defrowsperstrip = atol(optarg);
+			break;
+		case 's':		/* stretch image by dup'ng scanlines */
+			stretch = 1;
+			break;
+		case 'w':		/* undocumented -- for testing */
+			photometric_out = PHOTOMETRIC_MINISWHITE;
+			break;
+		case 'b':		/* undocumented -- for testing */
+			photometric_out = PHOTOMETRIC_MINISBLACK;
+			break;
+		case 'z':		/* undocumented -- for testing */
+			compression_out = COMPRESSION_LZW;
+			break;
+		case 'v':		/* -v for info */
+			verbose++;
+			break;
+		case '?':
+			usage();
+			/*NOTREACHED*/
+		}
+	npages = argc - optind;
+	if (npages < 1)
+		usage();
+
+	rowbuf = _TIFFmalloc(TIFFhowmany8(xsize));
+	refbuf = _TIFFmalloc(TIFFhowmany8(xsize));
+	if (rowbuf == NULL || refbuf == NULL) {
+		fprintf(stderr, "%s: Not enough memory\n", argv[0]);
+		return (EXIT_FAILURE);
+	}
+
+	if (out == NULL) {
+		out = TIFFOpen("fax.tif", "w");
+		if (out == NULL) {
+			fprintf(stderr, "%s: Can not create fax.tif\n",
+			    argv[0]);
+			return (EXIT_FAILURE);
+		}
+	}
+		
+	faxTIFF = TIFFClientOpen("(FakeInput)", "w",
+	/* TIFFClientOpen() fails if we don't set existing value here */
+				 TIFFClientdata(out),
+				 TIFFGetReadProc(out), TIFFGetWriteProc(out),
+				 TIFFGetSeekProc(out), TIFFGetCloseProc(out),
+				 TIFFGetSizeProc(out), TIFFGetMapFileProc(out),
+				 TIFFGetUnmapFileProc(out));
+	if (faxTIFF == NULL) {
+		fprintf(stderr, "%s: Can not create fake input file\n",
+		    argv[0]);
+		return (EXIT_FAILURE);
+	}
+	TIFFSetMode(faxTIFF, O_RDONLY);
+	TIFFSetField(faxTIFF, TIFFTAG_IMAGEWIDTH,	xsize);
+	TIFFSetField(faxTIFF, TIFFTAG_SAMPLESPERPIXEL,	1);
+	TIFFSetField(faxTIFF, TIFFTAG_BITSPERSAMPLE,	1);
+	TIFFSetField(faxTIFF, TIFFTAG_FILLORDER,	fillorder_in);
+	TIFFSetField(faxTIFF, TIFFTAG_PLANARCONFIG,	PLANARCONFIG_CONTIG);
+	TIFFSetField(faxTIFF, TIFFTAG_PHOTOMETRIC,	photometric_in);
+	TIFFSetField(faxTIFF, TIFFTAG_YRESOLUTION,	resY);
+	TIFFSetField(faxTIFF, TIFFTAG_RESOLUTIONUNIT,	RESUNIT_INCH);
+	
+	/* NB: this must be done after directory info is setup */
+	TIFFSetField(faxTIFF, TIFFTAG_COMPRESSION, compression_in);
+	if (compression_in == COMPRESSION_CCITTFAX3)
+		TIFFSetField(faxTIFF, TIFFTAG_GROUP3OPTIONS, group3options_in);
+	else if (compression_in == COMPRESSION_CCITTFAX4)
+		TIFFSetField(faxTIFF, TIFFTAG_GROUP4OPTIONS, group4options_in);
+	for (pn = 0; optind < argc; pn++, optind++) {
+		in = fopen(argv[optind], "rb");
+		if (in == NULL) {
+			fprintf(stderr,
+			    "%s: %s: Can not open\n", argv[0], argv[optind]);
+			continue;
+		}
+#if defined(_WIN32) && defined(USE_WIN32_FILEIO)
+                TIFFSetClientdata(faxTIFF, (thandle_t)_get_osfhandle(fileno(in)));
+#else
+                TIFFSetClientdata(faxTIFF, (thandle_t)fileno(in));
+#endif
+		TIFFSetFileName(faxTIFF, (const char*)argv[optind]);
+		TIFFSetField(out, TIFFTAG_IMAGEWIDTH, xsize);
+		TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 1);
+		TIFFSetField(out, TIFFTAG_COMPRESSION, compression_out);
+		TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric_out);
+		TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+		TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 1);
+		switch (compression_out) {
+			/* g3 */
+			case COMPRESSION_CCITTFAX3:
+			TIFFSetField(out, TIFFTAG_GROUP3OPTIONS,
+				     group3options_out);
+			TIFFSetField(out, TIFFTAG_FAXMODE, mode);
+			rowsperstrip =
+				(defrowsperstrip)?defrowsperstrip:(uint32)-1L;
+			break;
+
+			/* g4 */
+			case COMPRESSION_CCITTFAX4:
+			TIFFSetField(out, TIFFTAG_GROUP4OPTIONS,
+				     group4options_out);
+			TIFFSetField(out, TIFFTAG_FAXMODE, mode);
+			rowsperstrip =
+				(defrowsperstrip)?defrowsperstrip:(uint32)-1L;
+			break;
+
+			default:
+			rowsperstrip = (defrowsperstrip) ?
+				defrowsperstrip : TIFFDefaultStripSize(out, 0);
+		}
+		TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
+		TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+		TIFFSetField(out, TIFFTAG_FILLORDER, fillorder_out);
+		TIFFSetField(out, TIFFTAG_SOFTWARE, "fax2tiff");
+		TIFFSetField(out, TIFFTAG_XRESOLUTION, 204.0);
+		if (!stretch) {
+			TIFFGetField(faxTIFF, TIFFTAG_YRESOLUTION, &resY);
+			TIFFSetField(out, TIFFTAG_YRESOLUTION, resY);
+		} else
+			TIFFSetField(out, TIFFTAG_YRESOLUTION, 196.);
+		TIFFSetField(out, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
+		TIFFSetField(out, TIFFTAG_PAGENUMBER, pn, npages);
+
+		if (!verbose)
+		    whandler = TIFFSetWarningHandler(NULL);
+		rows = copyFaxFile(faxTIFF, out);
+		fclose(in);
+		if (!verbose)
+		    (void) TIFFSetWarningHandler(whandler);
+
+		TIFFSetField(out, TIFFTAG_IMAGELENGTH, rows);
+
+		if (verbose) {
+			fprintf(stderr, "%s:\n", argv[optind]);
+			fprintf(stderr, "%d rows in input\n", rows);
+			fprintf(stderr, "%ld total bad rows\n",
+			    (long) badfaxlines);
+			fprintf(stderr, "%d max consecutive bad rows\n", badfaxrun);
+		}
+		if (compression_out == COMPRESSION_CCITTFAX3 &&
+		    mode == FAXMODE_CLASSF) {
+			TIFFSetField(out, TIFFTAG_BADFAXLINES, badfaxlines);
+			TIFFSetField(out, TIFFTAG_CLEANFAXDATA, badfaxlines ?
+			    CLEANFAXDATA_REGENERATED : CLEANFAXDATA_CLEAN);
+			TIFFSetField(out, TIFFTAG_CONSECUTIVEBADFAXLINES, badfaxrun);
+		}
+		TIFFWriteDirectory(out);
+	}
+	TIFFClose(out);
+	_TIFFfree(rowbuf);
+	_TIFFfree(refbuf);
+	return (EXIT_SUCCESS);
+}
+
+int
+copyFaxFile(TIFF* tifin, TIFF* tifout)
+{
+	uint32 row;
+	uint32 linesize = TIFFhowmany8(xsize);
+	uint16 badrun;
+	int ok;
+
+	tifin->tif_rawdatasize = TIFFGetFileSize(tifin);
+	tifin->tif_rawdata = _TIFFmalloc(tifin->tif_rawdatasize);
+	if (tifin->tif_rawdata == NULL) {
+		TIFFError(tifin->tif_name, "Not enough memory");
+		return (0);
+	}
+	if (!ReadOK(tifin, tifin->tif_rawdata, tifin->tif_rawdatasize)) {
+		TIFFError(tifin->tif_name, "Read error at scanline 0");
+		return (0);
+	}
+	tifin->tif_rawcp = tifin->tif_rawdata;
+	tifin->tif_rawcc = tifin->tif_rawdatasize;
+
+	(*tifin->tif_setupdecode)(tifin);
+	(*tifin->tif_predecode)(tifin, (tsample_t) 0);
+	tifin->tif_row = 0;
+	badfaxlines = 0;
+	badfaxrun = 0;
+
+	_TIFFmemset(refbuf, 0, linesize);
+	row = 0;
+	badrun = 0;		/* current run of bad lines */
+	while (tifin->tif_rawcc > 0) {
+		ok = (*tifin->tif_decoderow)(tifin, (tdata_t) rowbuf, 
+					     linesize, 0);
+		if (!ok) {
+			badfaxlines++;
+			badrun++;
+			/* regenerate line from previous good line */
+			_TIFFmemcpy(rowbuf, refbuf, linesize);
+		} else {
+			if (badrun > badfaxrun)
+				badfaxrun = badrun;
+			badrun = 0;
+			_TIFFmemcpy(refbuf, rowbuf, linesize);
+		}
+		tifin->tif_row++;
+
+		if (TIFFWriteScanline(tifout, rowbuf, row, 0) < 0) {
+			fprintf(stderr, "%s: Write error at row %ld.\n",
+			    tifout->tif_name, (long) row);
+			break;
+		}
+		row++;
+		if (stretch) {
+			if (TIFFWriteScanline(tifout, rowbuf, row, 0) < 0) {
+				fprintf(stderr, "%s: Write error at row %ld.\n",
+				    tifout->tif_name, (long) row);
+				break;
+			}
+			row++;
+		}
+	}
+	if (badrun > badfaxrun)
+		badfaxrun = badrun;
+	_TIFFfree(tifin->tif_rawdata);
+	return (row);
+}
+
+char* stuff[] = {
+"usage: fax2tiff [options] input.raw...",
+"where options are:",
+" -3		input data is G3-encoded		[default]",
+" -4		input data is G4-encoded",
+" -U		input data is uncompressed (G3 or G4)",
+" -1		input data is 1D-encoded (G3 only)	[default]",
+" -2		input data is 2D-encoded (G3 only)",
+" -P		input is not EOL-aligned (G3 only)	[default]",
+" -A		input is EOL-aligned (G3 only)",
+" -M		input data has MSB2LSB bit order",
+" -L		input data has LSB2MSB bit order	[default]",
+" -B		input data has min 0 means black",
+" -W		input data has min 0 means white	[default]",
+" -R #		input data has # resolution (lines/inch) [default is 196]",
+" -X #		input data has # width			[default is 1728]",
+"",
+" -o out.tif	write output to out.tif",
+" -7		generate G3-encoded output		[default]",
+" -8		generate G4-encoded output",
+" -u		generate uncompressed output (G3 or G4)",
+" -5		generate 1D-encoded output (G3 only)",
+" -6		generate 2D-encoded output (G3 only)	[default]",
+" -p		generate not EOL-aligned output (G3 only)",
+" -a		generate EOL-aligned output (G3 only)	[default]",
+" -c		generate \"classic\" TIFF format",
+" -f		generate TIFF Class F (TIFF/F) format	[default]",
+" -m		output fill order is MSB2LSB",
+" -l		output fill order is LSB2MSB		[default]",
+" -r #		make each strip have no more than # rows",
+" -s		stretch image by duplicating scanlines",
+" -v		print information about conversion work",
+" -z		generate LZW compressed output",
+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(EXIT_FAILURE);
+}
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */