home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / ap / ghostscr / gdevlinu.c / gdevlinux.c
Encoding:
C/C++ Source or Header  |  1995-05-02  |  15.0 KB  |  457 lines
  1. /* Copyright (C) 1992 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. /*
  21.  * gdevlinux.c
  22.  *
  23.  * This is a driver for 386 PCs using VGALIB for graphics on the console 
  24.  * display.
  25.  *
  26.  * Written by Sigfrid Lundberg, siglun@euler.teorekol.lu.se.
  27.  *
  28.  * Support for all the SVGAlib video modes, MAGSTEP, XO, YO, and additions
  29.  * to the gs.1 man page by Patrick Volkerding, volkerdi@mhd1.moorhead.msus.edu.
  30.  *
  31.  */
  32.  
  33. #include "gx.h"
  34. #include "gxdevice.h"
  35. #include "gserrors.h"
  36.  
  37. #include <errno.h>
  38. #include <vga.h>
  39.  
  40. extern char svgalib_detected;
  41. extern char video_resolution[25];
  42. extern float size_multiplier; 
  43. extern float adjust_xo;
  44. extern float adjust_yo;
  45. extern char xo_units;
  46. extern char yo_units;
  47.  
  48. int screen_width, screen_height;
  49. int xorigin, yorigin;
  50.  
  51. typedef struct gx_device_linux {
  52.     gx_device_common;
  53.     int fd;                    /* window file descriptor */
  54.     uchar *screen;             /* pointer to screen image */
  55.     ushort line_size;          /* size of single screen line in bytes */
  56.     ulong screen_size;         /* size of screen image in bytes */
  57.     int screen_width, screen_height; /* size of screen used */
  58.     int page;                  /* page number */
  59. #ifdef LINUX_PERF
  60.     char *no_output, *no_fill, *no_copy;
  61. #endif
  62. } gx_device_linux;
  63. #define linuxdev ((gx_device_linux *)dev)
  64.  
  65. #define XDPI   60              /* to get a more-or-less square aspect ratio */
  66. #define YDPI   60
  67.  
  68. #ifndef A4 /*Letter size*/
  69. #define YSIZE (20.0 * YDPI / 2.5))
  70. #define XSIZE (8.5 / 11)*YSIZE /* 8.5 x 11 inch page, by default */
  71. #else  /* A4 paper */
  72. #define XSIZE 8.27
  73. #define YSIZE 11.69 
  74. #endif
  75.  
  76. dev_proc_open_device(linux_open);
  77. dev_proc_close_device(linux_close);
  78. dev_proc_draw_line(linux_draw_line);
  79. dev_proc_fill_rectangle(linux_fill_rectangle);
  80. dev_proc_tile_rectangle(linux_tile_rectangle);
  81. dev_proc_map_color_rgb(linux_map_color_rgb);
  82. dev_proc_map_rgb_color(linux_map_rgb_color);
  83. dev_proc_copy_mono(linux_copy_mono);
  84. dev_proc_copy_color(linux_copy_color);
  85.  
  86.  
  87.  
  88. private gx_device_procs linux_procs = {
  89.     linux_open,
  90.     gx_default_get_initial_matrix,
  91.     gx_default_sync_output,
  92.     gx_default_output_page,
  93.     linux_close,
  94.     linux_map_rgb_color,
  95.     linux_map_color_rgb,
  96.     linux_fill_rectangle,
  97.     linux_tile_rectangle,
  98.     linux_copy_mono,
  99.     linux_copy_color,
  100.     linux_draw_line,
  101.     gx_default_get_bits,
  102.     gx_default_get_props,
  103.     gx_default_put_props
  104. };
  105.  
  106. gx_device_linux gs_linux_device = {
  107.     sizeof(gx_device_linux),
  108.     &linux_procs,
  109.     "linux",
  110.     0,0,
  111.     1,1,
  112.     no_margins,
  113.     dci_black_and_white,
  114.     0
  115. };
  116.  
  117. int
  118. linux_open(gx_device *dev)
  119. {
  120.   if (!strcmp(video_resolution,"320x200x16") || !strcmp(video_resolution,"1")) {
  121.     vga_setmode(1);
  122.   } else if (!strcmp(video_resolution,"640x200x16") || !strcmp(video_resolution,"2")) {
  123.     vga_setmode(2);
  124.   } else if (!strcmp(video_resolution,"640x350x16") || !strcmp(video_resolution,"3")) {
  125.     vga_setmode(3);
  126.   } else if (!strcmp(video_resolution,"640x480x16") || !strcmp(video_resolution,"4")) {
  127.     vga_setmode(4);
  128.   } else if (!strcmp(video_resolution,"320x200x256") || !strcmp(video_resolution,"5")) {
  129.     vga_setmode(5);
  130.   } else if (!strcmp(video_resolution,"320x240x256") || !strcmp(video_resolution,"6")) {
  131.     vga_setmode(6);
  132.   } else if (!strcmp(video_resolution,"320x400x256") || !strcmp(video_resolution,"7")) {
  133.     vga_setmode(7);
  134.   } else if (!strcmp(video_resolution,"360x480x256") || !strcmp(video_resolution,"8")) {
  135.     vga_setmode(8);
  136.   } else if (!strcmp(video_resolution,"640x480x2") || !strcmp(video_resolution,"9")) {
  137.     vga_setmode(9);
  138.   } else if (!strcmp(video_resolution,"640x480x256") || !strcmp(video_resolution,"10")) {
  139.     vga_setmode(10);
  140.   } else if (!strcmp(video_resolution,"800x600x256") || !strcmp(video_resolution, "11")) {
  141.     vga_setmode(11);
  142.   } else if (!strcmp(video_resolution,"1024x768x256") || !strcmp(video_resolution,"12")) {
  143.     vga_setmode(12);
  144.   } else if (!strcmp(video_resolution,"320x200x32K") || !strcmp(video_resolution,"13")) {
  145.     vga_setmode(13);
  146.   } else if (!strcmp(video_resolution,"320x200x64K") || !strcmp(video_resolution,"14")) {
  147.     vga_setmode(14);
  148.   } else if (!strcmp(video_resolution,"320x200x16M") || !strcmp(video_resolution,"15")) {
  149.     vga_setmode(15);
  150.   } else if (!strcmp(video_resolution,"640x480x32K") || !strcmp(video_resolution,"16")) {
  151.     vga_setmode(16);
  152.   } else if (!strcmp(video_resolution,"640x480x64K") || !strcmp(video_resolution,"17")) {
  153.     vga_setmode(17);
  154.   } else if (!strcmp(video_resolution,"640x480x16M") || !strcmp(video_resolution,"18")) {
  155.     vga_setmode(18);
  156.   } else if (!strcmp(video_resolution,"800x600x32K") || !strcmp(video_resolution,"19")) {
  157.     vga_setmode(19);
  158.   } else if (!strcmp(video_resolution,"800x600x64K") || !strcmp(video_resolution,"20")) {
  159.     vga_setmode(20);
  160.   } else if (!strcmp(video_resolution,"800x600x16M") || !strcmp(video_resolution,"21")) {
  161.     vga_setmode(21);
  162.   } else if (!strcmp(video_resolution,"1024x768x32K") || !strcmp(video_resolution,"22")) {
  163.     vga_setmode(22);
  164.   } else if (!strcmp(video_resolution,"1024x768x64K") || !strcmp(video_resolution,"23")) {
  165.     vga_setmode(23);
  166.   } else if (!strcmp(video_resolution,"1024x768x16M") || !strcmp(video_resolution,"24")) {
  167.     vga_setmode(24);
  168.   } else if (!strcmp(video_resolution,"1280x1024x256") || !strcmp(video_resolution,"25")) {
  169.     vga_setmode(25);
  170.   } else if (!strcmp(video_resolution,"1280x1024x32K") || !strcmp(video_resolution,"26")) {
  171.     vga_setmode(26);
  172.   } else if (!strcmp(video_resolution,"1280x1024x64K") || !strcmp(video_resolution,"27")) {
  173.     vga_setmode(27);
  174.   } else if (!strcmp(video_resolution,"1280x1024x16M") || !strcmp(video_resolution,"28")) {
  175.     vga_setmode(28);
  176.   } else if (!strcmp(video_resolution,"720x350x16") || !strcmp(video_resolution,"29")) {
  177.     vga_setmode(29);
  178.   } else if (!strcmp(video_resolution,"720x480x16") || !strcmp(video_resolution,"30")) {
  179.     vga_setmode(30);
  180.   } else {
  181.     fprintf(stdout,"Sorry, but %s is not a recognized SVGAlib mode.\n\n",video_resolution);
  182.     fprintf(stdout,"These are the recognized video modes, (and mode numbers):\n");
  183.     fprintf(stdout," 320x200x16 (1), 640x200x16 (2), 640x350x16 (3), 640x480x16 (4), \n");
  184.     fprintf(stdout," 320x200x256 (5), 320x240x256 (6), 320x400x256 (7), 360x480x256 (8), \n");
  185.     fprintf(stdout," 640x480x2 (9), 640x480x256 (10), 800x600x256 (11), 1024x768x256 (12), \n");
  186.     fprintf(stdout," 320x200x32K (13), 320x200x64K (14), 320x200x16M (15), 640x480x32K (16), \n");
  187.     fprintf(stdout," 640x480x64K (17), 640x480x16M (18), 800x600x32K (19), 800x600x64K (20), \n");
  188.     fprintf(stdout," 800x600x16M (21), 1024x768x32K (22), 1024x768x64K (23), 1024x768x16M (24), \n");
  189.     fprintf(stdout," 1280x1024x256 (25), 1280x1024x32K (26), 1280x1024x64K (27), \n");
  190.     fprintf(stdout," 1280x1024x16M (28), 720x350x16 (29), 720x480x16 (30), \n");
  191.     fprintf(stdout,"\n");
  192.     fprintf(stdout,"In addition to -r<resolution>, these flags also work with -sDEVICE=linux:\n");
  193.     fprintf(stdout,"\n");
  194.     fprintf(stdout,"  -dMAGSTEP=<value> : Change the image size. Values 0.0 < value < 1.0 shrink\n");
  195.     fprintf(stdout,"       the image size, while values > 1.0 expand it. The default value is 1.0.\n");
  196.     fprintf(stdout,"\n");
  197.     fprintf(stdout,"  -dXO=<value>[units], -dYO=<value>[units] : Specify a new origin. The upper-\n");
  198.     fprintf(stdout,"       left hand corner of the image is considered to be (0,0). You may move\n");
  199.     fprintf(stdout,"       the origin down and/or right using these flags. The default unit of \n");
  200.     fprintf(stdout,"       measurement is inches (in), but you may also use centimeters (cm), or\n");
  201.     fprintf(stdout,"       percent (%%) of distance from the origin (0%% - 100%%).\n");
  202.     exit(1);
  203.   }
  204.   fprintf(stdout,"\nSelected SVGAlib resolution: %s\n",video_resolution);
  205.   vga_clear();
  206.   if ( dev->width == 0 )
  207.     dev->width = vga_getxdim() * size_multiplier; /* + 1; */
  208.     screen_width = vga_getxdim();
  209.   if ( dev->height == 0 )
  210.     dev->height = vga_getydim() * size_multiplier; /* + 1; */
  211.     screen_height = vga_getydim();
  212.  
  213.   /*vgalib provides no facilities for finding out aspect ratios*/
  214.   if ( dev->y_pixels_per_inch == 1 ) {
  215.     dev->y_pixels_per_inch = dev->height / 11.0;
  216.     dev->x_pixels_per_inch = dev->y_pixels_per_inch;
  217.     if (xo_units == 'c') adjust_xo /= 2.58;
  218.     if (yo_units == 'c') adjust_yo /= 2.58;
  219.     if (xo_units == '%') {
  220.       if (adjust_xo < 0) adjust_xo = 0;
  221.       if (adjust_xo > 100) adjust_xo = 100;
  222.       adjust_xo = 8.5 * (adjust_xo/100);
  223.     }
  224.     if (yo_units == '%') {
  225.       if (adjust_yo < 0) adjust_yo = 0;
  226.       if (adjust_yo > 100) adjust_yo = 100;
  227.       adjust_yo = 11 * (adjust_yo/100);
  228.     }
  229.     xorigin = dev->x_pixels_per_inch * adjust_xo;
  230.     yorigin = dev->y_pixels_per_inch * adjust_yo;
  231.   }
  232.  
  233.   /* Find out if the device supports color */
  234.   /* (default initialization is monochrome). */
  235.   /* We only recognize 16-color devices right now. */
  236.   if ( vga_getcolors() > 1 ) {
  237.    
  238.     int index,one,rgb[3];
  239.  
  240.     static gx_device_color_info linux_16color = dci_color(4, 2, 3);
  241.     dev->color_info = linux_16color;  
  242.  
  243.     for(index=0;index<gx_max_color_value;index++) {
  244.       one = (index & 8 ? gx_max_color_value : gx_max_color_value / 3);
  245.       rgb[0] = (index & 4 ? one : 0);
  246.       rgb[1] = (index & 2 ? one : 0);
  247.       rgb[2] = (index & 1 ? one : 0);
  248.       vga_setpalette((int)index, rgb[0], rgb[1], rgb[2]);
  249.     }
  250.   }
  251.  
  252.   return 0;
  253. }
  254.  
  255. int
  256. linux_close(gx_device *dev)
  257. {
  258.   vga_getch();
  259.   vga_setmode(TEXT);
  260.   return 0;
  261. }
  262.  
  263. gx_color_index
  264. linux_map_rgb_color(gx_device *dev, gx_color_value red, gx_color_value green,
  265.                    gx_color_value blue)
  266. {
  267.   int index;
  268.  
  269.   index=((red > gx_max_color_value / 4 ? 4 : 0) +
  270.         (green > gx_max_color_value / 4 ? 2 : 0) +
  271.         (blue > gx_max_color_value / 4 ? 1 : 0) +
  272.         (red > gx_max_color_value / 4 * 3 ||
  273.          green > gx_max_color_value / 4 * 3 ? 8 : 0));
  274.  
  275.   return (gx_color_index)index;
  276. }
  277.  
  278.  
  279. /* I actually don't understand what I'm doing -- the only thing I want to
  280. achieve are palettes that emulates BGI */
  281. int
  282. linux_map_color_rgb(gx_device *dev, gx_color_index index, 
  283.                    unsigned short rgb[3])
  284. {  
  285.   int red, green, blue;
  286.   gx_color_value one = 
  287.     (index & 8 ? gx_max_color_value : gx_max_color_value / 3);
  288.   rgb[0] = (index & 4 ? one : 0);
  289.   rgb[1] = (index & 2 ? one : 0);
  290.   rgb[2] = (index & 1 ? one : 0);
  291.  
  292.   return 0;
  293. }
  294.  
  295. void
  296. adj_vga_drawpixel(int x, int y)
  297. {
  298.   y -= yorigin;
  299.   x -= xorigin;
  300.   if (x < 0 || x >= screen_width || y < 0 || y >= screen_height) return;
  301.   vga_drawpixel(x,y);
  302. }
  303.  
  304. void
  305. adj_vga_drawline(int x1, int y1, int x2, int y2 )
  306. {
  307.   y1 -= yorigin;
  308.   y2 -= yorigin;
  309.   x1 -= xorigin;
  310.   x2 -= xorigin;
  311.   if (x1 < 0 || x1 >= screen_width || y1 < 0 || y1 >= screen_height) return;
  312.   if (x2 < 0 || x2 >= screen_width || y2 < 0 || y2 >= screen_height) return;
  313.   vga_drawline(x1,y1,x2,y2);
  314. }
  315.  
  316. int
  317. linux_draw_line(gx_device *dev, int x0, int y0, int x1, int y1, 
  318.                gx_color_index color)
  319. {  
  320.   if(!((x0==x1)&&(y0==y1))) {
  321.     vga_setcolor((int)color);
  322.     adj_vga_drawline(x0,y0,x1,y1);
  323.   }
  324.   return 0;
  325. }
  326.  
  327. int
  328. linux_tile_rectangle(gx_device *dev, const gx_bitmap *tile,
  329.   int x, int y, int w, int h, gx_color_index czero, gx_color_index cone,
  330.   int px, int py)
  331. {
  332.   if ( czero != gx_no_color_index && cone != gx_no_color_index ) {
  333.     linux_fill_rectangle(dev, x, y, w, h, czero);
  334.     czero = gx_no_color_index;
  335.   }
  336.   return gx_default_tile_rectangle(dev, tile, x, y, w, h, czero, cone, px, py);
  337. }
  338.  
  339.  
  340. int
  341. linux_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  342.                       gx_color_index color)
  343. {
  344.   int i,j;
  345.   fit_fill(dev, x, y, w, h);
  346.   vga_setcolor((int)color);
  347.   for(i=y;i<y+h;i++)
  348.     for(j=x;j<x+w;j++)
  349.       adj_vga_drawpixel(j,i);
  350.   return 0;
  351. }
  352.  
  353. int
  354. linux_copy_mono(gx_device *dev,
  355.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  356.   int x, int y, int width, int height,
  357.   gx_color_index zero, gx_color_index one)
  358.  
  359. {
  360.   const byte *ptr_line = base + (sourcex >> 3);
  361.   int left_bit = 0x80 >> (sourcex & 7);
  362.   int dest_y = y, end_x = x + width;
  363.   int invert = 0;
  364.   int color;
  365.   int i;
  366.  
  367.   fit_copy(dev, base, sourcex, raster, id, x, y, width, height);
  368.  
  369.   if ( zero == gx_no_color_index ) {
  370.     if ( one == gx_no_color_index ) return 0;
  371.     color = (int)one;
  372.   } else {
  373.     if ( one == gx_no_color_index ) {
  374.       color = (int)zero;
  375.       invert = -1;
  376.     } else {   /* Pre-clear the rectangle to zero */
  377.       vga_setcolor(zero);
  378.       linux_fill_rectangle(dev,x,y,width,height,zero);
  379.       color = (int)one;
  380.     }
  381.   }
  382.  
  383.   vga_setcolor(color);
  384.   
  385.   while( height-- ) { /* for each line */ 
  386.     const byte *ptr_source = ptr_line;
  387.     register int dest_x = x;
  388.     register int bit = left_bit;
  389.     while ( dest_x < end_x ) { /* for each bit in the line */
  390.       if ( (*ptr_source ^ invert)  & bit ) 
  391.       adj_vga_drawpixel(dest_x,dest_y);
  392.       dest_x++;
  393.       if ( (bit >>= 1) == 0 )
  394.        bit = 0x80, ptr_source++;
  395.     }
  396.     dest_y++;
  397.     ptr_line += raster;
  398.   }  
  399.   return 0;
  400. }
  401.  
  402.  
  403. /* Copy a color pixel map.  This is just like a bitmap, except that */
  404. /* each pixel takes 4 bits instead of 1 when device driver has color. */
  405. int
  406. linux_copy_color(gx_device *dev,
  407.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  408.   int x, int y, int width, int height)
  409. {
  410.  
  411.   fit_copy(dev, base, sourcex, raster, id, x, y, width, height);
  412.  
  413.   if ( gx_device_has_color(dev) ) { /* color device, four bits per pixel */
  414.     const byte *line = base + (sourcex >> 1);
  415.     int dest_y = y, end_x = x + width, i;
  416.  
  417.     if ( width <= 0 ) return 0;
  418.     while ( height-- )  { /* for each line */
  419.       const byte *source = line;
  420.       register int dest_x = x;
  421.       if ( sourcex & 1 ) {    /* odd nibble first */
  422.        int color =  *source++ & 0xf;
  423.        vga_setcolor(color);
  424.        adj_vga_drawpixel(dest_x,dest_y);
  425.        dest_x++;
  426.       }
  427.       /* Now do full bytes */
  428.       while ( dest_x < end_x ) {
  429.        int color = *source >> 4;
  430.        vga_setcolor(color);
  431.        adj_vga_drawpixel(dest_x,dest_y);
  432.        dest_x++;
  433.        if ( dest_x < end_x ) {
  434.          color =  *source++ & 0xf;
  435.          vga_setcolor(color);
  436.          adj_vga_drawpixel(dest_x,dest_y);
  437.          dest_x++;
  438.        }
  439.       }
  440.       dest_y++;
  441.       line += raster;
  442.     }
  443.   } else { /* monochrome device: one bit per pixel */
  444.     /* bitmap is the same as bgi_copy_mono: one bit per pixel */
  445.     linux_copy_mono(dev, base, sourcex, raster, id, x, y, width, height,
  446.                  (gx_color_index)0, (gx_color_index)7);
  447.     }
  448.   return 0;
  449. }
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456.  
  457.