| /* Copyright (C) 1989, 1990, 1991 Aladdin Enterprises. All rights reserved. | |
| Distributed by Free Software Foundation, Inc. | |
| This file is part of Ghostscript. | |
| Ghostscript is distributed in the hope that it will be useful, but | |
| WITHOUT ANY WARRANTY. No author or distributor accepts responsibility | |
| to anyone for the consequences of using it or for whether it serves any | |
| particular purpose or works at all, unless he says so in writing. Refer | |
| to the Ghostscript General Public License for full details. | |
| Everyone is granted permission to copy, modify and redistribute | |
| Ghostscript, but only under the conditions described in the Ghostscript | |
| General Public License. A copy of this license is supposed to have been | |
| given to you along with Ghostscript so you can know your rights and | |
| responsibilities. It should be in a file named COPYING. Among other | |
| things, the copyright notice and this notice must be preserved on all | |
| copies. */ | |
| /* gdevdjet.c */ | |
| /* H-P DeskJet/LaserJet driver for GhostScript */ | |
| /* Define whether we are writing to a DeskJet (which can do bitmap */ | |
| /* compression) or a LaserJet (which can't). */ | |
| /* Normally this is defined in the compiler command line -- */ | |
| /* see the DeskJet and LaserJet entries in gdevs.mak. */ | |
| #ifndef LASER | |
| # define LASER 0 | |
| #endif | |
| #if LASER | |
| # define GS_PRN_DEVICE gs_laserjet_device | |
| # define DEVICE_NAME "laserjet" | |
| #else | |
| # define GS_PRN_DEVICE gs_deskjet_device | |
| # define DEVICE_NAME "deskjet" | |
| #endif | |
| #define PAGE_WIDTH_10THS 80 /* not quite a full page */ | |
| #define PAGE_HEIGHT_10THS 105 /* ditto */ | |
| /* Normally we set up at 300 DPI; however, on MS-DOS systems with */ | |
| /* virtual memory disabled, we can't do more than 60 DPI */ | |
| /* because the maximum buffer is only 64K. */ | |
| #define X_DPI 300 | |
| #define Y_DPI 300 | |
| #ifdef __MSDOS__ | |
| # if !VMEM_SPACE | |
| # undef X_DPI | |
| # define X_DPI 60 | |
| # undef Y_DPI | |
| # define Y_DPI 60 | |
| # endif | |
| #endif | |
| #define PRN_OPEN gdev_prn_open | |
| #define PRN_CLOSE gdev_prn_close | |
| #define PRN_OUTPUT_PAGE djet_output_page | |
| #define DRIVER /* see gdevprn.h */ | |
| #include "gdevprn.h" | |
| /* Forward references */ | |
| private int djet_print_page(P2(gx_device_printer *, FILE *)); | |
| /* Send the page to the printer. */ | |
| private int | |
| djet_output_page(gx_device *dev) | |
| { int code = gdev_prn_open_printer(dev); | |
| if ( code < 0 ) return code; | |
| /* print the accumulated page description */ | |
| djet_print_page(prn_dev, prn_dev->file); | |
| gdev_prn_close_printer(dev); | |
| return 0; | |
| } | |
| /* ------ Internal routines ------ */ | |
| /* Send the page to the printer. For the DeskJet, compress each scan line, */ | |
| /* since computer-to-printer communication time is often a bottleneck. */ | |
| private int | |
| djet_print_page(gx_device_printer *pdev, FILE *prn_stream) | |
| { char data[LINE_SIZE + 4]; | |
| #define escape_print(str) fprintf(prn_stream, str, 27) | |
| #define escape_print_1(str,arg) fprintf(prn_stream, str, 27, arg) | |
| /* ends raster graphics to set raster graphics resolution */ | |
| escape_print("%c*rB"); | |
| /* set raster graphics resolution -- 75 or 300 dpi */ | |
| #if X_DPI == 300 | |
| escape_print("%c*t300R"); | |
| #else | |
| escape_print("%c*t75R"); | |
| #endif | |
| /* move to top left of page */ | |
| escape_print("%c*p0x0Y"); | |
| /* start raster graphics */ | |
| escape_print("%c*r0A"); | |
| /* select the most compressed mode available */ | |
| #if !LASER /* LaserJet can't handle it */ | |
| escape_print("%c*b2M"); | |
| #endif | |
| /* Send each scan line in turn */ | |
| { int lnum; | |
| int line_size = mem_bytes_per_scan_line(&pdev->mem); | |
| int num_blank_lines = 0; | |
| for ( lnum = 0; lnum < pdev->height; lnum++ ) | |
| { char *end_data = data + LINE_SIZE; | |
| mem_copy_scan_lines(&pdev->mem, lnum, | |
| (byte *)data, line_size); | |
| /* Mask off 1-bits beyond LINE_WIDTH. */ | |
| #if (LINE_WIDTH & 7) | |
| end_data[-1] &= (byte)(0xff00 >> (LINE_WIDTH & 7)); | |
| #endif | |
| /* Remove trailing 0s. */ | |
| while ( end_data > data && end_data[-1] == 0 ) | |
| end_data--; | |
| if ( end_data == data ) | |
| { /* Blank line */ | |
| num_blank_lines++; | |
| } | |
| else | |
| { | |
| #if LASER /* no compression */ | |
| char *out_data = data; | |
| int out_count = end_data - data; | |
| #else | |
| char out_data[LINE_SIZE + LINE_SIZE / 127 + 1]; | |
| int out_count = | |
| compress_row(data, end_data, out_data); | |
| #endif | |
| /* Skip blank lines if any */ | |
| if ( num_blank_lines > 0 ) | |
| { /* move down from current position */ | |
| escape_print_1("%c*p+%dY", | |
| num_blank_lines); | |
| num_blank_lines = 0; | |
| } | |
| /* transfer raster graphics */ | |
| escape_print_1("%c*b%dW", out_count); | |
| /* send the row */ | |
| fwrite(out_data, sizeof(char), | |
| out_count, prn_stream); | |
| } | |
| } | |
| } | |
| /* end raster graphics */ | |
| escape_print("%c*rB"); | |
| /* eject page */ | |
| escape_print("%c&l0H"); | |
| return 0; | |
| } | |
| #if !LASER | |
| /* Row compression routine for the HP DeskJet. */ | |
| /* Compresses data from row up to end_row, storing the result */ | |
| /* starting at compressed. Returns the number of bytes stored. */ | |
| /* Runs of K<=127 literal bytes are encoded as K-1 followed by */ | |
| /* the bytes; runs of 2<=K<=127 identical bytes are encoded as */ | |
| /* 257-K followed by the byte. */ | |
| /* In the worst case, the result is N+(N/127)+1 bytes long, */ | |
| /* where N is the original byte count (end_row - row). */ | |
| int | |
| compress_row(char *row, char *end_row, char *compressed) | |
| { register char *i_exam = row; /* byte being examined in the row to compress */ | |
| char *stop_exam = end_row - 4; /* stop scanning for similar bytes here */ | |
| register char *cptr = compressed; /* output pointer into compressed bytes */ | |
| while ( i_exam < end_row ) | |
| { /* Search ahead in the input looking for a run */ | |
| /* of at least 4 identical bytes. */ | |
| char *i_compr = i_exam; | |
| char *i_next; /* end of run */ | |
| char byte_value; | |
| while ( i_exam <= stop_exam && | |
| ((byte_value = *i_exam) != i_exam[1] || | |
| byte_value != i_exam[2] || | |
| byte_value != i_exam[3]) ) | |
| i_exam++; | |
| /* Find out how long the run is */ | |
| if ( i_exam > stop_exam ) /* no run */ | |
| i_next = i_exam = end_row; | |
| else | |
| { i_next = i_exam + 4; | |
| while ( i_next < end_row && *i_next == byte_value ) | |
| i_next++; | |
| } | |
| /* Now [i_compr..i_exam) should be encoded as dissimilar, */ | |
| /* and [i_exam..i_next) should be encoded as similar. */ | |
| /* Note that either of these ranges may be empty. */ | |
| while ( i_compr < i_exam ) | |
| { /* Encode up to 127 dissimilar bytes */ | |
| int count = i_exam - i_compr; | |
| if ( count > 127 ) count = 127; | |
| *cptr++ = count - 1; | |
| while ( count > 0 ) | |
| { *cptr++ = *i_compr++; | |
| count--; | |
| } | |
| } | |
| while ( i_exam < i_next ) | |
| { /* Encode up to 127 similar bytes */ | |
| int count = i_next - i_exam; | |
| if ( count > 127 ) count = 127; | |
| *cptr++ = 1 - count; | |
| *cptr++ = byte_value; | |
| i_exam += count; | |
| } | |
| } | |
| return (cptr - compressed); | |
| } | |
| #endif /* !LASER */ |