home *** CD-ROM | disk | FTP | other *** search
/ Carousel / CAROUSEL.cdr / mactosh / unix / unix_mac.c < prev    next >
C/C++ Source or Header  |  1984-07-30  |  16KB  |  551 lines
  1. /* convert from MacPaint document to a form that can be printed on the
  2.    Symbolics LGP-1 laser printer
  3.  
  4.    This program should work with MacPaint and Screen dump files (made by
  5.    COMMAND-SHIFT-3).  However, it does not work with MacWrite files.
  6.  
  7.    This program was written for Berkeley Unix, version 4.2, running on a
  8.    VAX.
  9.  
  10.    Options:
  11.     -h turn off halftoning
  12.     -m <n>    where <n> is between 1 and 4.  This is an indication
  13.         of how much to magnify (and is called the "magfactor")
  14.  
  15.    Written by Richard Furuta, Computer Science, University of Washington.
  16.    (July 26, 1984)
  17.  
  18.    Please report changes and fixes back to me.  By Arpanet and CSNet,
  19.    I am Furuta@Washington.  By uucp, I am ihnp4!uw-beaver!furuta.  I
  20.    prefer the Arpanet/CSNet address.
  21.  
  22.    I benefitted greatly from Ed Pattermann's code for macimp.  The
  23.    following description of the MacPaint font format comes from that
  24.    code.
  25.  
  26.    =============
  27.  
  28.        First, the Macintosh file ; This format is the common
  29.        interchange format for full-page bitmap images on the Macintosh.
  30.  
  31.        The first 512 bytes of the file are the header. The first four bytes
  32.        comprise the version number, followed by 38*8 = 304 bytes of
  33.        patterns.  The remaining 204 bytes of the header are reserved for
  34.        future expansion. If the version number is zero, the patterns are
  35.        ignored. Hence, programs that wish to create files to be read into
  36.        MACpaint can just write out 512 bytes of zero as the header.
  37.  
  38.        Following the header are 720 compressed scanlines of data which form
  39.        the 576 wide by 720 tall bitmap. The bitmap is compressed as follows ;
  40.        Any run of three or more equal bytes is compressed into a count byte
  41.        and a single data byte. Runs of unequal bytes are passed on literally,
  42.        preceded also by a count byte. i.e.
  43.  
  44.        <count byte> <data byte>
  45.          count = -1..-127 --> replicate byte 2..128 times
  46.        <count byte> <n data bytes>
  47.          count = 0.. 127 --> copy 1..128 bytes uncompressed
  48.          count = -128 ignored for backward compatibility
  49.  
  50.    =============
  51.  
  52.    This program produces a series of LGP "Define a Block of Raster Data"
  53.    commands which are used to produce a dump of the screen.  You have to be
  54.    careful about the syntax of the arguments to this command.  I had a bit of
  55.    trouble caused by forgetting that the byte ordering and bit ordering of the
  56.    raster words given to this command differ from those of the parameters to
  57.    the command.  I could have used the "Screen Dump" LGP command instead of
  58.    this command to dump the raster.  The advantage would have been that the
  59.    resolution of the device would have been halved probably eliminating the
  60.    need to half tone.  The disadvantage is that it is harder to support the
  61.    magnification factor of 3 that seems to make the most sense to me.
  62.  
  63.    An arbitrary magnification is used to blow up the figure in both dimensions
  64.    (x and y).  This is controlled by "magfactor" which should be at least one.
  65.    If it gets larger than 4, you'll have to expand the amount of storage given
  66.    to "outline" in procedure "makebitmap".  I try detect and skip blank scan
  67.    lines to help conserve bandwidth to the printer which is pretty horrid at
  68.    9600 baud.  Maybe one of these days our DR11/C interface will work again and
  69.    bandwidth won't be such a problem!
  70.  
  71. */
  72.  
  73. #include <stdio.h>
  74.  
  75. #define TRUE 1
  76. #define FALSE 0
  77. #define LGPESC 27    /* flags LGP command to the LGP */
  78.  
  79. /* for command line option processing */
  80. char *ProgName;
  81. extern char *optarg;
  82. extern int optind;
  83.  
  84. int checkwhite();
  85. int dolgpheader();
  86. char flipbits();
  87. int intoout();
  88.  
  89. /* a macpaint document in the worst case should occupy twice as many bytes
  90.    as a straight screen dump.  This pathological case comes when you have
  91.    only count bytes of 1.  Since the Mac screen is 576 x 720 bits or
  92.    72 x 720 bytes == 51840 bytes, this worst case would occupy 103680
  93.    bytes */
  94. char compressed[103680];    /* lookahead storage for input */
  95. int nextcompbyte;        /* next index into this array */
  96.  
  97. int whitestateflg;        /* TRUE if we last looked at a blank line */
  98.  
  99. /* The LGP washes out large black areas.  As an attempt to address this,
  100.    I'm trying to halftone the output */
  101.  
  102. #define DMASK 0377    /* 11111111 pass everything through */
  103. #define EMASK 0252    /* 10101010 even bits only */
  104. #define OMASK 0125    /* 01010101 odd bits only */
  105. char curmask;        /* the current one to use */
  106. int hflg;        /* TRUE if we want to halftone */
  107.  
  108. main(argc, argv)
  109. int argc;
  110. char **argv;
  111. {
  112.     int optch;        /* option character */
  113.     int ctr;        /* temporary counter */
  114.     int scanctr;        /* count the 720 scan lines */
  115.     int byte;        /* incoming information */
  116.     int countbyte;        /* gives meaning of subsequent input bytes */
  117.     int linebytecount;    /* how many bytes seen so far on
  118.                    input? 0..71 */
  119.     int magfactor;        /* how many times do you want to expand
  120.                    this? 1..4 */
  121.     int linecount;        /* how many lines in this current spread? */
  122.     int lgptop;        /* top of this lgp line */
  123.     int linestart;        /* when collecting a line, recall where it
  124.                    all began */
  125.     int laststate;        /* to allow detection of change */
  126.  
  127.     magfactor = 3;        /* by default, show at true size */
  128.     curmask = DMASK;    /* by default, in case no halftoning is set */
  129.     hflg = TRUE;        /* by default, halftoning */
  130.  
  131.     ProgName = *argv;
  132.  
  133.     /* grab some options */
  134.     while ((optch = getopt (argc, argv, "hm:")) != EOF) {
  135.         switch (optch) {
  136.         case 'h':    /* want halftoning */
  137.             hflg = FALSE;
  138.             curmask = DMASK;    /* unnecessary but for safety... */
  139.             break;
  140.         case 'm':    /* magnification factor */
  141.             magfactor = atoi(optarg);
  142.             break;
  143.         case '?':
  144.             fprintf(stderr, "Usage: %s [-m magfactor]\n",
  145.                 ProgName);
  146.             (void)fflush(stderr);
  147.             exit(1);    /* a bit harsh, but ... */
  148.         }
  149.     }
  150.     if((magfactor < 1) || (magfactor > 4))  {
  151.         fprintf(stderr, "%s: Sorry, magfactor can't be %d, must be between 1 and 4\n",
  152.             ProgName, magfactor);
  153.         exit(1);
  154.     }
  155.  
  156.     /* jump over the 512 bytes of header */
  157.     for(ctr=0; ctr < 512; ctr++)
  158.         byte = getc(stdin);
  159.  
  160.     nextcompbyte = 0;
  161.     whitestateflg = TRUE;
  162.     linecount = 0;
  163.     lgptop = 240 * 10;    /* leave an inch at the very top */
  164.  
  165.     /* for each scan line */
  166.     for(scanctr=0; scanctr < 720; scanctr++)  {
  167.         linebytecount = 0;
  168.  
  169.         linestart = nextcompbyte;
  170.         linecount++;
  171.         laststate = whitestateflg;
  172.  
  173.         /* capture incoming line, producing the output line */
  174.         while(linebytecount < 72)  {
  175.             countbyte = getc(stdin) & 0377;    /* count byte */
  176.             compressed[nextcompbyte++] = countbyte;
  177.             if(countbyte > 127)  {
  178.                 /* replicated bytes follow */
  179.                 countbyte = 256-countbyte+1;
  180.                  byte = getc(stdin) & 0377;
  181.                 compressed[nextcompbyte++] = byte;
  182.             }
  183.             else  {
  184.                 /* unreplicated bytes follow */
  185.                 countbyte++;
  186.                 for(ctr = 0; ctr < countbyte; ctr++)  {
  187.                     byte = getc(stdin) & 0377;
  188.                     compressed[nextcompbyte++] = byte;
  189.                 }
  190.             }
  191.             linebytecount += countbyte;
  192.         }
  193.         /* now see where we are */
  194.         whitestateflg = checkwhite(&compressed[linestart]);
  195.         /* in white, remaining white, and in white, coming from
  196.            somewhere require actions.  With others, just cumulate */
  197.         if(whitestateflg && laststate)  {
  198.             /* in white, remaining white */
  199.             nextcompbyte = 0;
  200.             linecount = 0;
  201.             lgptop -= magfactor;
  202.         }
  203.         else if(whitestateflg && !laststate)  {
  204.             /* went from stuff to white---dump bitmap */
  205.             makebitmap(stdout, compressed, lgptop, linecount-1,
  206.                 magfactor, linestart);
  207.             /* and reset for next time */
  208.             nextcompbyte = 0;
  209.             lgptop -= linecount * magfactor;
  210.             linecount = 0;
  211.         }
  212.     }
  213.  
  214.     if(!whitestateflg)  {
  215.         /* need to dump out the final buffer */
  216.         makebitmap(stdout, compressed, lgptop, linecount,
  217.             magfactor, nextcompbyte);
  218.     }
  219.  
  220.     /* put out some end of files to make the lgp happier */
  221.     for(ctr=0;ctr<100;ctr++)
  222.         dolgpeof(stdout);
  223. }
  224.  
  225.  
  226. /* dump out a bitmap */
  227. makebitmap(outf, compressed, toplgpoff, maclines, magfactor, usedbytes)
  228. FILE *outf;        /* where to put it */
  229. char compressed[];    /* input commands */
  230. int toplgpoff;        /* top of the bitmap box */
  231. int maclines;        /* how many scan lines are represented? */
  232. int magfactor;        /* correspondence between mac lines and lgp lines */
  233. int usedbytes;        /* number of bytes produced */
  234. {
  235.     int hsize;        /* expected horizontal size in words */
  236.     int vsize;        /* expected vertical size in scan lines */
  237.     int expectwords;    /* predicted number of output LGP bytes */
  238.     int outwordcount;    /* to verify against expectwords */
  239.     int scanctr;        /* count the scan lines */
  240.     int linebytecount;    /* how many bytes seen so far on
  241.                    input? 0..71 */
  242.     int compcnt;        /* count into the compressed array */
  243.     int byte;        /* incoming information */
  244.     int countbyte;        /* gives meaning of subsequent input bytes */
  245.     char outline[288];    /* max one scan line at magfactor 4 (72*4) */
  246.     int outbytecount;    /* bytes produced so far on output */
  247.     int octr;        /* output counter for display */
  248.     int ctr;        /* temporary counter */
  249.     int lgpline;        /* for use in deciding which mask to use */
  250.  
  251.     /* there are 72 *bytes* per scan line and this is expected to
  252.        turn out a complete scan line */
  253.     hsize = (72/2) * magfactor;
  254.     vsize = maclines * magfactor;
  255.  
  256.     /* one inch horizontal margin by default */
  257.     expectwords = dolgpheader(outf, hsize, vsize, 240, toplgpoff);
  258.  
  259.     outwordcount = 0;
  260.  
  261.     if(hflg)
  262.         lgpline = toplgpoff;
  263.     compcnt = 0;
  264.     /* for each scan line */
  265.     for(scanctr=0; scanctr < maclines; scanctr++)  {
  266.         linebytecount = 0;
  267.         outbytecount = 0;
  268.  
  269.         /* capture incoming line, producing the output line */
  270.         while(linebytecount < 72)  {
  271.             countbyte = compressed[compcnt++] & 0377;
  272.             if(countbyte > 127)  {
  273.                 /* replicated bytes follow */
  274.                 countbyte = 256-countbyte+1;
  275.                  byte = compressed[compcnt++] & 0377;
  276.                 for(ctr = 0; ctr < countbyte; ctr++)
  277.                     outbytecount = intoout(byte,magfactor,
  278.                         outline,outbytecount);
  279.             }
  280.             else  {
  281.                 /* unreplicated bytes follow */
  282.                 countbyte++;
  283.                 for(ctr = 0; ctr < countbyte; ctr++)  {
  284.                     byte = compressed[compcnt++] & 0377;
  285.                     outbytecount = intoout(byte,magfactor,
  286.                         outline,outbytecount);
  287.                 }
  288.             }
  289.             linebytecount += countbyte;
  290.         }
  291.  
  292.         /* display the output line */
  293.         for(ctr=0; ctr < magfactor; ctr++)  {
  294.             /* if halftoning */
  295.             if(hflg)  {
  296.                 /* pick proper mask (want to alternate them */
  297.                 if(lgpline & 01)
  298.                     curmask = OMASK;
  299.                 else
  300.                     curmask = EMASK;
  301.                 lgpline--;
  302.             }
  303.             /* generate output bytes */
  304.             for(octr=0; octr < outbytecount; octr += 2)  {
  305.                 putlgpbyte(flipbits(outline[octr])&curmask, outf);
  306.                 putlgpbyte(flipbits(outline[octr+1])&curmask, outf);
  307.                 outwordcount++;
  308.             }
  309.         }
  310.     }
  311.  
  312.     if(compcnt != usedbytes)
  313.         fprintf(stderr,"Warning, expected to use %d bytes, used %d\n",
  314.             usedbytes, compcnt);
  315.     if(expectwords != outwordcount)
  316.         fprintf(stderr,"Warning, expected %d words, sent %d\n",
  317.             expectwords, outwordcount);
  318.  
  319. }
  320.  
  321.  
  322. /* take the byte and produce an appropriate number of output bytes */
  323. int intoout(byte, magfactor, outline, outbytecount)
  324. int byte;        /* incoming byte */
  325. int magfactor;        /* how many repitions */
  326. char outline[];        /* output buffer */
  327. int outbytecount;    /* where are we in outline? */
  328. {
  329.     int bitctr;    /* count the bits in the byte */
  330.     int bit;
  331.     int magctr;    /* count down the copies */
  332.     char *cptr;    /* current character being stuffed */
  333.     int outbitctr;    /* and the bit within the character */
  334.  
  335.     /* optimization */
  336.     if(magfactor == 1)  {
  337.         outline[outbytecount] = byte;
  338.         outbytecount++;
  339.     }
  340.     else  {
  341.         /* make multiple copies of this bit */
  342.         cptr = &outline[outbytecount];
  343.         *cptr = 0;
  344.         outbitctr = 7;
  345.         for(bitctr = 7; bitctr >= 0; bitctr--)  {
  346.             bit = (byte >> bitctr) & 01;
  347.             /* replicate the bit in the output */
  348.             for(magctr=0; magctr < magfactor; magctr++)  {
  349.                 if(outbitctr < 0)  {
  350.                     /* to next output byte */
  351.                     cptr++;
  352.                     *cptr = 0;
  353.                     outbitctr = 7;
  354.                 }
  355.  
  356.                 *cptr |= (bit << outbitctr);
  357.                 outbitctr--;
  358.             }
  359.         }
  360.         outbytecount += magfactor;
  361.     }
  362.     return(outbytecount);
  363. }
  364.  
  365. /* produce the lgp header returning the expected number of bitmap bytes */
  366. int dolgpheader(outf, hsize, vsize, hoff, voff)
  367. FILE *outf;    /* where to send this stuff */
  368. int hsize;    /* expected horizontal word count */
  369. int vsize;    /* expected vertical scan line count */
  370. int hoff;    /* horizontal offset from origin */
  371. int voff;    /* vertical offset from origin */
  372. {
  373.     /* reposition to the origin */
  374.     putlgpbyte(LGPESC, outf); putlgpbyte('m', outf);
  375.     putlgpword(0, outf);    /* x */
  376.     putlgpword(0, outf);    /* y */
  377.     /* starting a bit map */
  378.     /* ESC b */
  379.     putlgpbyte(LGPESC, outf); putlgpbyte('b', outf);
  380.     /* hsize (word).  There are 72 *bytes* per scan line */
  381.     putlgpword(hsize, outf);
  382.     /* vsize (word).  There are at most 720 scan lines */
  383.     putlgpword(vsize, outf);
  384.     /* hoff (word) */
  385.     putlgpword(hoff, outf);    /* one inch offset initially */
  386.     /* voff (word) */
  387.     putlgpword(voff, outf);    /* on inch vertical offset initially */
  388.     /* hinc (word) */
  389.     putlgpword(0, outf);    /* but no change in coordinates afterwards */
  390.     /* vinc (word) */
  391.     putlgpword(0, outf);
  392.     /* bitmap follows */
  393.  
  394.     return(hsize * vsize);
  395. }
  396.  
  397. /* put out an EOF escape sequence */
  398. dolgpeof(outf)
  399. FILE *outf;
  400. {
  401.     putlgpbyte(LGPESC, outf);
  402.     putlgpbyte('e', outf);
  403. }
  404.  
  405.  
  406. /* low order, high order */
  407. putlgpword(value, outf)
  408. int value;
  409. FILE *outf;
  410. {
  411.     putc(value & 0377, outf);
  412.     putc((value >> 8) & 0377, outf);
  413. }
  414.  
  415. putlgpbyte(value, outf)
  416. int value;
  417. FILE *outf;
  418. {
  419.     putc(value & 0377, outf);
  420. }
  421.  
  422. char flipbits(oldbyte)
  423. char oldbyte;
  424. {
  425.     char newbyte;
  426.  
  427.     newbyte = 0;
  428.  
  429.     /* 7 6 5 4 3 2 1 0 */
  430.     newbyte = ((oldbyte & 01) << 7) |    /* old 0 to new 7 */
  431.           ((oldbyte & 02) << 5) |    /* old 1 to new 6 */
  432.           ((oldbyte & 04) << 3) |    /* old 2 to new 5 */
  433.           ((oldbyte & 010) << 1) |    /* old 3 to new 4 */
  434.           ((oldbyte & 020) >> 1) |    /* old 4 to new 3 */
  435.           ((oldbyte & 040) >> 3) |    /* old 5 to new 2 */
  436.           ((oldbyte & 0100) >> 5) |    /* old 6 to new 1 */
  437.           ((oldbyte & 0200) >> 7);    /* old 7 to new 0 */
  438.     return(newbyte);
  439. }
  440.  
  441.  
  442. /* see if this line is all white */
  443. int checkwhite(bytes)
  444. char *bytes;
  445. {
  446.     int countbyte;
  447.     int linebytecount;
  448.     int iswhite;
  449.     int ctr;
  450.  
  451.     iswhite = TRUE;
  452.     linebytecount = 0;
  453.  
  454.     while(iswhite && (linebytecount < 72))  {
  455.         countbyte = *bytes & 0377;
  456.         bytes++;
  457.         if(countbyte > 127)  {
  458.             /* replicated byte case */
  459.             countbyte = 256-countbyte+1;
  460.             if(*bytes)  {
  461.                 iswhite = FALSE;
  462.                 break;
  463.             }
  464.             bytes++;
  465.         }
  466.         else  {
  467.             /* unreplicated bytes follow */
  468.             countbyte++;
  469.             for(ctr = 0; ctr < countbyte; ctr++)  {
  470.                 if(*bytes)  {
  471.                     iswhite = FALSE;
  472.                     break;
  473.                 }
  474.                 bytes++;
  475.             }
  476.         }
  477.         linebytecount += countbyte;
  478.     }
  479.     return(iswhite);
  480. }
  481.  
  482.  
  483. /* =================option processing via Chris Torek@Maryland=============*/
  484. /*
  485.  * getopt - get option letter from argv
  486.  * (From Henry Spencer @ U of Toronto Zoology, slightly modified)
  487.  */
  488.  
  489. /* #include <stdio.h> */
  490.  
  491. char    *optarg;    /* Global argument pointer. */
  492. int    optind;        /* Global argv index. */
  493.  
  494. static char    *scan;    /* Private scan pointer. */
  495.  
  496. extern char    *index();
  497.  
  498. int
  499. getopt (argc, argv, optstring)
  500. register int    argc;
  501. register char **argv;
  502. char *optstring;
  503. {
  504.     register int    c;
  505.     register char  *place;
  506.  
  507.     optarg = NULL;
  508.  
  509.     if (scan == NULL || *scan == 0) {
  510.     if (optind == 0)
  511.         optind++;
  512.  
  513.     if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == 0)
  514.         return EOF;
  515.     if (strcmp (argv[optind], "--") == 0) {
  516.         optind++;
  517.         return EOF;
  518.     }
  519.  
  520.     scan = argv[optind] + 1;
  521.     optind++;
  522.     }
  523.  
  524.     c = *scan++;
  525.     place = index (optstring, c);
  526.  
  527.     if (place == NULL || c == ':') {
  528.     fprintf (stderr, "%s: unknown option -%c\n", argv[0], c);
  529.     return '?';
  530.     }
  531.  
  532.     place++;
  533.     if (*place == ':') {
  534.     if (*scan != '\0') {
  535.         optarg = scan;
  536.         scan = NULL;
  537.     }
  538.     else {
  539.         if (optind >= argc) {
  540.         fprintf (stderr, "%s: missing argument after -%c\n",
  541.             argv[0], c);
  542.         return '?';
  543.         }
  544.         optarg = argv[optind];
  545.         optind++;
  546.     }
  547.     }
  548.  
  549.     return c;
  550. }
  551.