home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / mgr / sparcmgr / misc.zoo / misc / hp_raster.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-01-24  |  8.1 KB  |  288 lines
  1. /*                        Copyright (c) 1988 Bellcore
  2.  *                            All Rights Reserved
  3.  *       Permission is granted to copy or use this program, EXCEPT that it
  4.  *       may not be sold for profit, the copyright notice must be reproduced
  5.  *       on copies, and credit should be given to Bellcore where it is due.
  6.  *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  7.  */
  8. /* Raster print filter for hp laser printer */
  9.  
  10. /***********************************************************************
  11.  * $Header: hp_raster.c,v 1.3 88/07/15 14:34:13 sau Exp $
  12.  * $Locker:  $
  13.  * $Source: /tmp/mgrsrc/misc/RCS/hp_raster.c,v $
  14.  * $Log:    hp_raster.c,v $
  15.  * Revision 1.3  88/07/15  14:34:13  sau
  16.  * Add new bitmap format (handles both formats now )
  17.  * 
  18.  * Revision 1.1  88/07/15  14:32:21  sau
  19.  * Initial revision
  20.  * 
  21.  * Revision 1.2  88/07/08  08:25:43  sau
  22.  * 
  23.  * 
  24.  * Revision 1.1  88/07/08  08:16:57  sau
  25.  * Initial revision
  26.  * 
  27.  * Revision 1.1  88/07/08  08:14:22  sau
  28.  * Initial revision
  29.  * 
  30.  * Revision 1.5  87/07/14  20:10:40  sau
  31.  * Eliminate training white space on a line by line basis
  32.  * 
  33.  * Revision 1.4  87/06/25  11:03:29  sau
  34.  * Auto scaling, lpr version
  35.  * 
  36.  ***********************************************************************/
  37.  
  38. /* avoid complaints from "lint" */
  39.  
  40. #ifndef lint
  41. static char     RCS_Id[] = "$Header: hp_raster.c,v 1.3 88/07/15 14:34:13 sau Exp $";
  42. #endif
  43. #include <stdio.h>
  44. #include "dump.h"
  45.  
  46. #define GET_OPT(i)    \
  47.     strlen(argv[i])>2 ? argv[i]+2 : argv[++i]
  48. #define WIDTH16(w)    ((((w)+15)&~0xf)>>3)        /* old bitmap format */
  49. #define WIDTH8(w)    ((w)>>3)                            /* new bitmap format */
  50. #define Min(x,y)    ((x)<(y)?(x):(y))
  51.  
  52. #define DOTS_WIDE    (8*300)        /* dots across page */
  53. #define DOTS_HIGH    (10*300+150)    /* dots down page */
  54. #define WIDE        1152        /* default # pixels/row */
  55. #define HIGH        900        /* default # rows/screen */
  56. #define HI_RES        300        /* dots per inch */
  57. #define MED_RES        150        /* dots per inch */
  58. #define LOW_RES        100        /* dots per inch */
  59. #define MIN_RES        75        /* dots per inch */
  60. #define MAX        4000        /* maximum row size */
  61. #define BORDER        3        /* default size of border */
  62. #define STRIP        3        /* white strip for viewgrqaphs */
  63.  
  64. /* printer macros */
  65.  
  66. #define set_pos(xp,yp) \
  67.     printf("\033*p%dy%dX",yp,xp)    /* set cursor position (dots) */
  68. #define set_res(res) \
  69.     printf("\033*t%dR",res)        /* set dots/inch */
  70. #define reset() \
  71.     printf("\033E")            /* reset the printer */
  72. #define manual_feed() \
  73.     printf("\033&l2H")        /* select manual feed */
  74. #define start_graphics() \
  75.     printf("\033*r1A")        /* set raster mode */
  76. #define set_row(wide) \
  77.     (printf("\033*b%dW",wide), fflush(stdout))
  78. #define end_graphics() \
  79.     printf("\033*rB")        /* end graphics mode */
  80. #define set_copies(n) \
  81.     printf("\033&l%dX",Min(n,99))    /* set copy count */
  82. #define set_rule(w,h) \
  83.     printf("\033*c%da%dB",w,h)    /* set rule size */
  84. #define print_rule(type) \
  85.     printf("\033*c%dP",type)    /* print 'type' rule */
  86.  
  87. union {
  88.     struct b_header new;
  89.     struct old_b_header old;
  90.     char type[2];
  91.     } h_buff, *head = &h_buff;
  92.  
  93. main(argc,argv)
  94. int argc;
  95. char **argv;
  96.    {
  97.    register int k,i,j=0;
  98.    int n;                /* last non-white space */
  99.    unsigned char buff[MAX/8];        /* graphics line buffer */
  100.    int wide = WIDE, high = HIGH;    /* raster size */
  101.    int no_head=0;            /* no raster header found */
  102.    int reverse=0;            /* reverse bits */
  103.    int pause = 0;            /* for vgrafs */
  104.    int manual = 0;            /* select manual feed */
  105.    int copies = 0;            /* set copy count */
  106.    int border = 0;            /* draw border around picture */
  107.    int res = MED_RES;            /* resolution dots/in */
  108.    int force_res=0;            /* force resolution */
  109.    int x0,y0;                /* starting raster coord */
  110.    int x=0,y=0;                    /* user supplied coords */
  111.    int bytes;                /* raster line size */
  112.     int depth=1;            /* bitmap depth */
  113.     char type[2];            /* bitmap type */
  114.  
  115.    /* check arguments */
  116.  
  117.    for(i=1;i<argc;i++) {
  118.       if (*argv[i] == '-')
  119.          switch (argv[i][1]) {
  120.             case 'X':                /* x coord */
  121.                x = atoi(GET_OPT(i));
  122.                break;
  123.             case 'Y':                /* y coord */
  124.                y = atoi(GET_OPT(i));
  125.                break;
  126.             case 'r':                /* reverse bits */
  127.                force_res = atoi(GET_OPT(i));
  128.                break;
  129.             case 'm':                /* set manual feed */
  130.                manual++;
  131.                break;
  132.             case 'n':                /* login (from lpd )*/
  133.                GET_OPT(i);
  134.                break;
  135.             case 'h':                /*  host (from lpd) */
  136.                GET_OPT(i);
  137.                break;
  138.             case 'y':                /* specify border- for lpd */
  139.                border = Min(32,atoi(GET_OPT(i)));
  140.                break;
  141.             case 'b':                /* set border size */
  142.                if (argv[i][2])
  143.                   border = atoi(&argv[i][2]);
  144.                else
  145.                   border = BORDER;
  146.                break;
  147.             case 'c':                /* set copies */
  148.                copies = atoi(GET_OPT(i));
  149.                break;
  150.             case 'p':                /* set pause */
  151.             case 'x':                /* for lpd */
  152.                pause = atoi(GET_OPT(i));
  153.                break;
  154.             default:
  155.                fprintf(stderr,"%s: bad flag %c ignored\n",argv[0],argv[i][1]);
  156.             }
  157.       }
  158.  
  159.    /* get header */
  160.  
  161.    if (!no_head) {
  162.       read(0,head->type,2);                /* get magic number */
  163.       if (B_ISHDR16(&head->old)) {        /* old style header */
  164.          read(0,head->type+2,B_OHSIZE-2);
  165.          B_GETOLDHDR(&head->old,wide,high);
  166.            bytes = WIDTH16(wide);
  167.             }
  168.         else if (B_ISHDR8(&head->new)) {        /* new style header */
  169.          read(0,head->type+2,B_HSIZE-2);
  170.          B_GETHDR8(&head->new,wide,high,depth);
  171.            bytes = WIDTH8(wide);
  172.             }
  173.       else {        /* assume 16 bit alignment , no header */
  174.          wide=WIDE,high=HIGH-1;
  175.          Read(0,buff,WIDTH16(wide)-2);        /* oops ! lose 1st line */
  176.            bytes = WIDTH16(wide);
  177.          }
  178.       }
  179.  
  180.     if (depth != 1) {
  181.         fprintf(stderr,"Sorry, Can\'t handle 8-bit pixels\n");
  182.         exit(0);
  183.         }
  184.  
  185.    /* compute appropriate resolution */
  186.  
  187.    switch(Min(DOTS_WIDE/(border+wide),DOTS_HIGH/(border+high))) {
  188.       case 0:        /* picture too big, use hi-res and go */
  189.          /* no break - for now */
  190.       case 1:
  191.          res = HI_RES;
  192.          break;
  193.       case 2:
  194.          res = MED_RES;
  195.          break;
  196.       case 3:
  197.          res = LOW_RES;
  198.          break;
  199.       default:
  200.          res = MIN_RES;
  201.          break;
  202.       }
  203.  
  204.    if (force_res)
  205.       res = force_res;
  206.  
  207.    /* center picture */
  208.  
  209.    if (pause>1)             /* skip white strip for viewgraphs */
  210.       x0 = (DOTS_WIDE-HI_RES*wide/res);
  211.    else
  212.       x0 = (DOTS_WIDE-HI_RES*wide/res)/2;
  213.    y0 = (DOTS_HIGH-HI_RES*high/res)/2;
  214.  
  215.    if (x>0)
  216.       x0 = x;
  217.    if (y>0)
  218.       y0 = y;
  219.  
  220.    fprintf(stderr,"printing raster %dx%d at %d,%d - %d dots/in%s\n",
  221.             wide,high,x0,y0,res,border ? " (bordered)":"");
  222.  
  223.    /* setup printer */
  224.  
  225.    reset();                    /* reset the printer */
  226.    if (pause || manual) 
  227.         manual_feed();                /* select manual feed */
  228.    if (copies)
  229.         set_copies(copies);            /* set copy count */
  230.    set_pos(x0,y0);                /* set starting position */
  231.    set_res(res);                /* set resolution */
  232.    start_graphics();                /* start graphics */
  233.  
  234.    for (i=0;i<high;i++) {
  235.       Read(0,buff,bytes);
  236.       for(j=bytes;j>0 && buff[j-1]==0;j--); 
  237.       set_row(j);
  238.       write(1,buff,j);
  239.       }
  240.    end_graphics();
  241.  
  242.    /* draw borders */
  243.  
  244.    if (border) {
  245.       set_rule(border,2*border+high*HI_RES/res);
  246.       set_pos(x0-border,y0-border);
  247.       print_rule(0);                /* left edge */
  248.       set_pos(x0+wide*HI_RES/res,y0-border);
  249.       print_rule(0);                /* right edge */
  250.  
  251.       set_rule(wide*HI_RES/res,border);
  252.       set_pos(x0,y0-border);
  253.       print_rule(0);                /* top edge */
  254.       set_pos(x0,y0+high*HI_RES/res);
  255.       print_rule(0);                /* bottom edge */
  256.       }
  257.  
  258.    printf("\n\f");
  259.    exit(0);
  260.    }
  261.  
  262. /* do multiple passes for read */
  263.  
  264. Read(fd,buff,count)
  265. int fd,count;
  266. register char *buff;
  267.    {
  268.    register int sum=0,current=0;
  269.  
  270.    while((current = read(0,buff+sum,count-sum))>0)
  271.       sum += current;
  272.    return(sum);
  273.    }
  274.  
  275. /* return index of 1st non zero byte, or bytes if entirely blank */
  276.  
  277. int
  278. first(buff,bytes)
  279. register char *buff;
  280. register int bytes;
  281.    {
  282.    char *start = buff+1;
  283.    while(bytes-- > 0)
  284.       if (*buff++) 
  285.          break;
  286.    return(buff-start);
  287.    }
  288.