postdmd.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#ident "%Z%%M% %I% %E% SMI" /* SVr4.0 1.1 */
/*
*
* 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
* 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>
#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:J:L:P:DI";
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 *rptr; /* next free byte in raster */
char *eptr; /* one past the last byte in raster */
/*****************************************************************************/
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.
*
*/
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 */
} /* End of main */
/*****************************************************************************/
{
void interrupt(); /* signal handler */
/*
*
* Make sure we handle interrupts.
*
*/
} else {
} /* End else */
} /* End of init_signals */
/*****************************************************************************/
header()
{
int ch; /* return value from getopt() */
/*
*
* 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.
*
*/
if ( ch == 'L' )
else if ( ch == '?' )
} /* 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.
*
*/
switch ( ch ) {
case 'a': /* aspect ratio */
break;
case 'b': /* bytes per pattern */
break;
case 'c': /* copies */
break;
case 'f': /* ones complement - sort of */
break;
case 'm': /* magnification */
break;
case 'n': /* forms per page */
break;
case 'o': /* output page list */
break;
case 'p': /* landscape or portrait mode */
if ( *optarg == 'l' )
break;
case 'u': /* don't undo Eighth Edition bitmaps */
break;
case 'x': /* shift things horizontally */
break;
case 'y': /* and vertically on the page */
break;
case 'A': /* force job accounting */
case 'J':
break;
case 'C': /* copy file straight to output */
break;
case 'L': /* PostScript prologue file */
break;
case 'P': /* PostScript pass through */
break;
case 'R': /* special global or page level request */
break;
case 'D': /* debug flag */
break;
case 'I': /* ignore FATAL errors */
break;
case '?': /* don't understand the option */
break;
default: /* don't know what to do for ch */
break;
} /* End switch */
} /* End while */
} /* End of options */
/*****************************************************************************/
setup()
{
/*
*
* Handles things that must be done after the options are read but before the
* input files are processed.
*
*/
} /* End if */
} /* End of setup */
/*****************************************************************************/
{
/*
*
* 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 )
else { /* at least one argument is left */
while ( argc > 0 ) {
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.
*
*/
} /* 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.
*
*/
} /* End of account */
/*****************************************************************************/
{
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.
*
*/
while ( dimensions() == TRUE ) {
patcount = 0;
putrast();
} /* End while */
} /* End while */
} /* End of 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().
*
*/
return(FALSE);
for ( i = 0; i < patterns * 2; i++ )
*(prevrast+i) = 0377;
return(TRUE);
} /* End of dimensions */
/*****************************************************************************/
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 {
count = 1;
} /* End else */
for ( i = size; i > 0; i-- ) {
return;
for ( j = count; j > 0; j-- ) {
*rptr++ = l;
*rptr++ = h;
} /* End for */
} /* End for */
} /* End of addrast */
/*****************************************************************************/
putrast()
{
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.
*
*/
for ( i = 0; i < patterns * 2; i++ )
p2 += n;
for ( i = 0; i < n; i++, p1++ )
} else {
} /* End else */
} /* End of putrast */
/*****************************************************************************/
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.
*
*/
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.
*
*/
return(-1);
return((h & 0377) << 8 | (l & 0377));
} /* End of getint */
/*****************************************************************************/
int pg; /* next page we're printing */
{
/*
*
* otherwise output goes to stdout.
*
*/
} /* End of redirect */
/*****************************************************************************/