/* $Id: fax2tiff.c,v 1.28 2017-10-29 18:28:45 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

#ifdef NEED_LIBPORT

# include "libport.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);

/*

  Struct to carry client data.  Note that it does not appear that the client

  data is actually used in this program.

*/

typedef struct _FAX_Client_Data

{

#if defined(_WIN32) && defined(USE_WIN32_FILEIO)

        intptr_t fh; /* Operating system file handle */

#else

        int fd;      /* Integer file descriptor */

#endif

} FAX_Client_Data;

int

main(int argc, char* argv[])

{

	FILE *in;

	TIFF *out = NULL;

        FAX_Client_Data client_data;

	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;

#if !HAVE_DECL_OPTARG

	extern int optind;

	extern char* optarg;

#endif

	while ((c = getopt(argc, argv, "R:X:o:r: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)

                client_data.fh = _get_osfhandle(fileno(in));

#else

                client_data.fd = fileno(in);

#endif

                TIFFSetClientdata(faxTIFF, (thandle_t) &client_data);

		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 = (tmsize_t)TIFFGetFileSize(tifin);

	if (tifin->tif_rawdatasize == 0) {

		TIFFError(tifin->tif_name, "Empty input file");

		return (0);

	}

	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:

 */