Subversion Repositories planix.SVN

/*

 *

 * postdmd - PostScript translator for DMD bitmap files.

 *

 * A simple program that can be used to print DMD bitmaps on PostScript printers.

 * Much of the code was borrowed from abm, which was written by Guy Riddle.

 *

 * Although the program supports two different input bitmap formats, by far the

 * most important is the Eighth (and Ninth) Edition bitfile format. A bitmap in

 * the bitfile format begins with a 10 byte header with the first two bytes set to

 * zero. The next 8 bytes set the x and y coordinates of the bitmap's origin and

 * corner (ie. the upper left and lower right corners). The compressed raster data

 * follows the header and consists of control bytes followed an appropriate number

 * of data bytes. Control bytes (ie. n) less than 127 means read the next 2*n bytes 

 * of raster data directly from the input file, while if n is larger than 128 we

 * read two bytes from the input file and replicate the bytes n-128 times. After

 * each scan line is recovered it's exclusive-or'd with the preceeding line to

 * generate the real raster data.

 *

 * After each raster line is recovered postdmd encodes it in a slightly different

 * format that's designed to be unpacked by a PostScript procedure that's defined

 * in the prologue. By default no exclusive-or'ing is done and packing of pattern

 * data can be based on any number of bytes rather than just the next two bytes.

 * By default 6 byte patterns are used, but any number can be selected with the -b

 * option. A non-positive argument (eg. -b0) disables all pattern encoding. Larger

 * patterns increase the size of the output file, but reduce the work load that's

 * forced on the PostScript interpreter. The default choices I've made (ie. 6 byte

 * patterns and no exclusive-or'ing) do a decent balancing job across currently

 * available PostScript printers. Larger patterns (eg. -b16) increase the output

 * file size, but may be appropriate if you're running at a high baud rate (eg.

 * 19.2KB), while smaller patter size (eg. -b4) may help if you've got a printer

 * with a fast processor (eg. a PS-810).

 *

 * The encoding produced by the program (and decoded on the printer) looks like,

 * 

 * 	bytes patterns count

 * 

 * where bytes and count are decimal integers and patterns is a hex string. Bytes

 * is the number of bytes represented by the hex patterns and count is the number

 * of additional times the patterns should be repeated. For example,

 * 

 * 	2 FFFF 4

 * 	5 FFFFFFFFFF 1

 *     10 FFFFFFFFFFFFFFFFFFFF 0

 * 

 * all represent 10 consecutive bytes of ones. Scanlines are terminated by a 0 on

 * a line by itself.

 *

 * The PostScript prologue is copied from *prologue before any of the input files

 * are translated. The program expects that the following PostScript procedures

 * are defined in that file:

 *

 *	setup

 *

 *	  mark ... setup -

 *

 *	    Handles special initialization stuff that depends on how this program

 *	    was called. Expects to find a mark followed by key/value pairs on the

 *	    stack. The def operator is applied to each pair up to the mark, then

 *	    the default state is set up.

 *

 *	pagesetup

 *

 *	  page pagesetup -

 *

 *	    Does whatever is needed to set things up for the next page. Expects

 *	    to find the current page number on the stack.

 *

 *	bitmap

 *

 *	  v8format flip scanlength scanlines bitmap -

 *

 *	    Prints the bitmap that's read from standard input. The bitmap consists

 *	    of scanlines lines, each of which includes scanlength pixels. If

 *	    v8format is true the picture is assumed to be an Eighth Edition bitmap,

 *	    and the exclusive-or'ing will be done on the printer.

 *

 *	done

 *

 *	  done

 *

 *	    Makes sure the last page is printed. Only needed when we're printing

 *	    more than one page on each sheet of paper.

 *

 * Many default values, like the magnification and orientation, are defined in 

 * the prologue, which is where they belong. If they're changed (by options), an

 * appropriate definition is made after the prologue is added to the output file.

 * The -P option passes arbitrary PostScript through to the output file. Among

 * other things it can be used to set (or change) values that can't be accessed by

 * other options.

 *

 */

#include <stdio.h>

#include <signal.h>

#include <ctype.h>

#ifdef plan9

#define	isascii(c)	((unsigned char)(c)<=0177)

#endif

#include <sys/types.h>

#include <fcntl.h>

#include "comments.h"			/* PostScript file structuring comments */

#include "gen.h"			/* general purpose definitions */

#include "path.h"			/* for the prologue */

#include "ext.h"			/* external variable declarations */

char	*optnames = "a:b:c:fm:n:o:p:ux:y:A:C:E:J:L:P:DI";

char	*prologue = POSTDMD;		/* default PostScript prologue */

char	*formfile = FORMFILE;		/* stuff for multiple pages per sheet */

int	bbox[2] = {0, 0};		/* upper right coordinates only */

int	formsperpage = 1;		/* page images on each piece of paper */

int	copies = 1;			/* and this many copies of each sheet */

int	bytespp = 6;			/* bytes per pattern - on output */

int	flip = FALSE;			/* ones complement the bitmap */

int	v8undo = TRUE;			/* xor'ing done on host if TRUE */

int	v8format = FALSE;		/* for Eighth Edition bitmaps */

int	page = 0;			/* last page we worked on */

int	printed = 0;			/* and the number of pages printed */

int	patterns;			/* 16 bit patterns per scan line */

int	scanlines;			/* lines in the bitmap */

int	patcount = 0;			/* should be patterns * scanlines */

char	*raster = NULL;			/* next raster line */

char	*prevrast = NULL;		/* and the previous one - v8format */

char	*rptr;				/* next free byte in raster */

char	*eptr;				/* one past the last byte in raster */

FILE	*fp_in = NULL;			/* read from this file */

FILE	*fp_out = stdout;		/* and write stuff here */

FILE	*fp_acct = NULL;		/* for accounting data */

/*****************************************************************************/

main(agc, agv)

    int		agc;

    char	*agv[];

{

/*

 *

 * A simple program that translates DMD bitmap files into PostScript. There can

 * be more than one bitmap per file, but none can be split across input files.

 * Each bitmap goes on a page by itself.

 *

 */

    argc = agc;				/* other routines may want them */

    argv = agv;

    prog_name = argv[0];		/* really just for error messages */

    init_signals();			/* sets up interrupt handling */

    header();				/* PostScript header comments */

    options();				/* handle the command line options */

    setup();				/* for PostScript */

    arguments();			/* followed by each input file */

    done();				/* print the last page etc. */

    account();				/* job accounting data */

    exit(x_stat);			/* not much could be wrong */

}   /* End of main */

/*****************************************************************************/

init_signals()

{

/*

 *

 * Make sure we handle interrupts.

 *

 */

    if ( signal(SIGINT, interrupt) == SIG_IGN )  {

	signal(SIGINT, SIG_IGN);

	signal(SIGQUIT, SIG_IGN);

	signal(SIGHUP, SIG_IGN);

    } else {

	signal(SIGHUP, interrupt);

	signal(SIGQUIT, interrupt);

    }   /* End else */

    signal(SIGTERM, interrupt);

}   /* End of init_signals */

/*****************************************************************************/

header()

{

    int		ch;			/* return value from getopt() */

    int		old_optind = optind;	/* for restoring optind - should be 1 */

/*

 *

 * Scans the option list looking for things, like the prologue file, that we need

 * right away but could be changed from the default. Doing things this way is an

 * attempt to conform to Adobe's latest file structuring conventions. In particular

 * they now say there should be nothing executed in the prologue, and they have

 * added two new comments that delimit global initialization calls. Once we know

 * where things really are we write out the job header, follow it by the prologue,

 * and then add the ENDPROLOG and BEGINSETUP comments.

 *

 */

    while ( (ch = getopt(argc, argv, optnames)) != EOF )

	if ( ch == 'L' )

	    prologue = optarg;

	else if ( ch == '?' )

	    error(FATAL, "");

    optind = old_optind;		/* get ready for option scanning */

    fprintf(stdout, "%s", CONFORMING);

    fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);

    fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);

    fprintf(stdout, "%s %s\n", PAGES, ATEND);

    fprintf(stdout, "%s", ENDCOMMENTS);

    if ( cat(prologue) == FALSE )

	error(FATAL, "can't read %s", prologue);

    fprintf(stdout, "%s", ENDPROLOG);

    fprintf(stdout, "%s", BEGINSETUP);

    fprintf(stdout, "mark\n");

}   /* End of header */

/*****************************************************************************/

options()

{

    int		ch;			/* return value from getopt() */

/*

 *

 * Reads and processes the command line options. Added the -P option so arbitrary

 * PostScript code can be passed through. Expect it could be useful for changing

 * definitions in the prologue for which options have not been defined.

 *

 */

    while ( (ch = getopt(argc, argv, optnames)) != EOF )  {

	switch ( ch )  {

	    case 'a':			/* aspect ratio */

		    fprintf(stdout, "/aspectratio %s def\n", optarg);

		    break;

	    case 'b':			/* bytes per pattern */

		    bytespp = atoi(optarg);

		    break;

	    case 'c':			/* copies */

		    copies = atoi(optarg);

		    fprintf(stdout, "/#copies %s store\n", optarg);

		    break;

	    case 'f':			/* ones complement - sort of */

		    flip = TRUE;

		    break;

	    case 'm':			/* magnification */

		    fprintf(stdout, "/magnification %s def\n", optarg);

		    break;

	    case 'n':			/* forms per page */

		    formsperpage = atoi(optarg);

		    fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);

		    fprintf(stdout, "/formsperpage %s def\n", optarg);

		    break;

	    case 'o':			/* output page list */

		    out_list(optarg);

		    break;

	    case 'p':			/* landscape or portrait mode */

		    if ( *optarg == 'l' )

			fprintf(stdout, "/landscape true def\n");

		    else fprintf(stdout, "/landscape false def\n");

		    break;

	    case 'u':			/* don't undo Eighth Edition bitmaps */

		    v8undo = FALSE;

		    break;

	    case 'x':			/* shift things horizontally */

		    fprintf(stdout, "/xoffset %s def\n", optarg);

		    break;

	    case 'y':			/* and vertically on the page */

		    fprintf(stdout, "/yoffset %s def\n", optarg);

		    break;

	    case 'A':			/* force job accounting */

	    case 'J':

		    if ( (fp_acct = fopen(optarg, "a")) == NULL )

			error(FATAL, "can't open accounting file %s", optarg);

		    break;

	    case 'C':			/* copy file straight to output */

		    if ( cat(optarg) == FALSE )

			error(FATAL, "can't read %s", optarg);

		    break;

	    case 'E':			/* text font encoding - unnecessary */

		    fontencoding = optarg;

		    break;

	    case 'L':			/* PostScript prologue file */

		    prologue = optarg;

		    break;

	    case 'P':			/* PostScript pass through */

		    fprintf(stdout, "%s\n", optarg);

		    break;

	    case 'R':			/* special global or page level request */

		    saverequest(optarg);

		    break;

	    case 'D':			/* debug flag */

		    debug = ON;

		    break;

	    case 'I':			/* ignore FATAL errors */

		    ignore = ON;

		    break;

	    case '?':			/* don't understand the option */

		    error(FATAL, "");

		    break;

	    default:			/* don't know what to do for ch */

		    error(FATAL, "missing case for option %c\n", ch);

		    break;

	}   /* End switch */

    }   /* End while */

    argc -= optind;			/* get ready for non-option args */

    argv += optind;

}   /* End of options */

/*****************************************************************************/

setup()

{

/*

 *

 * Handles things that must be done after the options are read but before the

 * input files are processed.

 *

 */

    writerequest(0, stdout);		/* global requests eg. manual feed */

    setencoding(fontencoding);		/* unnecessary */

    fprintf(stdout, "setup\n");

    if ( formsperpage > 1 )  {		/* followed by stuff for multiple pages */

	if ( cat(formfile) == FALSE )

	    error(FATAL, "can't read %s", formfile);

	fprintf(stdout, "%d setupforms\n", formsperpage);

    }	/* End if */

    fprintf(stdout, "%s", ENDSETUP);

}   /* End of setup */

/*****************************************************************************/

arguments()

{

    FILE	*fp;			/* next input file */

/*

 *

 * Makes sure all the non-option command line arguments are processed. If we get

 * here and there aren't any arguments left, or if '-' is one of the input files

 * we'll process stdin.

 *

 */

    if ( argc < 1 )

	bitmap(stdin);

    else  {				/* at least one argument is left */

	while ( argc > 0 )  {

	    if ( strcmp(*argv, "-") == 0 )

		fp = stdin;

	    else if ( (fp = fopen(*argv, "r")) == NULL )

		error(FATAL, "can't open %s", *argv);

	    bitmap(fp);

	    if ( fp != stdin )

		fclose(fp);

	    argc--;

	    argv++;

	}   /* End while */

    }   /* End else */

}   /* End of arguments */

/*****************************************************************************/

done()

{

/*

 *

 * Finished with all the input files, so mark the end of the pages with a TRAILER

 * comment, make sure the last page prints, and add things like the PAGES comment

 * that can only be determined after all the input files have been read.

 *

 */

    fprintf(stdout, "%s", TRAILER);

    fprintf(stdout, "done\n");

    fprintf(stdout, "%s 0 0 %d %d\n", BOUNDINGBOX, (bbox[0]*72+100)/100, (bbox[1]*72+100)/100);

    fprintf(stdout, "%s %d\n", PAGES, printed);

}   /* End of done */

/*****************************************************************************/

account()

{

/*

 *

 * Writes an accounting record to *fp_acct provided it's not NULL. Accounting is

 * requested using the -A or -J options.

 *

 */

    if ( fp_acct != NULL )

	fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);

}   /* End of account */

/*****************************************************************************/

bitmap(fp)

    FILE	*fp;			/* next input file */

{

    int		count;			/* pattern repeats this many times */

    long	total;			/* expect this many patterns */

/*

 *

 * Reads all the bitmaps from the next input file, translates each one into

 * PostScript, and arranges to have one bitmap printed on each page. Multiple

 * bitmaps per input file work.

 *

 */

    fp_in = fp;				/* everyone reads from this file */

    while ( dimensions() == TRUE )  {

	patcount = 0;

	total = scanlines * patterns;

	bbox[0] = MAX(bbox[0], patterns*16);	/* for BoundingBox comment */

	bbox[1] = MAX(bbox[1], scanlines);

	redirect(++page);

	fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);

	fprintf(fp_out, "/saveobj save def\n");

	writerequest(printed+1, fp_out);

	fprintf(fp_out, "%s ", (v8format == TRUE && v8undo == FALSE) ? "true" : "false");

	fprintf(fp_out, "%s ", (flip == TRUE) ? "true" : "false");

	fprintf(fp_out, "%d %d bitmap\n", patterns * 16, scanlines);

	while ( patcount != total && (count = getc(fp)) != EOF )  {

	    addrast(count);

	    patcount += (count & 0177);

	    if ( patcount % patterns == 0 )

		putrast();

	}   /* End while */

	if ( debug == ON )

	    fprintf(stderr, "patterns = %d, scanlines = %d, patcount = %d\n", patterns, scanlines, patcount);

	if ( total != patcount )

	    error(FATAL, "bitmap format error");

	if ( fp_out == stdout ) printed++;

	fprintf(fp_out, "showpage\n");

	fprintf(fp_out, "saveobj restore\n");

	fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);

    }	/* End while */

}   /* End of bitmap */

/*****************************************************************************/

dimensions()

{

    int		ox, oy;			/* coordinates of the origin */

    int		cx, cy;			/* and right corner of the bitmap */

    int		i;			/* loop index */

/*

 *

 * Determines the dimensions and type of the next bitmap. Eighth edition bitmaps

 * have a zero in the first 16 bits. If valid dimensions are read TRUE is returned

 * to the caller. Changed so the check of whether we're done (by testing scanlines

 * or patterns) comes before the malloc().

 *

 */

    if ( (scanlines = getint()) == 0 )  {

	ox = getint();

	oy = getint();

	cx = getint();

	cy = getint();

	scanlines = cy - oy;

	patterns = (cx - ox + 15) / 16;

	v8format = TRUE;

    } else patterns = getint();

    if ( scanlines <= 0 || patterns <= 0 )	/* done - don't do the malloc() */

	return(FALSE);

    if ( raster != NULL ) free(raster);

    if ( prevrast != NULL ) free(prevrast);

    if ( (rptr = raster = (char *) malloc(patterns * 2)) == NULL )

	error(FATAL, "no memory");

    if ( (prevrast = (char *) malloc(patterns * 2)) == NULL )

	error(FATAL, "no memory");

    for ( i = 0; i < patterns * 2; i++ )

	*(prevrast+i) = 0377;

    eptr = rptr + patterns * 2;

    return(TRUE);

}   /* End of dimensions */

/*****************************************************************************/

addrast(count)

    int		count;			/* repeat count for next pattern */

{

    int		size;			/* number of bytes in next pattern */

    int		l, h;			/* high and low bytes */

    int		i, j;			/* loop indices */

/*

 *

 * Reads the input file and adds the appropriate number of bytes to the output

 * raster line. If count has bit 7 on, one 16 bit pattern is read and repeated

 * count & 0177 times. If bit 7 is off, count is the number of patterns read from

 * fp_in - each one repeated once.

 *

 */

    if ( count & 0200 )  {

	size = 1;

	count &= 0177;

    } else {

	size = count;

	count = 1;

    }	/* End else */

    for ( i = size; i > 0; i-- )  {

	if ( (l = getc(fp_in)) == EOF || (h = getc(fp_in)) == EOF )

	    return;

	for ( j = count; j > 0; j-- )  {

	    *rptr++ = l;

	    *rptr++ = h;

	}   /* End for */

    }	/* End for */

}   /* End of addrast */

/*****************************************************************************/

putrast()

{

    char	*p1, *p2;		/* starting and ending patterns */

    int		n;			/* set to bytes per pattern */

    int		i;			/* loop index */

/*

 *

 * Takes the scanline that's been saved in *raster, encodes it according to the

 * value that's been assigned to bytespp, and writes the result to *fp_out. Each

 * line in the output bitmap is terminated by a 0 on a line by itself.

 *

 */

    n = (bytespp <= 0) ? 2 * patterns : bytespp;

    if ( v8format == TRUE && v8undo == TRUE )

	for ( i = 0; i < patterns * 2; i++ )

	    *(raster+i) = (*(prevrast+i) ^= *(raster+i));

    for ( p1 = raster, p2 = raster + n; p1 < eptr; p1 = p2 )

	if ( patncmp(p1, n) == TRUE )  {

	    while ( patncmp(p2, n) == TRUE ) p2 += n;

	    p2 += n;

	    fprintf(fp_out, "%d ", n);

	    for ( i = 0; i < n; i++, p1++ )

		fprintf(fp_out, "%.2X", ((int) *p1) & 0377);

	    fprintf(fp_out, " %d\n", (p2 - p1) / n);

	} else {

	    while ( p2 < eptr && patncmp(p2, n) == FALSE ) p2 += n;

	    if ( p2 > eptr ) p2 = eptr;

	    fprintf(fp_out, "%d ", p2 - p1);

	    while ( p1 < p2 )

		fprintf(fp_out, "%.2X", ((int) *p1++) & 0377);

	    fprintf(fp_out, " 0\n");

	}   /* End else */

    fprintf(fp_out, "0\n");

    rptr = raster;

}   /* End of putrast */

/*****************************************************************************/

patncmp(p1, n)

    char	*p1;			/* first patterns starts here */

    int		n;			/* and extends this many bytes */

{

    char	*p2;			/* address of the second pattern */

/*

 *

 * Compares the two n byte patterns *p1 and *(p1+n). FALSE is returned if they're

 * different or extend past the end of the current raster line.

 *

 */

    p2 = p1 + n;

    for ( ; n > 0; n--, p1++, p2++ )

	if ( p2 >= eptr || *p1 != *p2 )

	    return(FALSE);

    return(TRUE);

}   /* End of patncmp */

/*****************************************************************************/

getint()

{

    int		h, l;			/* high and low bytes */

/*

 *

 * Reads the next two bytes from *fp_in and returns the resulting integer.

 *

 */

    if ( (l = getc(fp_in)) == EOF || (h = getc(fp_in)) == EOF )

	return(-1);

    return((h & 0377) << 8 | (l & 0377));

}   /* End of getint */

/*****************************************************************************/

redirect(pg)

    int		pg;			/* next page we're printing */

{

    static FILE	*fp_null = NULL;	/* if output is turned off */

/*

 *

 * If we're not supposed to print page pg, fp_out will be directed to /dev/null,

 * otherwise output goes to stdout.

 *

 */

    if ( pg >= 0 && in_olist(pg) == ON )

	fp_out = stdout;

    else if ( (fp_out = fp_null) == NULL )

	fp_out = fp_null = fopen("/dev/null", "w");

}   /* End of redirect */

/*****************************************************************************/