Details of Ghostscript output devices

Table of contents

For other information, see the Ghostscript overview. You may also be interested in how to build Ghostscript and install it, as well as the description of the driver interface.

Documentation for some older, superceeded devices has been moved to another document. In general such devices are deprecated and will be removed in future versions of ghostscript. In general all older printer drivers can be replaced by the ijs interface and one of the available 3rd party raster driver collections. We recommend moving to the ijs device for all such printing.


Notes on measurements

Several different important kinds of measures appear throughout this document: inches, centimeters and millimeters, points, and bits per pixel.

Centimeters and millimeters
ISO standard paper sizes such as A4 and A3 are commonly represented in the SI units of centimeters and millimeters. Centimeters are abbreviated cm, millimeters mm. ISO A4 paper is quite close to 210×297 millimeters (approximately 8.3×11.7 inches).
Inches
1 inch equals 2.54 centimeters. The inch measure is sometimes represented by in or a quotation mark (") to the right of a measure, like 8.5in or 8.5". U.S. "letter" paper is exactly 8.5in×11in, approximately 21.6cm×27.9cm. (See in the usage documentation all the paper sizes predefined in Ghostscript.)
Points
Points are a measure traditionally used in the printing trade and now in PostScript, which specifies exactly 72 points per inch (approximately 28.35 per centimeter). The paper sizes known to Ghostscript are defined in the initialization file gs_statd.ps in terms of points.
Dots per inch
Dots per inch or dpi is the common measure of printing resolution in the US.
Bits per pixel
Commonly abbreviated bpp this is the number of digital bits used to represent the color of each pixel. This is also refered to as 'bit depth' or 'pixel depth'.

Image file formats

Ghostscript supports output to a variety of image file formats and is widely used for rasterizing postscript and pdf files. A collection of such formats ('output devices' in Ghostscript terminology) are described in this section.

Here are some commonly useful driver options that apply to all raster drivers. Options specific to particular file formats are described in their respective sections below.

-sOutputFile=filename

This is a general option telling ghostscript what to name the output. It can either be a single filename 'tiger.png' or a template 'figure-%03d.jpg' where the %03d is replaced by the page number.

-rres
-rxresxyres

This option sets the resolution of the output file in dots per inch. The default value if you don't specify this options is usually 72 dpi.

-dTextAlphaBits=n
-dGraphicsAlphaBits=n

These options control the use of subsample antialiasing. Their use is highly recommended for producing high quality rasterizations of the input files. The size of the subsampling box n should be 4 for optimum output, but smaller values can be used for faster rendering. Antialiasing is enabled separately for text and graphics content.

It is also conventional to call ghostscript with the '-dSAFER -dBATCH -dNOPAUSE' trio of options when rasterizing to a file. These suppress interactive prompts and enable some security checks on the file to be run. Please see the Use documentation for a complete description.

PNG file format

PNG (pronounced 'ping') stands for Portable Network Graphics, and is the recommended format for high-quality images. It supports full quality color and transparency, offers excellent lossless compression of the image data, and is widely supported. Please see the PNG website for a complete description of the format.

Ghostscript provides a variety of devices for PNG output varying by bit depth. For normal use we recommend png16m for 24-bit RGB color, or pnggray for grayscale. The png256, png16 and pngmono devices respectively provide 8-bit color, 4-bit color and black-and-white for special needs.

Options

The png devices have no special options.

Examples

Examples of how to use ghostscript to convert postscript to PNG image files:

 gs -dSAFER -dBATCH -dNOPAUSE -sDEVICE=png16m -dGraphicsAlphaBits=4 \
      -sOutputFile=tiger.png examples/tiger.png
      
 gs -dSAFER -dBATCH -dNOPAUSE -r150 -sDEVICE=pnggray -dTextAlphaBits=4 \
      -sOutputFile=doc-%02d.png doc.pdf

JPEG file format (JFIF)

Ghostscript includes output drivers that can produce jpeg files from postscript or pdf images. These are the jpeg and jpeggray devices.

Technically these produce Independent JPEG Group JFIF (JPEG File Interchange Format) files, the common sort found on the web.

Please note that JPEG is a compression method specifically intended for continuous-tone images such as photographs, not for graphics, and it is therefore quite unsuitable for the vast majority of page images produced with PostScript. For anthing other than pages containing simple images the lossy compression of the jpeg format will result in poor quality output regardless of the input. To learn more about the distinction, consult a reference about uses and abuses of JPEG, such as the JPEG FAQ

http://www.faqs.org/faqs/jpeg-faq/

Examples

You can use the JPEG output drivers -- jpeg to produce color JPEG files and jpeggray for grayscale JPEGs -- the same as other file-format drivers: by specifying the device name and an output file name, for example

gs -sDEVICE=jpeg -sOutputFile=foo.jpg foo.ps

Options

The JPEG devices support several special parameters to control the JPEG "quality setting" (DCT quantization level).

-dJPEGQ=N (integer from 0 to 100, default 75)
Set the quality level N according to the widely used IJG quality scale, which balances the extent of compression against the fidelity of the image when reconstituted. Lower values drop more information from the image to achieve higher compression, and therefore have lower quality when reconstituted.
-dQFactor=M (float from 0.0 to 1.0)
Adobe's QFactor quality scale, which you may use in place of JPEGQ above. The QFactor scale is used by PostScript's DCTEncode filter but is nearly unheard-of elsewhere.

At this writing the default JPEG quality level of 75 is equivalent to -dQFactor=0.5, but the JPEG default might change in the future. There is currently no support for any additional JPEG compression options, such as the other DCTEncode filter parameters.

PNM

The PNM (portable network map) family of formats are very simple uncompressed image formats commonly used on unix-like systems. They are particularly useful for testing or as input to an external conversion utility.

A wide variety of data formats and depths is supported. Devices include pbm pbmraw pgm pgmraw pgnm pgnmraw pnm pnmraw ppm ppmraw pkm pkmraw pksm pksmraw.

TIFF file formats

TIFF is a loose collection of formats, now largely superceeded by PNG except in applications where backward compatibility or special compression is required. The TIFF file format is described in the TIFF 6.0 Specification published by Adobe Systems Incorporated.

There are two unrelated sets of TIFF drivers. There are two color TIFF drivers that produce uncompressed output:

tiff24nc
Produces 24-bit RGB output (8 bits per component).
tiff12nc
Produces 12-bit RGB output (4 bits per component).

The remaining TIFF drivers all produce black-and-white output with different compression modes:

tiffcrle
G3 fax encoding with no EOLs
tiffg3
G3 fax encoding with EOLs
tiffg32d
2-D G3 fax encoding
tiffg4
G4 fax encoding
tifflzw
LZW-compatible (tag = 5) compression
tiffpack
PackBits (tag = 32773) compression

Options

The black-and-white TIFF drivers support creation of files that are comprised of more than a single strip. Multi-strip files reduce the memory requirement on the reader, since readers need only store and process one strip at a time. These drivers provide two parameters beyond the standard set:

-dMaxStripSize=N (non-negative integer; default = 0)
Set the maximum (uncompressed) size of a strip.
-dAdjustWidth=true|false (Boolean; default = true)
If true, then if the requested page width is close to either A4 (1728 columns) or B4 (2048 columns), set the page width to A4 or B4 respectively.

The TIFF 6.0 specification, Section 7, page 27, recommends that the size of each strip be about 8 Kbytes. As an example, to generate the 'tiger' in tiffg4 format that has the recommended strip size, use:

gs -sDEVICE=tiffg4 -sOutputFile=tiger.tiff -dMaxStripSize=8192 examples/tiger.eps

If the value of the MaxStripSize parameter is smaller than a single image row, then no error will be generated, and the TIFF file will be generated correctly using one row per strip. Note that smaller strip sizes increase the size of the file by increasing the size of the StripOffsets and StripByteCounts tables, and by reducing the effectiveness of the compression which must start over for each strip.

If the value of MaxStripSize is 0 (the default), then the entire image will be a single strip.

FAX

Ghostscript supports a variety of fax encodings, both encapsulated in TIFF (see above) and as raw files. The later case is described here.

The fax devices are faxg3, faxg32d and faxg4.

BMP

BMP is a simple uncompressed image format commonly used on MS Windows. It is supported by the devices bmpmono bmpgray bmpsep1 bmpsep8 bmp16 bmp256 bmp16m bmp32b.

PCX

PCX is an image format sometimes used on MS Windows. It has some support for image compression and alternate color spaces, and so can be a useful way to output CMYK. It is supported by the pcxmono pcxgray pcx16 pcx256 pcx24b pcxcmyk series of devices.

High-level devices

In addition to raster image files, Ghostscript supports output in a number of 'high-level' formats. These allow Ghostscript to preserve (as much as possible) the drawing elements of the input file maintaining flexibility, resolution independence, and editability.

PDF writer

The pdfwrite device outputs PDF.

PS writer

The pswrite device outputs postscript.

Options

-dLanguageLevel=1 | 1.5 | 2 | 3 (default is 2)
Set the language level of the generated file. Language level 1.5 is language level 1 with color extensions. Currently language level 3 generates the same PostScript as 2.

EPS writer

The epswrite device outputs encapsulated postscript.

Options

-dLanguageLevel=1 | 1.5 | 2 | 3 (default is 2)
Set the language level of the generated file. Language level 1.5 is language level 1 with color extensions. Currently language level 3 generates the same PostScript as 2.

PXL

The pxlmono and pxlcolor devices output HP PCL-XL, a graphic language understood by many recent laser printers.


Display Devices

Ghostscript is often used for screen display of postscript and pdf documents. In many cases, a client or 'viewer' application calls the ghostscript engine to do the rasterization and handles the display of the resulting image itself, but it is also possible to invoke ghostscript directly and select an output device which directly handles displaying the image on screen.

This section describes the various display-oriented devices that are available in ghostscript.

X Window System

Perhaps the most common use of of a display device is with the X Window System on unix-like systems. It is the default device on the command line client on such systems, and is used more creatively by the gv client application.

The available devices are:

x11
This is the default device, handling display on X11R6.
x11alpha
This is the x11 device, but with antialiasing. It is equivalent to invoking the x11 device with the options -dGraphicsAlphaBits=4 -dTextAlphaBits=4 -dMaxBitmap=50000000.
x11cmyk
This device rasterizes the image in the CMKY color space, then flattens it to RGB for display. It's intended for testing only.
x11mono
This is a strict black-and-white device for 1-bit monochrome displays.
x11gray2
This is a device for 2 bpp (4-level) monochrome displays.
x11gray4
This is a device for 4 bpp (16-level) monochrome displays.

IJS - Inkjet and other raster devices

IJS is a relatively new initiative to improve the quality and ease of use of inkjet printing with Ghostscript. Using IJS, you can add new drivers, or upgrade existing ones, without recompiling Ghostscript. All driver authors are encouraged to adapt their drivers for IJS, and if there is an IJS driver available for your printer, it should be your first choice.

Please see the IJS web page for more information about IJS, including a listing of IJS-compatible drivers.

A typical command line for IJS is:

gs -DSAFER -sDEVICE=ijs -sIjsServer=hpijs -sDeviceManufacturer=HEWLETT-PACKARD -sDeviceModel='DESKJET 990' -DIjsUseOutputFD -sOutputFile=/dev/usb/lp1 -DNOPAUSE -- examples/tiger.eps

Individual IJS command line parameters are as follows:

-sIjsServer={path}
Sets the pathname for the IJS server (ie printer driver). Ghostscript will spawn a new process for this driver, and communicate with it using the IJS protocol. The pathname need not be absolute, as the PATH environment variable is searched, but it's probably a good idea for robustness and security. Note also that if -dSAFER is not specified, it's possible for PostScript code to set this parameter, so it can cause arbitrary code to be executed. See the section on Security for more information.
-sDeviceManufacturer={name}
-sDeviceModel={name}
These parameters select the device according to IEEE-1284 standard device ID strings. In general, consult the documentation for the driver to find the appropriate settings. Note that, if the value contains a space, you'll want to quote the value in your shell, as in the example above.
-sIjsParams={params}
This parameter allows you to set arbitrary IJS parameters on the IJS driver. The format is a comma-separated list of key=value pairs. If it is necessary to send a value containing a comma or backslash, it can be escaped with a backslash. Thus, '-sIjsParams=Foo=bar,Baz=a\,b' sets the parameter Foo to "bar", and Baz to "a,b".
-dIjsUseOutputFD
This flag indicates that Ghostscript should open the output file and pass a file descriptor to the server. If not set, Ghostscript simply passes the filename set in OutputFile to the server. In most cases, this flag won't matter, but if you have a driver which works only with OutputFD (such as hpijs 1.0.2), or if you're using the -sOutputFile="|cmd" syntax, you'll need to set it.
-dBitsPerSample=N
This parameter controls the number of bits per sample. The default value of 8 should be appropriate for most work. For monochrome images, use -dBitsPerSample=1.

Generic Ghostscript options that are particularly relevant for IJS are summarized below:

-rnumber
-rnumber1xnumber2
Sets the resolution, in dpi. If the resolution is not specified, Ghostscript queries the IJS server to determine the preferred resolution. When the resolution is specified, it overrides the value (if any) preferred by the IJS server.
-dDuplex
-dTumble
These flags enable duplex (two-sided) printing. Tumble controls the orientation. When Tumble is false, the pages are oriented suitably at the left or right. When Tumble is true, the pages are oriented suitably for binding at the top or bottom.
-sProcessColorModel={name}
Use this flag to select the process color model. Suitable values include DeviceGray, DeviceRGB, and DeviceCMYK.

Building IJS

IJS is included by default on Unix gcc builds, and also in autoconf'ed builds. Others may need some makefile tweaking. First, make sure the IJS device is selected:

DEVICE_DEVS2=$(DD)ijs.dev

Next, make sure that the path and execution type are set in the toplevel makefile. The values for Unix are as follows:

IJSSRCDIR=ijs IJSEXECTYPE=unix

At present, "unix" and "win" are the only supported values for IJSEXECTYPE. If neither sounds appropriate for your system, it's possible that more porting work is needed.

Last, make sure that ijs.mak is included in the toplevel makefile. It should be present right after the include of icclib.mak.

IJS is not inherently platform-specific. We're very much interested in taking patches from people who have ported it to non-mainstream platforms. And once it's built, you won't have to recompile Ghostscript to support new drivers!

HP Deskjet official drivers

HP provides official drivers for many of their Deskjet printer models. In order to use these drivers, you will need the HP Inkjet Server as well as Ghostscript, available from http://hpinkjet.sourceforge.net. This version of Ghostscript includes the patch from version 0.97 of the hpijs software. If you are installing hpijs from an RPM, you will only need the hpijs RPM, not the ghostscript-hpijs one, as the code needed to work with hpijs is already included.

Note that newer version of the hpijs drivers support the IJS protocol. If you can, you should consider using the ijs driver instead. Among other things, the hpijs Ghostscript driver is Unix-only, and is untested on older Unix platforms.

As of the 0.97 version, hpijs supports the following printer models:

e-Series:
e-20
DeskJet 350C Series:
350C
DeskJet 600C Series:
600C, 660C, 670/672C, 670TV, 680/682C
DeskJet 600C Series Photo:
610/612C, 640/648C, 690/692/693/694/695/697C
DeskJet 630C Series:
630/632C
DeskJet 800C Series:
810/812C, 830/832C, 840/842/843C, 880/882C, 895C
DeskJet 900C Series, PhotoSmart::
930/932C, 950/952C, 970C, PhotoSmart 1000/1100
DeskJet 990C, PhotoSmart:
960C, 980C, 990C, PhotoSmart 1215/1218

You will need to add the following line to your makefile:

DEVICE_DEVS2=$(DD)DJ630.dev $(DD)DJ6xx.dev $(DD)DJ6xxP.dev $(DD)DJ8xx.dev $(DD)DJ9xx.dev $(DD)DJ9xxVIP.dev $(DD)AP21xx.dev

Please see http://hpinkjet.sourceforge.net for more information about this driver. Thanks to the folks at HP, especially David Suffield for making this driver available and working to integrate it with Ghostscript.

Gimp-Print driver collection

The Gimp-Print project provides a large collection of printer drivers with an IJS interface. Please see their website for details.


MS Windows printers

This section was written by Russell Lang, the author of Ghostscript's MS Windows-specific printer driver, and updated by Pierre Arnaud, the current maintainer.

The mswinpr2 device uses MS Windows printer drivers, and thus should work with any printer with device-independent bitmap (DIB) raster capabilities. The printer resolution cannot be selected directly using PostScript commands from Ghostscript: use the printer setup in the Control Panel instead. It is however possible to specify a maximum resolution for the printed document (see below).

If no Windows printer name is specified in -sOutputFile, Ghostscript prompts for a Windows printer using the standard Print Setup dialog box. You must set the orientation to Portrait and the page size to that expected by Ghostscript; otherwise the image will be clipped. Ghostscript sets the physical device size to that of the Windows printer driver, but it does not update the PostScript clipping path.

If a Windows printer name is specified in -sOutputFile using the format "%printer%printer_name", for instance

gs ... -sOutputFile="%printer%Apple LaserWriter II NT"

then Ghostscript attempts to open the Windows printer without prompting (except, of course, if the printer is connected to FILE:). Ghostscript attempts to set the Windows printer page size and orientation to match that expected by Ghostscript, but doesn't always succeed. It uses this algorithm:

  1. If the requested page size matches one of the Windows standard page sizes +/- 2mm, request that standard size.
  2. Otherwise if the requested page size matches one of the Windows standard page sizes in landscape mode, ask for that standard size in landscape.
  3. Otherwise ask for the page size by specifying only its dimensions.
  4. Merge the requests above with the defaults. If the printer driver ignores the requested paper size, no error is generated: it will print on the wrong paper size.
  5. Open the Windows printer with the merged orientation and size.

The Ghostscript physical device size is updated to match the Windows printer physical device.

Supported command-line parameters

The mswinpr2 device supports a limited number of command-line parameters (e.g. it does not support setting the printer resolution). The recognized parameters are the following:

-sDEVICE=mswinpr2
Selects the MS Windows printer device. If Ghostscript was not compiled with this device as the default output device, you have to specify it on the command line.
-dNoCancel
Hides the progress dialog, which shows the percent of the document page already processed and also provides a cancel button. This option is useful if GS is intended to print pages in the background, without any user intervention.
-sOutputFile="%printer%printer_name"
Specifies which printer should be used. The printer_name should be typed exactly as it appears in the Printers control panel, including spaces.

Supported options (device properties)

Several extra options exist which cannot be set through the command-line, but only by executing the appropriate PostScript setup code. These options can be set through the inclusion of a setup file on the command-line:

gs ... setup.ps ...

The setup.ps file is responsible for the device selection, therefore you should not specify the -sDEVICE=mswinpr2 option on the command-line if you are using such a setup file. Here is an example of such a setup file:

mark
  /NoCancel      true                       % don't show the cancel dialog
  /BitsPerPixel  4                          % force 4 bits/pixel
  /UserSettings
    <<
      /DocumentName  (Ghostscript document) % name for the Windows spooler
      /MaxResolution 360                    % maximum document resolution
    >>
  (mswinpr2) finddevice                     % select the Windows device driver
  putdeviceprops
setdevice

This example disables the progress dialog (same as the -dNoCancel option), forces a 4 bits/pixel output resolution and specifies additional user settings, such as the document name (which will be displayed by the Windows spooler for the queued document) and the maximum resolution (here 360 dpi). It then finds and selects an instance of the MS Windows device printer and activates it. This will show the standard printer dialog, since no /OutputFile property was specified.

The following options are available:

/NoCancel boolean
Disables (hides) the progress dialog when set to true or show the progress dialog if not set or set to false.
/OutputFile string
Specifies which printer should be used. The string should be of the form %printer%printer_name, where the printer_name should be typed exactly as it appears in the Printers control panel, including spaces.
/QueryUser integer
Shows the standard printer dialog (1 or any other value), shows the printer setup dialog (2) or selects the default Windows printer without any user interaction (3).
/BitsPerPixel integer
Sets the device depth to the specified bits per pixel. Currently supported values are 1 (monochrome), 4 (CMYK with screening handled by Ghostscript) and 24 (True Color, dithering handled by the Windows printer driver; this option can produce huge print jobs).
/UserSettings dict
Sets additional options, defined in a dictionary. The following properties can be set:
/DocumentName string
Defines the user friendly document name which will be displayed by the Windows spooler.
/DocumentRange [n1 n2]
Defines the range of pages contained in the document. This information can be used by the printer dialog, in conjunction with the following property.
/SelectedRange [n1 n2]
Defines the selected range of pages. This information will be displayed in the printer dialog and will be updated after the user interaction. A PostScript program could check these values and print only the selected page range.
/MaxResolution dpi
Specifies the maximum tolerated output resolution. If the selected printer has a higher resolution than dpi, then Ghostscript will render the document with a submultiple of the printer resolution. For example, if MaxResolution is set to 360 and the output printer supports up to 1200 dpi, then Ghostscript renders the document with an internal resolution of 1200/4=300 dpi. This can be very useful to reduce the memory requirements when printing in True Color on some high resolution ink-jet color printers.

These properties can be queried through the currentpagedevice operator. The following PostScript code snippet shows how to do it for some of the properties:

currentpagedevice /BitsPerPixel get ==  % displays the selected depth

currentpagedevice /UserSettings get     % get the additional options..
/us exch def                            % ..and assign them to a variable

us /DocumentName get ==     % displays the document name
us /SelectedRange get ==    % displays the selected page range

% other misc. informations (don't rely on them)

us /Color get ==            % 1 => monochrome output, 2 => color output
us /PrintCopies get ==      % displays the number of copies requested

There are a few undocumented informations stored in the UserSettings dictionary. You should not rely on them. Their use is still experimental and they could be removed in a future version.

Duplex printing

If the Windows printer supports the duplex printing feature, then it will also be available through the mswinpr2 device. You can query for this support through the /Duplex propery of the currentpagedevice. If it returns null, then the feature is not supported by the selected printer. Otherwise, true means that the printer is currently set up to print on both faces of the paper and false that it is not, but that it can.

The following example shows how to print on both faces of the paper (using the long side of the paper as the reference):

<< /Duplex true /Tumble false >> setpagedevice


Sun SPARCprinter

This section was contributed by Martin Schulte.

With a SPARCprinter you always buy software that enables you to do PostScript printing on it. A page image is composed on the host, which sends a bitmap to the SPARCprinter through a special SBUS video interface. So the need for a Ghostscript interface to the SPARCPrinter seems low, but on the other hand, Sun's software prints some PostScript drawings incorrectly: some pages contain a thin vertical line of rubbish, and on some Mathematica drawings the text at the axes isn't rotated. Ghostscript, however, gives the correct results. Moreover, replacing proprietary software should never be a bad idea.

The problem is that there has yet been no effort to make the SPARCPrinter driver behave like a BSD output filter. I made my tests using the script shown here.

Installation

Add sparc.dev to DEVICE_DEVS and compile Ghostscript as described in the documentation on how to build Ghostscript. Afterwards you can use the following script as an example for printing after modifying it with the right pathnames -- including for {GSPATH} the full pathname of the Ghostscript executable:

outcmd1='/vol/local/lib/troff2/psxlate -r'
outcmd2='{GSPATH} -sDEVICE=sparc -sOUTPUTFILE=/dev/lpvi0 -'

if [ $# -eq 0 ]
then
  $outcmd1 | $outcmd2
else
  cat $* | $outcmd1 | $outcmd2
fi

Problems

Since /dev/lpi can be opened only for exclusive use, if another job has it open (engine_ctl_sparc or another Ghostscript are the most likely candidates), Ghostscript stops with "Error: /invalidfileaccess in --.outputpage--"

In case of common printer problems like being out of paper, a warning describing the reason is printed to stdout. The driver tries access again each five seconds. Due to a problem with the device driver (in the kernel) the reason for printer failure isn't always reported correctly to the program. This is the case, for instance, if you open the top cover (error E5 on the printer's display). Look at the display on the printer itself if a "Printer problem with unknown reason" is reported. Fatal errors cause the print job to be terminated.

Note: there is some confusion whether the resolution setting should be the integers 300 and 400, or the symbolic constants DPI300 and DPI400 (defined in lpviio.h). Ghostscript releases have had it both ways. It is currently the latter. However, INOUE Namihiko reports (in SourceForge bug #215256) that the former works better for him. If anyone has a definitive answer, please let us know.


Apple dot matrix printer

This section was contributed by Mark Wedel <master@cats.ucsc.edu>.

The Apple Dot Matrix Printer (DMP) was a parallel predecessor to the Imagewriter printer. As far as I know, Imagewriter commands are a superset of the Dot Matrix printer's, so the driver should generate output that can be printed on Imagewriters.

To print images, the driver sets the printer for unidirectional printing and 15 characters per inch (cpi), or 120dpi. It sets the line feed to 1/9 inch. When finished, it sets the printer to bidirectional printing, 1/8-inch line feeds, and 12 cpi. There appears to be no way to reset the printer to initial values.

This code does not set for 8-bit characters (which is required). It also assumes that carriage return-newline is needed, and not just carriage return. These are all switch settings on the DMP, and I have configured them for 8-bit data and carriage return exclusively. Ensure that the Unix printer daemon handles 8-bit (binary) data properly; in my SunOS 4.1.1 printcap file the string "ms=pass8,-opost" works fine for this.

Finally, you can search devdemp.c for "Init" and "Reset" to find the strings that initialize the printer and reset things when finished, and change them to meet your needs.


Special and Test devices

The devices in this section are intended primarily for testing. They may be interesting as code examples, as well.

Raw 'bit' devices

There are a collection of 'bit' devices that don't do any special formatting but output 'raw' binary data for the page images. These are used for benchmarking but can also be useful when you want to directly access the raster data.

The raw devices are bit bitrgb bitcmyk.

Bounding box output

There is a special bbox "device" that just prints the bounding box of each page. You select it in the usual way:

gs -dSAFER -dNOPAUSE -dBATCH -sDEVICE=bbox

It prints the output in a format like this:

%%BoundingBox: 14 37 570 719
%%HiResBoundingBox: 14.308066 37.547999 569.495061 718.319158

Currently, it always prints the bounding box on stderr; eventually, it should also recognize -sOutputFile=.

Note that this device, like other devices, has a resolution and a (maximum) page size. As for other devices, the product (resolution x page size) is limited to approximately 500K pixels. By default, the resolution is 4000 DPI and the maximum page size is approximately 125", or approximately 9000 default (1/72") user coordinate units. If you need to measure larger pages than this, you must reset both the resolution and the page size in pixels, e.g.,

gs -dNOPAUSE -dBATCH -sDEVICE=bbox -r100 -g500000x500000

Permutation (DeviceN color model)

With no additional parameters, the device named "permute" looks to Ghostscript like a standard CMYK contone device, and outputs a PPM file, using a simple CMYK->RGB transform. This should be the baseline for regression testing.

With the addition of -dPermute=1, the internal behavior changes somewhat, but in most cases the resulting rendered file should be the same. In this mode, the color model becomes "DeviceN" rather than "DeviceCMYK", the number of components goes to six, and the color model is considered to be the (yellow, cyan, cyan, magenta, 0, black) tuple. This is what's rendered into the memory buffer. Finally, on conversion to RGB for output, the colors are permuted back.

As such, this code should check that all imaging code paths are 64-bit clean. Additionally, it should find incorrect code that assumes that the color model is one of DeviceGray, DeviceRGB, or DeviceCMYK.

Currently, the code has the limitation of 8-bit continuous tone rendering only. An enhancement to do halftones is planned as well. Note, however, that when testing permuted halftones for consistency, it is important to permute the planes of the default halftone accordingly, and that any file which sets halftones explicitly will fail a consistency check.


Copyright © 1996-2002 artofcode LLC. All rights reserved.

This software is provided AS-IS with no warranty, either express or implied. This software is distributed under license and may not be copied, modified or distributed except as expressly authorized under the terms of the license contained in the file LICENSE in this distribution. For more information about licensing, please refer to http://www.ghostscript.com/licensing/. For information on commercial licensing, go to http://www.artifex.com/licensing/ or contact Artifex Software, Inc., 101 Lucas Valley Road #110, San Rafael, CA 94903, U.S.A., +1(415)492-9861.

Ghostscript version 8.01, 30 January 2004