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