/*
*
* 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.
*
*/
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 */
/*
*
* 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 */
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 */
/*
*
* 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;
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 */
/*
*
* 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 */
/*
*
* 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.
*
*/
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;
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().
*
*/
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.
*
*/
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));
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);
