home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / GRAPHICS / PSCRIPT / GS23A.ZIP / MYDEVEPS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-12  |  13.7 KB  |  382 lines
  1. /* Copyright (C) 1989, 1990, 1991 Aladdin Enterprises.  All rights reserved.
  2.    Distributed by Free Software Foundation, Inc.
  3.  
  4. This file is part of Ghostscript.
  5.  
  6. Ghostscript is distributed in the hope that it will be useful, but
  7. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  8. to anyone for the consequences of using it or for whether it serves any
  9. particular purpose or works at all, unless he says so in writing.  Refer
  10. to the Ghostscript General Public License for full details.
  11.  
  12. Everyone is granted permission to copy, modify and redistribute
  13. Ghostscript, but only under the conditions described in the Ghostscript
  14. General Public License.  A copy of this license is supposed to have been
  15. given to you along with Ghostscript so you can know your rights and
  16. responsibilities.  It should be in a file named COPYING.  Among other
  17. things, the copyright notice and this notice must be preserved on all
  18. copies.  */
  19.  
  20. /* gdevepsn.c */
  21. /* Epson dot-matrix printer driver for Ghostscript */
  22. #include "gdevprn.h"
  23. /******
  24.  * For 9-pin printers, you may select
  25.  *   X_DPI = 60, 120, or 240
  26.  *   Y_DPI = 60 or 72
  27.  * For 24-pin printers, you may select
  28.  *   X_DPI = 60, 120, 180, 240, or 360
  29.  *   Y_DPI = 60, 72, 180, or 216
  30.  * Note that a given printer implements *either* Y_DPI = 60 | 180 *or*
  31.  * Y_DPI = 72 | 216; no attempt is made to check this here.
  32.  * Note that X_DPI = 180 or 360 requires Y_DPI > 100;
  33.  * this isn't checked either.  Finally, note that X_DPI=240 and
  34.  * X_DPI=360 are double-density modes requiring two passes to print.
  35.  *
  36.  * The values of X_DPI and Y_DPI may be set at compile time:
  37.  * see gdevs.mak.
  38.  * 
  39.  * At some time in the future, we could simulate 24-bit output on
  40.  * 9-pin printers by using fractional vertical positioning;
  41.  * we could even implement an X_DPI=360 mode by using the
  42.  * ESC++ command that spaces vertically in units of 1/360"
  43.  * (not supported on many printers.)
  44.  ******/
  45.  
  46. #ifndef Y_DPI
  47. #  define Y_DPI 60
  48. #endif
  49.  
  50. /* The device descriptors */
  51. private dev_proc_print_page(eps_print_page1);
  52. private dev_proc_print_page(eps_print_page2);
  53.  
  54. gx_device_printer gs_eps9_device =
  55.   prn_device(prn_std_procs, "eps9",
  56.         85,                             /* width_10ths, 8.5" */
  57.         110,                            /* height_10ths, 11" */
  58.         240, Y_DPI,
  59.         0, 0, 0.5, 0,           /* margins */
  60.         1, eps_print_page1);
  61.  
  62. gx_device_printer gs_eps9draft_device =
  63.   prn_device(prn_std_procs, "eps9draft",
  64.         85,                             /* width_10ths, 8.5" */
  65.         110,                            /* height_10ths, 11" */
  66.         120, Y_DPI,
  67.         0, 0, 0.5, 0,           /* margins */
  68.         1, eps_print_page1);
  69.  
  70. gx_device_printer gs_eps9high_device = 
  71.   prn_device(prn_std_procs, "eps9high",
  72.         85,                             /* width_10ths, 8.5" */
  73.         110,                            /* height_10ths, 11" */
  74.         240, 3*Y_DPI,
  75.         0, 0, 0.5, 0,           /* margins */
  76.         1, eps_print_page2);
  77.  
  78. gx_device_printer gs_eps24_device =
  79.   prn_device(prn_std_procs, "eps24",
  80.         85,                             /* width_10ths, 8.5" */
  81.         110,                            /* height_10ths, 11" */
  82.         360, 3*Y_DPI,
  83.         0, 0, 0.5, 0,           /* margins */
  84.         1, eps_print_page1);
  85.  
  86. gx_device_printer gs_eps24draft_device =
  87.   prn_device(prn_std_procs, "eps24draft",
  88.         85,                             /* width_10ths, 8.5" */
  89.         110,                            /* height_10ths, 11" */
  90.         180, 3*Y_DPI,
  91.         0, 0, 0.5, 0,           /* margins */
  92.         1, eps_print_page1);
  93.  
  94. /* ------ Internal routines ------ */
  95.  
  96. /* Forward references */
  97. private void eps_output_run(P6(byte *, int, int, char, FILE *, int));
  98.  
  99. /* Send the page to the printer. */
  100. #define DD 0x80                         /* double density flag */
  101. private int
  102. eps_print_page(gx_device_printer *pdev, FILE *prn_stream, int y_9pin_high)
  103. {       
  104.     static char graphics_modes_9[5] =
  105.     {   
  106.         -1, 0 /*60*/, 1 /*120*/, -1, DD+3 /*240*/
  107.     };
  108.     static char graphics_modes_24[7] =
  109.     {   
  110.         -1, 32 /*60*/, 33 /*120*/, 39 /*180*/,
  111.         -1, -1, DD+40 /*360*/
  112.     };
  113.     int y_24pin = y_9pin_high ? 0 : pdev->y_pixels_per_inch > 72;
  114.     int in_y_mult = ((y_24pin || y_9pin_high) ? 3 : 1);
  115.     int line_size = gdev_mem_bytes_per_scan_line((gx_device *)pdev);
  116.     int in_size = line_size * (8 * in_y_mult);
  117.     byte *in = (byte *)gs_malloc(in_size, 1, "eps_print_page(in)");
  118.     byte *mid = (byte *)gs_malloc(in_size, 1, "eps_print_page(mid)");
  119.     int out_y_mult = (y_24pin ? 3 : 1);
  120.     int out_size = ((pdev->width + 7) & -8) * out_y_mult;
  121.     byte *out = (byte *)gs_malloc(out_size, 1, "eps_print_page(out)");
  122.     int x_dpi = pdev->x_pixels_per_inch;
  123.     char start_graphics =
  124.         (y_24pin ? graphics_modes_24 : graphics_modes_9)[x_dpi / 60];
  125.     int first_pass = (start_graphics & DD ? 1 : 0);
  126.     int last_pass = first_pass * 2;
  127.     int y_passes = (y_9pin_high ? 3 : 1);
  128.     int dots_per_space = x_dpi / 10;    /* pica space = 1/10" */
  129.     int bytes_per_space = dots_per_space * out_y_mult;
  130.     int skip = 0, lnum = 0, pass, ypass;
  131.  
  132.     /* Check allocations */
  133.     if ( in == 0 || out == 0 || mid == 0 )
  134.     {   
  135.         if ( in ) 
  136.         {
  137.             gs_free((char *)in, in_size, 1, "eps_print_page(in)");
  138.         }
  139.         if ( mid ) 
  140.         {
  141.             gs_free((char *)mid, in_size, 1, "eps_print_page(mid)");
  142.         }
  143.         if ( out ) 
  144.         {
  145.             gs_free((char *)out, out_size, 1, "eps_print_page(out)");
  146.         }
  147.         return -1;
  148.     }
  149.  
  150.     /* Initialize the printer and reset the margins. */
  151.     fwrite("\033@\033P\033l\000\033Q\377\r", 1, 11, prn_stream);
  152.     
  153.     /* Print lines of graphics */
  154.     while ( lnum < pdev->height )
  155.     {   
  156.         byte *inp;
  157.         byte *in_end;
  158.         byte *out_end;
  159.         byte *out_blk;
  160.         register byte *outp;
  161.         int lcnt;
  162.     
  163.         /* Copy 1 scan line and test for all zero. */
  164.         gdev_prn_copy_scan_lines(pdev, lnum, in, line_size);
  165.         if ( in[0] == 0 &&
  166.              !memcmp((char *)in, (char *)in + 1, line_size - 1) )
  167.         {       
  168.             lnum++;
  169.             skip += 3 / in_y_mult;
  170.             continue;
  171.         }
  172.     
  173.         /* Vertical tab to the appropriate position. */
  174.         while ( skip > 255 )
  175.         {       
  176.             fputs("\033J\377", prn_stream);
  177.             skip -= 255;
  178.         }
  179.         if ( skip )
  180.         {
  181.             fprintf(prn_stream, "\033J%c", skip);
  182.         }
  183.     
  184.         /* Copy the rest of the scan lines. */
  185.         lcnt = 1 + gdev_prn_copy_scan_lines(pdev, lnum + 1, in + line_size, 
  186.                                             in_size - line_size);
  187.         if ( lcnt < 8 * in_y_mult )
  188.         {
  189.             memset(in + lcnt * line_size, 0,
  190.                    in_size - lcnt * line_size);
  191.         }
  192.  
  193.         if ( y_9pin_high )
  194.         {
  195.             byte *p;
  196.             int i;
  197.             static char index[] = {  0,  8, 16,  1,  9, 17,  
  198.                                      2, 10, 18,  3, 11, 19,
  199.                                      4, 12, 20,  5, 13, 21,
  200.                                      6, 14, 22,  7, 15, 23};
  201.  
  202.             for ( i = 0; i < 24; i++ )
  203.             {
  204.                 memmove(mid+(index[i]*line_size), in+(i*line_size), line_size);
  205.             }
  206.             p = in;
  207.             in = mid;
  208.             mid = p;
  209.         }
  210.  
  211.         for ( ypass = 0; ypass < y_passes; ypass++ )
  212.         {
  213.             for ( pass = first_pass; pass <= last_pass; pass++ )
  214.             {
  215.                 /* We have to 'transpose' blocks of 8 pixels x 8 lines, */
  216.                 /* because that's how the printer wants the data. */
  217.                 /* If we are in a 24-pin mode, we have to transpose */
  218.                 /* groups of 3 lines at a time. */
  219.         
  220.                 if ( ( pass == 0 ) || ( pass == 1 ) )
  221.                 {
  222.                     out_end = out;
  223.                     inp = in;
  224.                     in_end = inp + line_size;
  225.     
  226.                     if ( y_24pin )
  227.                     { 
  228.                         for ( ; inp < in_end; inp++, out_end += 24 )
  229.                         { 
  230.                             gdev_prn_transpose_8x8(inp, line_size, out_end, 3);
  231.                             gdev_prn_transpose_8x8(inp + line_size * 8, 
  232.                                                    line_size, out_end + 1, 3);
  233.                             gdev_prn_transpose_8x8(inp + line_size * 16, 
  234.                                                    line_size, out_end + 2, 3);
  235.                         }
  236.                         /* Remove trailing 0s. */
  237.                         while ( out_end > out && out_end[-1] == 0 &&
  238.                                 out_end[-2] == 0 && out_end[-3] == 0)
  239.                         {
  240.                             out_end -= 3;
  241.                         }
  242.                     }
  243.                     else
  244.                     { 
  245.                         for ( ; inp < in_end; inp++, out_end += 8 )
  246.                         { 
  247.                             gdev_prn_transpose_8x8(inp + (ypass * 8*line_size), 
  248.                                                    line_size, out_end, 1);
  249.                         }
  250.                         /* Remove trailing 0s. */
  251.                         while ( out_end > out && out_end[-1] == 0 )
  252.                         {
  253.                             out_end--;
  254.                         }
  255.                     }
  256.                 }
  257.     
  258.                 for ( out_blk = outp = out; outp < out_end; )
  259.                 { 
  260.                     /* Skip a run of leading 0s. */
  261.                     /* At least 10 are needed to make tabbing */
  262.                     /* worth it.  We do everything by 3's to */
  263.                     /* avoid having to make different cases */
  264.                     /* for 9- and 24-pin. */
  265.             
  266.                     if ( *outp == 0 && outp + 12 <= out_end &&
  267.                          outp[1] == 0 && outp[2] == 0 &&
  268.                          (outp[3] | outp[4] | outp[5]) == 0 &&
  269.                          (outp[6] | outp[7] | outp[8]) == 0 &&
  270.                          (outp[9] | outp[10] | outp[11]) == 0 )
  271.                     {
  272.                         byte *zp = outp;
  273.                         int tpos;
  274.                         byte *newp;
  275.            
  276.                         outp += 12;
  277.                         while ( outp + 3 <= out_end && 
  278.                                 *outp == 0 &&
  279.                                 outp[1] == 0 && outp[2] == 0 )
  280.                         {
  281.                             outp += 3;
  282.                         }
  283.                         tpos = (outp - out) / bytes_per_space;
  284.                         newp = out + tpos * bytes_per_space;
  285.                         if ( newp > zp + 10 )
  286.                         { 
  287.                             /* Output preceding bit data.*/
  288.                             if ( zp > out_blk ) 
  289.                             {
  290.                                 /* only false at beginning of line */
  291.                                 eps_output_run(out_blk, (int)(zp - out_blk),
  292.                                                out_y_mult, start_graphics, 
  293.                                                prn_stream, pass);
  294.                             }
  295.                             /* Tab over to the appropriate position. */
  296.                             fprintf(prn_stream, "\033D%c%c\t", tpos, 0);
  297.                             out_blk = outp = newp;
  298.                         }
  299.                     }
  300.                     else
  301.                     {
  302.                         outp += out_y_mult;
  303.                     }
  304.                 }
  305.                 if ( outp > out_blk )
  306.                 {
  307.                     eps_output_run(out_blk, (int)(outp - out_blk),
  308.                                    out_y_mult, start_graphics,
  309.                                    prn_stream, pass);
  310.                 }
  311.     
  312.                 fputc('\r', prn_stream);
  313.             }
  314.             fputs("\033J\001", prn_stream);
  315.         }
  316.         skip = 24 - y_passes;
  317.         lnum += 8 * in_y_mult;
  318.     }
  319.  
  320.     /* Eject the page and reinitialize the printer */
  321.     fputs("\f\033@", prn_stream);
  322.  
  323.     gs_free((char *)out, out_size, 1, "eps_print_page(out)");
  324.     gs_free((char *)mid, in_size, 1, "eps_print_page(mid)");
  325.     gs_free((char *)in, in_size, 1, "eps_print_page(in)");
  326.     return 0;
  327. }
  328.  
  329. /* Output a single graphics command. */
  330. /* pass=0 for all columns, 1 for even columns, 2 for odd columns. */
  331. private void
  332. eps_output_run(byte *data, int count, int y_mult,
  333.                char start_graphics, FILE *prn_stream, int pass)
  334. {       
  335.     int xcount = count / y_mult;
  336.  
  337.     fputc(033, prn_stream);
  338.     if ( !(start_graphics & ~3) )
  339.     {   
  340.         fputc("KLYZ"[start_graphics], prn_stream);
  341.     }
  342.     else
  343.     {   
  344.         fputc('*', prn_stream);
  345.         fputc(start_graphics & ~DD, prn_stream);
  346.     }
  347.     fputc(xcount & 0xff, prn_stream);
  348.     fputc(xcount >> 8, prn_stream);
  349.     if ( !pass )
  350.     {
  351.         fwrite((char *)data, 1, count, prn_stream);
  352.     }
  353.     else
  354.     {   
  355.         /* Only write every other column of y_mult bytes. */
  356.         int which = pass;
  357.         register byte *dp = data;
  358.         register int i, j;
  359.  
  360.         for ( i = 0; i < xcount; i++, which++ )
  361.         {
  362.             for ( j = 0; j < y_mult; j++, dp++ )
  363.             {
  364.                 putc(((which & 1) ? *dp : 0), prn_stream);
  365.             }
  366.         }
  367.     }
  368. }
  369.  
  370. private int
  371. eps_print_page1(gx_device_printer *pdev, FILE *prn_stream)
  372. {
  373.     return(eps_print_page(pdev, prn_stream, 0));
  374. }
  375.  
  376. private int
  377. eps_print_page2(gx_device_printer *pdev, FILE *prn_stream)
  378. {
  379.     return(eps_print_page(pdev, prn_stream, 1));
  380. }
  381.  
  382.