/* $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

} 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:

*/