home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / apps / dtp / ghost / gs301src / atari / gdevprn.c next >
C/C++ Source or Header  |  1994-09-17  |  13KB  |  437 lines
  1. /* Copyright (C) 1990, 1992, 1993, 1994 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevprn.c */
  20. /* Generic printer support for Ghostscript */
  21. #include "gdevprn.h"
  22. #include "gp.h"
  23. #include "gsparam.h"
  24.  
  25. /* Define the scratch file name prefix for mktemp */
  26. #define SCRATCH_TEMPLATE gp_scratch_file_name_prefix
  27.  
  28. /* Internal routine for opening a scratch file */
  29. private int
  30. open_scratch(char *fname, FILE **pfile)
  31. {    char fmode[4];
  32.     strcpy(fmode, "w+");
  33.     strcat(fmode, gp_fmode_binary_suffix);
  34.     *pfile = gp_open_scratch_file(SCRATCH_TEMPLATE, fname, fmode);
  35.     if ( *pfile == NULL )
  36.        {    eprintf1("Could not open the scratch file %s.\n", fname);
  37.         return_error(gs_error_invalidfileaccess);
  38.        }
  39.     return 0;
  40. }
  41.  
  42. /* ------ Standard device procedures ------ */
  43.  
  44. /* Macros for casting the pdev argument */
  45. #define ppdev ((gx_device_printer *)pdev)
  46. #define pmemdev ((gx_device_memory *)pdev)
  47. #define pcldev ((gx_device_clist *)pdev)
  48.  
  49. /* Define the old-style printer procedure vector. */
  50. gx_device_procs prn_std_procs =
  51.   prn_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close);
  52.  
  53. /* Initialize a printer device. */
  54. int
  55. gdev_prn_initialize(register gx_device *pdev, const char _ds *dname,
  56.   dev_proc_print_page_t print_page)
  57. {    int code = gdev_initialize(pdev);
  58.     pdev->dname = dname;
  59.     set_dev_proc(pdev, open_device, gdev_prn_open);
  60.     set_dev_proc(pdev, output_page, gdev_prn_output_page);
  61.     set_dev_proc(pdev, close_device, gdev_prn_close);
  62.     set_dev_proc(pdev, map_rgb_color, gdev_prn_map_rgb_color);
  63.     set_dev_proc(pdev, map_color_rgb, gdev_prn_map_color_rgb);
  64.     set_dev_proc(pdev, get_params, gdev_prn_get_params);
  65.     set_dev_proc(pdev, put_params, gdev_prn_put_params);
  66.     ppdev->print_page = print_page;
  67.     ppdev->max_bitmap = PRN_MAX_BITMAP;
  68.     ppdev->use_buffer_space = PRN_BUFFER_SPACE;
  69.     ppdev->fname[0] = 0;
  70.     ppdev->file = 0;
  71.     ppdev->file_is_new = 0;
  72.     ppdev->ccfname[0] = 0;
  73.     ppdev->ccfile = 0;
  74.     ppdev->cbfname[0] = 0;
  75.     ppdev->cbfile = 0;
  76.     ppdev->buffer_space = 0;
  77.     ppdev->buf = 0;
  78.     return code;
  79. }
  80.  
  81. /* Further initialize a printer device for color. */
  82. void
  83. gdev_prn_init_color(gx_device *pdev, int depth,
  84.   dev_proc_map_rgb_color_t map_rgb_color,
  85.   dev_proc_map_color_rgb_t map_color_rgb)
  86. {    pdev->color_info.num_components = (depth > 1 ? 3 : 1);
  87.     pdev->color_info.depth = (depth > 1 && depth < 8 ? 8 : depth);
  88.     pdev->color_info.max_gray = (depth >= 8 ? 255 : 1);
  89.     pdev->color_info.max_rgb = (depth >= 8 ? 255 : depth > 1 ? 1 : 0);
  90.     pdev->color_info.dither_gray = (depth >= 8 ? 5 : 2);
  91.     pdev->color_info.dither_rgb = (depth >= 8 ? 5 : depth > 1 ? 2 : 0);
  92.     set_dev_proc(pdev, map_rgb_color, map_rgb_color);
  93.     set_dev_proc(pdev, map_color_rgb, map_color_rgb);
  94. }
  95.  
  96. /* Open a generic printer device. */
  97. /* Specific devices may wish to extend this. */
  98. int
  99. gdev_prn_open(gx_device *pdev)
  100. {    const gx_device_memory *mdev =
  101.       gdev_mem_device_for_bits(pdev->color_info.depth);
  102.     ulong mem_space;
  103.     byte *base = 0;
  104.     char *left = 0;
  105.     if ( mdev == 0 )
  106.         return_error(gs_error_rangecheck);
  107.     memset(ppdev->skip, 0, sizeof(ppdev->skip));
  108.     ppdev->orig_procs = pdev->std_procs;
  109.     ppdev->file = ppdev->ccfile = ppdev->cbfile = NULL;
  110.     mem_space = gdev_mem_bitmap_size(pmemdev);
  111.     if ( mem_space >= ppdev->max_bitmap ||
  112.          mem_space != (uint)mem_space ||    /* too big to allocate */
  113.          (base = (byte *)gs_malloc((uint)mem_space, 1, "printer buffer(open)")) == 0 ||    /* can't allocate */
  114.          (PRN_MIN_MEMORY_LEFT != 0 &&
  115.           (left = gs_malloc(PRN_MIN_MEMORY_LEFT, 1, "printer memory left")) == 0)    /* not enough left */
  116.        )
  117.     {    /* Buffer the image in a command list. */
  118.         uint space;
  119.         int code;
  120.         /* Release the buffer if we allocated it. */
  121.         if ( base != 0 )
  122.             gs_free((char *)base, (uint)mem_space, 1,
  123.                 "printer buffer(open)");
  124.         for ( space = ppdev->use_buffer_space; ; )
  125.         {    base = (byte *)gs_malloc(space, 1,
  126.                          "command list buffer(open)");
  127.             if ( base != 0 ) break;
  128.             if ( (space >>= 1) < PRN_MIN_BUFFER_SPACE )
  129.                 return_error(gs_error_VMerror);    /* no hope */
  130.         }
  131. open_c:        pcldev->data = base;
  132.         pcldev->data_size = space;
  133.         pcldev->target = pdev;
  134.         gs_make_mem_device(&pcldev->mdev, mdev, 0, 0);
  135.         pcldev->mdev.target = pdev;
  136.         ppdev->buf = base;
  137.         ppdev->buffer_space = space;
  138.         /* Try opening the command list, to see if we allocated */
  139.         /* enough buffer space. */
  140.         code = (*gs_clist_device_procs.open_device)((gx_device *)pcldev);
  141.         if ( code < 0 )
  142.         {    /* If there wasn't enough room, and we haven't */
  143.             /* already shrunk the buffer, try enlarging it. */
  144.             if ( code == gs_error_limitcheck &&
  145.                  space >= ppdev->use_buffer_space
  146.                )
  147.             {    gs_free((char *)base, space, 1,
  148.                     "command list buffer(retry open)");
  149.                 space <<= 1;
  150.                 base = (byte *)gs_malloc(space, 1,
  151.                          "command list buffer(retry open)");
  152.                 ppdev->buf = base;
  153.                 if ( base != 0 ) goto open_c;
  154.             }
  155.             /* Fall through with code < 0 */
  156.         }
  157.         if ( code < 0 ||
  158.              (code = open_scratch(ppdev->ccfname, &ppdev->ccfile)) < 0 ||
  159.              (code = open_scratch(ppdev->cbfname, &ppdev->cbfile)) < 0
  160.            )
  161.         {    /* Clean up before exiting */
  162.             gdev_prn_close(pdev);
  163.             return code;
  164.         }
  165.         pcldev->cfile = ppdev->ccfile;
  166.         pcldev->bfile = ppdev->cbfile;
  167.         pcldev->bfile_end_pos = 0;
  168.         ppdev->std_procs = gs_clist_device_procs;
  169.     }
  170.     else
  171.     {    /* Render entirely in memory. */
  172.         /* Release the leftover memory. */
  173.         gs_free(left, PRN_MIN_MEMORY_LEFT, 1,
  174.             "printer memory left");
  175.         ppdev->buffer_space = 0;
  176.         pmemdev->base = base;
  177.         ppdev->std_procs = mdev->std_procs;
  178.         ppdev->std_procs.get_page_device =
  179.             gx_page_device_get_page_device;
  180.     }
  181.     /* Synthesize the procedure vector. */
  182.     /* Rendering operations come from the memory or clist device, */
  183.     /* non-rendering come from the printer device. */
  184. #define copy_proc(p) set_dev_proc(ppdev, p, ppdev->orig_procs.p)
  185.     copy_proc(get_initial_matrix);
  186.     copy_proc(output_page);
  187.     copy_proc(close_device);
  188.     copy_proc(map_rgb_color);
  189.     copy_proc(map_color_rgb);
  190.     copy_proc(get_params);
  191.     copy_proc(put_params);
  192.     copy_proc(map_cmyk_color);
  193.     copy_proc(get_xfont_procs);
  194.     copy_proc(get_xfont_device);
  195.     copy_proc(map_rgb_alpha_color);
  196.     copy_proc(get_page_device);
  197. #undef copy_proc
  198.     return (*dev_proc(pdev, open_device))(pdev);
  199. }
  200.  
  201. /* Get parameters.  In addition to the standard parameters, */
  202. /* we supply the max bitmap size, buffer size, output file name, */
  203. /* and page count. */
  204. int
  205. gdev_prn_get_params(gx_device *pdev, gs_param_list *plist)
  206. {    int code = gx_default_get_params(pdev, plist);
  207.     gs_param_string ofns;
  208.     if ( code < 0 ) return code;
  209.     code = param_write_long(plist, "BufferSpace", &ppdev->use_buffer_space);
  210.     if ( code < 0 ) return code;
  211.     code = param_write_long(plist, "MaxBitmap", &ppdev->max_bitmap);
  212.     if ( code < 0 ) return code;
  213.     ofns.data = (const byte *)ppdev->fname,
  214.       ofns.size = strlen(ppdev->fname),
  215.       ofns.persistent = false;
  216.     return param_write_string(plist, "OutputFile", &ofns);
  217. }
  218.  
  219. /* Put parameters. */
  220. /* Note that setting the buffer sizes closes the device. */
  221. int
  222. gdev_prn_put_params(gx_device *pdev, gs_param_list *plist)
  223. {    long v;
  224.     gs_param_string s;
  225.     int ecode = gx_default_put_params(pdev, plist);
  226.     int rcode = ecode, code;
  227.     switch ( code = param_read_long(plist, "BufferSpace", &v) )
  228.     {
  229.     default:
  230.         ecode = code;
  231.     case 1:
  232.         break;
  233.     case 0:
  234.         if ( v < 10000 )
  235.             param_signal_error(plist, "BufferSpace",
  236.                        ecode = gs_error_rangecheck);
  237.         else
  238.           {    ppdev->use_buffer_space = v;
  239.             rcode = 1;
  240.           }
  241.     }
  242.     switch ( code = param_read_long(plist, "MaxBitmap", &v) )
  243.     {
  244.     default:
  245.         ecode = code;
  246.     case 1:
  247.         break;
  248.     case 0:
  249.         ppdev->max_bitmap = v;
  250.         rcode = 1;
  251.     }
  252.     switch ( code = param_read_string(plist, "OutputFile", &s) )
  253.     {
  254.     default:
  255.         ecode = code;
  256.     case 1:
  257.         break;
  258.     case 0:
  259.         if ( s.size >= prn_fname_sizeof )
  260.             param_signal_error(plist, "OutputFile",
  261.                        ecode = gs_error_limitcheck);
  262.         else
  263.           {    /* Close the file if it's open. */
  264.             if ( ppdev->file != NULL && ppdev->file != stdout )
  265.               gp_close_printer(ppdev->file, ppdev->fname);
  266.             ppdev->file = NULL;
  267.             memcpy(ppdev->fname, s.data, s.size);
  268.             ppdev->fname[s.size] = 0;
  269.             rcode = 1;
  270.           }
  271.     }
  272.     /* If we're changing the buffer sizes, close the device; */
  273.     /* gs_putdeviceparams will reopen it. */
  274.     if ( ecode < 0 )
  275.       return ecode;
  276.     if ( pdev->is_open && rcode )
  277.     {    int ccode = gs_closedevice(pdev);
  278.         if ( ccode < 0 ) return ccode;
  279.     }
  280.     return rcode;
  281. }
  282.  
  283. /* Generic routine to send the page to the printer. */
  284. /****** Note that num_copies is currently ignored: this is wrong. ******/
  285. int
  286. gdev_prn_output_page(gx_device *pdev, int num_copies, int flush)
  287. {    int code, outcode, closecode, errcode;
  288.  
  289.     code = gdev_prn_open_printer(pdev, 1);
  290.     if ( code < 0 )
  291.         return code;
  292.  
  293.     /* Print the accumulated page description. */
  294.     outcode = (*ppdev->print_page)(ppdev, ppdev->file);
  295.  
  296. #ifdef atarist
  297.     if (ppdev->file)
  298. #endif
  299.     errcode = (ferror(ppdev->file) ? gs_error_ioerror : 0);
  300.  
  301.     closecode = gdev_prn_close_printer(pdev);
  302.  
  303.     if ( ppdev->buffer_space ) /* reinitialize clist for writing */
  304.       code = (*gs_clist_device_procs.output_page)(pdev, num_copies, flush);
  305.  
  306.     if ( outcode < 0 )
  307.         return outcode;
  308.     if ( errcode < 0 )
  309.         return_error(errcode);
  310.     if ( closecode < 0 )
  311.         return closecode;
  312.     return code;
  313. }
  314.  
  315. /* Generic closing for the printer device. */
  316. /* Specific devices may wish to extend this. */
  317. int
  318. gdev_prn_close(gx_device *pdev)
  319. {    if ( ppdev->ccfile != NULL )
  320.     {    fclose(ppdev->ccfile);
  321.         ppdev->ccfile = NULL;
  322.         unlink(ppdev->ccfname);
  323.     }
  324.     if ( ppdev->cbfile != NULL )
  325.     {    fclose(ppdev->cbfile);
  326.         ppdev->cbfile = NULL;
  327.         unlink(ppdev->cbfname);
  328.     }
  329.     if ( ppdev->buffer_space != 0 )
  330.     {    /* Free the buffer */
  331.         gs_free((char *)ppdev->buf, (uint)ppdev->buffer_space, 1,
  332.             "command list buffer(close)");
  333.     }
  334.     else
  335.     {    /* Free the memory device bitmap */
  336.         gs_free((char *)pmemdev->base,
  337.             (uint)gdev_mem_bitmap_size(pmemdev),
  338.             1, "printer buffer(close)");
  339.     }
  340.     if ( ppdev->file != NULL )
  341.     {    if ( ppdev->file != stdout )
  342.            gp_close_printer(ppdev->file, ppdev->fname);
  343.         ppdev->file = NULL;
  344.     }
  345.     pdev->std_procs = ppdev->orig_procs;
  346.     return 0;
  347. }
  348.  
  349. /* Map colors.  This is different from the default, because */
  350. /* printers write black, not white. */
  351.  
  352. gx_color_index
  353. gdev_prn_map_rgb_color(gx_device *dev, gx_color_value r, gx_color_value g,
  354.   gx_color_value b)
  355. {    /* Map values >= 1/2 to 0, < 1/2 to 1. */
  356.     return ((r | g | b) > gx_max_color_value / 2 ?
  357.         (gx_color_index)0 : (gx_color_index)1);
  358. }
  359.  
  360. int
  361. gdev_prn_map_color_rgb(gx_device *dev, gx_color_index color,
  362.   gx_color_value prgb[3])
  363. {    /* Map 0 to max_value, 1 to 0. */
  364.     prgb[0] = prgb[1] = prgb[2] = -((gx_color_value)color ^ 1);
  365.     return 0;
  366. }
  367.  
  368. /* ------ Driver services ------ */
  369.  
  370. /* Open the current page for printing. */
  371. int
  372. gdev_prn_open_printer(gx_device *pdev, int binary_mode)
  373. {    char *fname = ppdev->fname;
  374.     char pfname[prn_fname_sizeof + 10];
  375.     char *pnpos = strchr(fname, '%');
  376.     if ( pnpos != NULL )
  377.     {    long count1 = ppdev->page_count + 1;
  378.         sprintf(pfname, fname,
  379.             (pnpos[1] == 'l' ? count1 : (int)count1));
  380.         fname = pfname;
  381.     }
  382.     if ( ppdev->file == NULL )
  383.     {    if ( !strcmp(fname, "-") )
  384.             ppdev->file = stdout;
  385.         else
  386.         {    ppdev->file = gp_open_printer(fname, binary_mode);
  387. #ifndef atarist
  388.                         if ( ppdev->file == NULL )
  389.                                 return_error(gs_error_invalidfileaccess);
  390. #endif
  391.         }
  392.         ppdev->file_is_new = 1;
  393.     }
  394.     else
  395.         ppdev->file_is_new = 0;
  396.     return 0;
  397. }
  398.  
  399. /* Copy a scan line from the buffer to the printer. */
  400. int
  401. gdev_prn_get_bits(gx_device_printer *pdev, int y, byte *str, byte **actual_data)
  402. {    int code = (*dev_proc(pdev, get_bits))((gx_device *)pdev, y, str, actual_data);
  403.     uint line_size = gdev_prn_raster(pdev);
  404.     int last_bits = -(pdev->width * pdev->color_info.depth) & 7;
  405.     if ( code < 0 ) return code;
  406.     if ( last_bits != 0 )
  407.     {    byte *dest = (actual_data != 0 ? *actual_data : str);
  408.         dest[line_size - 1] &= 0xff << last_bits;
  409.     }
  410.     return 0;
  411. }
  412. /* Copy scan lines to a buffer.  Return the number of scan lines, */
  413. /* or <0 if error. */
  414. int
  415. gdev_prn_copy_scan_lines(gx_device_printer *pdev, int y, byte *str, uint size)
  416. {    uint line_size = gdev_prn_raster(pdev);
  417.     int count = size / line_size;
  418.     int i;
  419.     byte *dest = str;
  420.     count = min(count, pdev->height - y);
  421.     for ( i = 0; i < count; i++, dest += line_size )
  422.     {    int code = gdev_prn_get_bits(pdev, y + i, dest, NULL);
  423.         if ( code < 0 ) return code;
  424.     }
  425.     return count;
  426. }
  427.  
  428. /* Close the current page. */
  429. int
  430. gdev_prn_close_printer(gx_device *pdev)
  431. {    if ( strchr(ppdev->fname, '%') )    /* file per page */
  432.        {    gp_close_printer(ppdev->file, ppdev->fname);
  433.         ppdev->file = NULL;
  434.        }
  435.     return 0;
  436. }
  437.