- Deprecated Options
- H-P 8xx, 1100, and 1600 color inkjet printers
- H-P 812, 815, 832, 880, 882, 895, and 970 color inkjet printers
- Other H-P color inkjet printers
- Canon BJC-8200 printer
- Other Canon BubbleJet (BJC) printers
- Epson Stylus color printer (see also
uniprint
)- uniprint, a flexible unified printer driver
These devices are no longer supported and/or superceeded by newer methods. The documentation is kept here for reference. Be advised that these devices will be removed in future versions of Ghostscript.
Supported devices are descripted in Details of Ghostscript output devices.
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.
For compatibility with older versions of Ghostscript, -sOUTPUTFILE is a synonym for -sOutputFile. It should not be used in new code.
This section, written by Uli Wortmann <uliw@erdw.ethz.ch>, deals with the DeskJet 670, 690, 850, 855, 870, 890, 1100, and 1600.
gdevcd8.c
The source module gdevcd8.c
contains four generic drivers:
cdj670
HP DeskJet 670 and 690 cdj850
HP DeskJet 850, 855, 870, and 1100 cdj890
HP DeskJet 890 cdj1600
HP DeskJet 1600
Credits: Much of the driver is based on ideas derived from the cdj550 driver of George Cameron. The support for the hp670, hp690, hp890 and hp1600 was added by Martin Gerbershagen.
11.11.96 Version 1.0 25.08.97 Version 1.2 Resolved all but one of the known bugs, introduced a couple of perfomance improvements. Complete new color-transfer-function handling (see gamma). 01.06.98 Version 1.3 Due to the most welcome contribution of Martin Gerbershagen (ger@ulm.temic.de), support for the hp670, hp690 and hp890 and hp1600 has been added. Martin has also resolved all known bugs. Problems:Dark colors are still pale.
The hp690 is supported through the hp670 device, the hp855, hp870 and the
hp1100 through the hp850 device. The driver needs no longer special
switches to be invoked except -sDEVICE=cdj850
,
-sDEVICE=CDJ890
, -sDEVICE=CDJ670, or
-sDevice=CDJ1600
. The following switches are supported.
-dPapertype=
0 plain paper [default] 1 bond paper 2 special paper 3 glossy film 4 transparency film Currently the lookup tables are unsuited for printing on special paper or transparencies. For these please revert to the gamma functions. -dQuality=
-1 draft 0 normal [default] 1 presentation -dRetStatus=
0 C-RET off 1 C-RET on [default] -dMasterGamma=
3.0 [default = 1.0]
Note: To take advantage of the calibrated color-transfer functions, be sure not to have any gamma statements left! If you need to (i.e., for overhead transparencies), you still can use the gamma functions, but they will override the built-in calibration. To use gamma in the traditional way, set MasterGamma to any value greater than 1.0 and less than 10.0. To adjust individual gamma values, you have to additionally set MasterGamma to a value greater than 1.0 and less than 10.0. With the next release, gamma functions will be dropped.
When using the driver, be aware that printing at 600dpi involves
processing large amounts of data (> 188MB !). Therefore the
driver is not what you would expect to be a fast driver ;-)
This is no problem when printing a full-sized color page (because
printing itself is slow), but it's really annoying if you print only
text pages. Maybe I can optimize the code for text-only pages in a
later release. Right now, it is recommended to use the highest
possible optimisation level your compiler offers.
For the time being, use the cdj550 device with -sBitsPerPixel=3
for fast proof prints. If you simply want to print 600dpi BW data,
use the cdj550 device with -sBitsPerPixel=8
(or 1).
Since the printer itself is slow, it may help to set the process priority
of the gs process to "regular" or even less. On a 486/100MHz this is still
sufficient to maintain a continuous data flow. Note to OS/2 users: simply
put the gs window into the background or minimize it. Also make sure that
print01.sys
is invoked without the /irq
switch (great speed improvement under Warp4).
The printer default settings compensate for dot-gain by a calibrated
color-transfer function. If this appears to be too light for your business
graphs, or for overhead transparencies, feel free to set
-dMasterGamma=1.7
. Furthermore, you may tweak the gamma
values independently by setting -dGammaValC
,
-dGammaValM
, -dGammaValY or
-dGammaValK
(if not set, the values default to
MasterGamma
). This will only work when
-dMasterGamma
is set to a value greater than 1.0.
Further information, bugs, tips etc, can be found at my website. To learn more about gamma, see ftp://ftp.igd.fhg.de/pub/doc/colour/GammaFAQ.pdf.
Depending on how you transfer the files, under UNIX you may need to remove
the CRs of the CR-LF sequence used for end-of-line on DOS-based (MS
Windows-based) systems. You can do this in unpacking the files with unzip -a hp850.zip
.
To compile with gs5.x or later, simply add to your makefile
DEVICE_DEVS4=cdj850.dev cdj670.dev cdj890.dev cdj1600.dev
Have fun!
Uli <uliw@erdw.ethz.ch>
http://www.erdw.ethz.ch/~bonk/
This section, written by Matthew Gelhaus <hp880@gelhaus.net>, deals with the DeskJet 812, 815, 832, 880, 882, 895, and 970.
This is a modified version of the HP8xx driver written by Uli Wortmann. More information and download are available at http://www.gelhaus.net/hp880c/.
gdevcd8.c
The source module gdevcd8.c
contains one generic driver:
cdj880
HP DeskJet 812, 815, 832, 880, 882, 895, and 970
Credits: This driver is based on the cdj850 driver by Uli Wortmann, and shares the same internal structure, although the PCL3+ interpretation has changed.
15.03.99 Version 1.3 Initial version, based on Version 1.3 of Uli Wortmann's driver. 26.02.00 Version 1.4beta Greatly improved color handling & dithering, but not yet complete enough to use for text.
All printers are supported through the cdj880 device. Invoke with
-sDEVICE=cdj880
. The following switches are supported.
-dPapertype=
0 plain paper [default] 1 bond paper 2 special paper 3 glossy film 4 transparency film Currently the lookup tables are unsuited for printing on special paper or transparencies. For these please revert to the gamma functions. -dQuality=
-1 draft 0 normal [default] 1 presentation -dMasterGamma=
3.0 [default = 1.0]
The printer default settings compensate for dot-gain by a pre-defined
color-transfer function. If this appears to be too light for your business
graphs, or for overhead transparencies, feel free to set
-dMasterGamma=1.7
. Furthermore, you may tweak the gamma
values independently by setting -dGammaValC
,
-dGammaValM
, -dGammaValY or
-dGammaValK
(if not set, the values default to
MasterGamma
). This will only work when
-dMasterGamma
is set to a value greater than 1.0.
Further information, bugs, tips etc, can be found at my website.
To compile with gs6.x or later, simply add to your makefile
DEVICE_DEVS4=$(DD)cdj880.dev
Matthew Gelhaus <mailto:hp880@gelhaus.net>
http://www.gelhaus.net/hp880c/
This section, written by George Cameron, deals with the DeskJet 500C, DeskJet 550C, PaintJet, PaintJet XL, PaintJet XL300, the DEC LJ250 operating in PaintJet-compatible mode.
gdevcdj.c
The source module gdevcdj.c
contains six generic drivers:
cdj500
HP DeskJet 500C and 540C cdj550
HP DeskJet 550C, 560C, 660C, 660Cse pjxl300
HP PaintJet XL300, DeskJet 1200C, and CopyJet pjtest
HP PaintJet pjxltest
HP PaintJet XL declj250
DEC LJ250
All these drivers have 8-bit (monochrome), 16-bit and 24-bit (colour) and for the DJ 550C, 32-bit (colour, CMYK mode) options in addition to standard colour and mono drivers. It is also possible to set various printer-specific parameters from the command line, for example
gs -sDEVICE=cDeskJet -dBitsPerPixel=16 -dDepletion=1 -dShingling=2 tiger.eps
Note: the old names cDeskJet
,
cdjcolor
and cdjmono drivers have been
retained; however, their functionality duplicates that available using the
drivers above (and cDeskJet
is identical to
cdj500
). That is, we can use
gs -sDEVICE=cdj500 -dBitsPerPixel=24
for cdjcolor
, andgs -sDEVICE=cdj500 -dBitsPerPixel=1
for cdjmono
If the preprocessor symbol A4
is defined, the default paper
size is ISO A4; otherwise it is U.S. letter size (see about
paper sizes in the usage
documentation). You can specify other paper
sizes on the command line, including A3 for the PaintJet XL and
PaintJet XL300, as also explained in the usage documentation.
The DeskJet's maximum printing width is 2400 dots, or 8 inches (20.32cm). The printer manuals say that the maximum recommended printing height on the page is 10.3 inches (26.16cm), but since this is obviously not true for A4 paper, and I have been unable to detect any problems in printing longer page lengths, this would seem to be a rather artificial restriction.
All DeskJets have 0.5 inches (1.27cm) of unprintable bottom margin, due to the mechanical arrangement used to grab the paper. Side margins are approximately 0.25 inches (0.64cm) for U.S. letter paper, and 0.15 inches (0.38cm) for A4.
Several printer "properties" have been implemented for these printers. Those available so far are all integer quantities, and thus may be specified, for instance, like
gs -dBitsPerPixel=32 -dShingling=1
...
which sets the BitsPerPixel
parameter to 32 and the
Shingling
parameter to 1.
If the preprocessor symbol BITSPERPIXEL
is defined as an
integer (see below for the range of allowable values), that number defines
the default bits per pixel (bit depth) for the generic drivers. If the
symbol is undefined, the default is 24 bits per pixel. It is, of course,
still possible to specify the value from the command line as described
below. Note also that the cDeskJet
,
cdjcolor
and cdjmono drivers are unaffected
by setting this symbol, as their default settings are predefined to be 1, 3
and 24 respectively.
All of the drivers in gdevcdj.c
accept a command line
option to set the BitsPerPixel
property. This gives
considerable flexibility in choosing various tradeoffs among speed,
quality, colour, etc. The valid numbers are:
- 1
- A standard Ghostscript monochrome driver, using black ink (by installing the separate mono cartridge in the case of the DeskJet 500C, or automatically for the other printers).
- 3
- A standard Ghostscript colour driver, using internal dithering. This is fast to compute and to print, but the clustered dithering can lose some detail and colour fidelity.
- 8
- An "error-diffusion" monochrome driver which uses Floyd-Steinberg dithering to print greyscale images. The patterns are much more randomised than with the normal clustered dithering, but the data files can be much larger and somewhat slower to print.
- 16
- A "cheaper" version of the 24-bit driver, which generates Floyd-Steinberg colour dithered output using the minimum memory (this may be helpful when using Ghostscript has not been compiled using a 16-bit build environment). The quality can be almost as good as the 24-bit version.
- 24
- A high-quality colour driver using Floyd-Steinberg dithering for maximum detail and colour range. However, it is very memory-intensive, and thus can be slow to compute. It tends to produce rather larger raw data files, so they can also take longer to print.
- 32
- Only for the DeskJet 550C, which uses the black cartridge and the colour cartridge simultaneously (that is, CMYK printing). This printer can both be faster and give higher quality than the DeskJet 500C, because of the true black ink. (Note that the 24-bit mode also permits CMYK printing on this printer, and uses less memory. Any differences between 24-bit and 32-bit should be small.)
Name Type
BlackCorrect
int
Colour correction to give better blacks when using the DJ500C in colour mode. For example, the default of 4 reduces the cyan component to 4/5. Range accepted: 0 - 9 (0 = none). Shingling
int
Interlaced, multi-pass printing: 0 = none, 1 = 50%, 2 = 25%, 2 is best and slowest. Depletion
int
"Intelligent" dot-removal: 0 = none, 1 = 25%, 2 = 50%, 1 best for graphics? Use 0 for transparencies.
Name Type
PrintQuality
int
Mechanical print quality: -1 = fast, 0 = normal, 1 = presentation. Fast mode reduces ink usage and uses single-pass operation for some media types. Presentation uses more ink and the maximum number of passes, giving slowest printing for highest quality RenderType
int
- 0
- driver does dithering
- 1
- snap to primaries
- 2
- snap black to white, others to black
- 3
- ordered dither
- 4
- error diffusion
- 5
- monochrome ordered dither
- 6
- monochrome error diffusion
- 7
- cluster ordered dither
- 8
- monochrome cluster ordered dither
- 9
- user-defined dither (not supported)
- 10
- monochrome user-defined dither ns.
The PaintJet (non-XL) has no additional properties.
One consequence of using Floyd-Steinberg dithering rather than Ghostscript's default clustered ordered dither is that it is much more obvious that the ink dots are rather larger on the page than their nominal 1/180-inch or 1/300-inch size (clustering the dots tends to minimise this effect). Thus it is often the case that the printed result is rather too dark. A simple empirical correction for this may be achieved by preceding the actual PostScript file to be printed by a short file which effectively sets the gamma for the device, such as
gs ... gamma.ps colorpic.ps -c quit
where gamma.ps
is
%! /.fixtransfer { currentcolortransfer 4 { mark exch dup type dup /arraytype eq exch /packedarraytype eq or 1 index xcheck and { /exec load } if 0.333 /exp load ] cvx 4 1 roll } repeat setcolortransfer } bind odef .fixtransfer /setpagedevice { setpagedevice .fixtransfer } bind odef
This does the gamma correction after whatever correction the device might be doing already. To do the correction before the current correction,
%! /.fixtransfer { currentcolortransfer 4 { mark 0.333 /exp load 4 -1 roll dup type dup /arraytype eq exch /packedarraytype eq or 1 index xcheck and { /exec load } if ] cvx 4 1 roll } repeat setcolortransfer } bind odef .fixtransfer /setpagedevice { setpagedevice .fixtransfer } bind odef
This example sets the gamma for R, G, and B to 3, which seems to work reasonably well in practice.
This feature is available on HP's more recent inkjet printers, including the DeskJet 520 (mono), 540 (mono or colour) and 560C (mono and colour). The colour and monochrome drivers for the HP DeskJet 550c are (probably) the best you will get for use with Ghostscript, for the following reasons.
These printers do not offer true 600×300dpi resolution. Those that print in colour are strictly 300×300dpi in colour mode, while in mono mode there is a pseudo 600×300dpi mode with the restriction that you can't print two adjacent dots. In effect what you have is 600dpi dot positioning, but on average you don't get more dots per line. This provides the possibility, for instance, to have sharper character outlines, because you can place dots on the edges nearer to their ideal positions. This is why it is worth doing.
However, HP will not support user-level programming of this resolution-enhanced mode, one reason being that (I understand) all the dot spacing has to be done by the driver, and if you get it wrong, you can actually damage the print head.
To summarise, you may lose a smidgin of (potential) text clarity using the
550c drivers (cdj550
, cdjcolor,
cdjmono
etc.), but other than that, they are the ones for
the job.
For all the printers above, the choice of paper is critically important to the final results. The printer manuals suggest type of paper, but in general, smoother, less fibrous types give better results. In particular, the special ink-jet paper can make a big difference: colours are brighter, but most importantly, there is almost no colour bleed, even with adjacent areas of very heavy inking. Similarly the special coated transparencies also work well (and ordinary transparencies do not work at all!).
The Unix procedure unix-lpr.sh
provides one example of setting up a multi-option colour PostScript
lpr
queue on Unix systems, and includes the ability to
choose a range of different colour options and printer accounting and error
logging.
Caveat emptor! It is not always easy for me to test all of these drivers, as the only colour printer I have here is the DeskJet 500C. I rely on others to test drivers for the additional machines and report their findings back to me.
This section was contributed by the author of the uniprint
configuration files for the Canon BJC-8200, Stephan C. Buchert <scb@stelab.nagoya-u.ac.jp>.
These files also handle the Japanese Canon F850 printer.
Warning: Usage of this program is neither supported nor endorsed by the Canon corporation. Please see the Ghostscript license regarding warranty.
The Canon Bubble Jet printer BJC-8200 is designed for printing digital photos and halftone images. Software drivers for Windows 95-2000 and Mac are usually included and can be downloaded from the Canon web sites like http://consumer.usa.canon.com/bjc/bjc8200/ for the US market. If these drivers cannot be used for some reason, then at present Ghostscript is probably the alternative giving the best results.
The BJC-8200 has features not found among the specs of earlier bubble jet models (except the even more advanced BJC-8500) and is advertised to offer:
Access to features 5 and 6 requires use of the original Canon drivers for the foreseeable future. This README is about getting the printer features 1-3 working with Ghostscript. No (re)compilation of Ghostscript is normally required.
Ghostscript comes with a relatively highly configurable driver, called uniprint, for printers which understand raster images in various propriety formats. Most options for this driver are usually organized into files having the suffix ".upp." Ghostscript versions >= 5.10 (or even earlier) include such uniprint control files for the Canon BJC-610. They work also well for some other Canon Bubble Jet models, for example for my BJC-35vII. But when using them for a BJC-8200 the result is unsatisfactory.
After some experimenting with the options for uniprint I have obtained quite satisfactory prints with my printer(*). This distribution includes six new uniprint control files:
They are included in Ghostscript >=6.21. For older versions you can put them anywhere in the Ghostscript search path (type "gs -h" to see the path), but should perhaps add the files to the directory with the other *.upp files. This is "/usr/share/ghostscript/gs6.01/lib" in my RedHat 6.1 Linux box with Aladdin Ghostscript 6.01.
Here is an explanation of my file name convention: the prefix "bj8" should perhaps be used for the Canon BJC-8200 and compatible (like the Japanese F850 and perhaps the non-Japanese BJC-8500) models. The next two letters indicate the print media:
The numbers at positions 6 and 7 indicate the resolution
The last letter stands for a quality factor that effects also the print speed (presumably related to the number of passes that the printhead makes).
Printing a postcard size (~10x15 cm^2) image at 1200x1200 DpI^2 takes about 3 minutes. The output of Ghostscript is then typically 4-5 MByte. The bootleneck seems to be the transfer of the raster image in run-length encoded Canon format to the printer (via the parallel port on my system) or the printer's speed, not Ghostscript or the uniprint renderer.
Here is information useful for changing or adding uniprint control files for the BJC-8200:
In "-dupBeginPageCommand=..." use the line
1b28 64 0400 04b0 04b0
for 1200x1200 resolution, and
1b28 64 0400 0258 0258
for 600x600. The "-r" option in the control file must of course match this line. Other resolutions might work as well, but I didn't try.
Crucial are the numbers in the lines like
1b28 63 0300 3005 04 ^ ^ Plain Paper 0 4 Highest quality OHP transparency 2 . T-shirt transfer 3 . Glossy Photo Film 5 . High Gloss Paper 6 0 Lowest quality Photo Paper Pro 9
Presently uniprint can use the black (K), cyan (C), magenta (M), and yellow (Y) colors in the BJC-8200. The unused colors are photo (or light) cyan (c) and magenta (m). Also the Canon driver seems to use only CMYK, for example when printing on Photo Paper Pro in "Camera" or "SuperPhoto" mode. These modes supposedly produce prints of the best quality that the Canon driver can offer. Other modes of Canon driver do use up to all six color cartridges (CMYKcm). Therefore expanding uniprint's capabilities for six colors would be interesting, but it may not increase the output quality of 6-color printers such as the BJC-8200 drastically.
More control files for uniprint could be added in order to offer more versatility for controlling the BJC-8200 within a Ghostscript installation. The number of possible combinations for media type, resolution and print quality factor is very large, many combinations would not make much sense, many might be used here and there, but relatively rarely. The user would have to remember a name for each combination that is used.
A better way would be to let the user patch optionally a user owned or system wide uniprint control file before each print via some print tool. This is similar to the approach taken by Canon with their driver for Windows. Similarly a uniprint tool could also incorporate other functions such as printing test and demo pages and the low ink warning once the protocol for this is known. Clearly it would be difficult to code such a uniprint tool for all the platforms where Ghostscript is running.
In order to install a BJC-8200 printer on a RedHat Linux system with
RedHat's printtool, you need also to insert with a text editor the contents
of the file bj8.rpd
into the RedHat printer database
/usr/lib/rhs/rhs-printfilters/printerdb
. Insert it most
appropriately after the section
StartEntry: U_CanonBJC610 . . . EndEntry < --- insert here "bj8.rpd" from this distribution: < --- StartEntry: U_CanonBJC8200 . . .
E-mail address: <scb@stelab.nagoya-u.ac.jp>
Footnotes:
(*) Actually I have a F850, not a BJC-8200. That model is sold for the Japanese market only. The specs and also the external look are the same as those of the BJC-8200 models for the American and European markets. I expect that the raster image mode which is used exclusively by Ghostscript is entirely compatible for both models.
Stephan C. Buchert
This section was contributed by the author of the drivers, Yves Arrouye (<yves.arrouye@usa.net>, but please do not send questions to him: he no longer maintains these drivers.) The drivers handle Canon BJC-600, BJC-4xxx, BJC-70, Stylewriter 2x00, and BJC-800 printers.
The BJC-600 driver was written in the first place by Yoshio Kuniyoshi and later modified by Yves Arrouye. We tried to make it evolve synchronously, though Yoshio cannot be reached since a long time ago. The drivers are based on code for the HP printers by George Cameron (in fact, they are in the same file!), so he's the first person to thank.
The 2.00 version of the drivers was a complete rewrite of the driver (arguments, optimization, colour handling, in short: everything!) by Yves Arrouye. That release was also the first one to be able to use the full width of an A3 paper size. PostScript Printer Description (PPD) files for the drivers were released with version 2.15. They are incomplete, but they can be used to drive the printers' main features.
gdevbjc.h
Configure the drivers by modifying the default values in the file
gdevbjc.h
or on the compilation line. If you don't do
that, the drivers use reasonable defaults that make them work "as
expected". All default values shown here are defined in that file.
By default, the drivers use the same algorithm as Ghostscript to convert
CMYK colors to RGB. If you prefer to use Adobe formulas, define
USE_ADOBE_CMYK_RGB
when compiling. (See the top of the
file gdevcdj.c
to see the difference between the two.)
The drivers center the imageable area horizontally but not vertically, so
that what can be printed does use the most of the output media. If you
define BJC_DEFAULT_CENTEREDAREA
when compiling, then the
top and bottom margins will be the same, resulting in a (smaller)
vertically centered imageable area also.
If you define USE_RECOMMENDED_MARGINS
, then the top and
bottom margins will be the same (that is,
BJC_DEFAULT_CENTEREDAREA
will be defined for you) and the
margins will be the 12.4mm recommended by Canon. Since margins are
complicated (because one must rely on the mechanical precision of the
printer), the drivers do something about the bottom margin: by default the
bottom margin is 9.54mm for the BJC-600 driver and 7mm for the BJC-800. If
you define USE_TIGHT_MARGINS
, then the bottom margin is 7mm
for both drivers (but I never managed to get my own BJC-600 to print a line
on this low bound, hence the larger default). Regardless of the presence
of this definition, USE_FIXED_MARGINS
will not allow the
BJC-800 to use the lower 7mm bottom margin, so if you have a problem with
the bottom margin on a BJC-800, just define that (without defining
USE_TIGHT_MARGINS
, of course).
A quick way to be sure the margins you selected is to print a file whose contents are:
%!
clippath stroke showpage
If the margins are okay, you will get a rectangle visibly surrounding the printable area. If they're not correct, one or more of the sides will be either incomplete or completely unprinted.
Make sure the bjc600
or bjc800 devices are
in DEVICE_DEVS
in
the makefile; that is, look in the makefile for your platform and add
them if necessary -- they may already be there. As of Ghostscript 5.10,
for instance, one makefile has
DEVICE_DEVS6=bj10e.dev bj200.dev bjc600.dev bjc800.dev
There are two drivers here. The "bjc600
" one supports the BJC-600 and
BJC-4xxx (maybe the BJC-70 as well) and the "bjc800
" one supports the
BJC-800 series. Remarks here that apply to both drivers use the name
"bjc".
Note: "options", "properties", and "parameters" designate the same thing: device parameters that you can change.
Giving an option an incorrect value causes an error. Unless stated
otherwise, this error will be a rangecheckerror. Options may be set from
the Ghostscript command line (using the -d
and
-s
switches or other predetermined switches if they have an
effect on the driver) or using the PostScript Level 2
setpagedevice
operator if Ghostscript has been compiled
with the level2
or level3 device (which it should
;-)
). There are no special-purpose operators such as
one was able to find in Level 1 printers.
The bjc uses 24 bits per pixel by default (unless you change the value of
BJC_BITSPERPIXEL
), corresponding to CMYK printing.
Supported modes are 1 bpp and 4 bpp (gray levels), 8 bpp, 16 bpp, 24 bpp
and 32 bpp (colours). Colours are preferably stored in the CMYK model
(which means, for example, that with 16 bpp there are only 16 different
shades of each color) but it is possible to store them as RGB color for
some depths. Some modes do Floyd-Steinberg dithering and some don't, but
use the default Ghostscript halftoning (in fact, when halftoning is used,
dithering takes also place but because of the low point density it is
usually not efficient, and thus invisible).
Descriptions of printing modes by bpp andColors
bpp Colors
Mode
32 4 CMYK colour printing, Floyd-Steinberg dithering 24 4 The same. (But each primary colour is stored on 6 bits instead of 8.) 24 3 RGB colour printing, Floyd-Steinberg dithering. This mode does not
use the black cartridge (that's why it exists, for when you don't want to use it;-)
). Each primary colour is stored in 8 bits as in the 32/4 mode, but black generation and under-color removal are done on the driver side and not by Ghostscript, so you have no control over it. (This mode is no longer supported in this driver.)16 4 CMYK colour printing, halftoned by Ghostscript. F-S dithering is still visible here (but the halftone patterns are visible too!). 8 4 The same. (But each primary colour is stored in 2 bits instead of 4.) 8 3 RGB colour printing. This mode is not intended for use. What I mean is that it should be used only if you want to use custom halftone screens and the halftoning is broken using the 8/4 mode (some versions of Ghostscript have this problem). 8 1 Gray-level printing, Floyd-Steinberg dithering 1 1 Gray-level printing halftoned by Ghostscript
These modes are selected using the BitsPerPixel
and
Colors
integer options (either from the command line or in
a PostScript program using setpagedevice
). See below.
A note about darkness of what is printed: Canon printers do print dark, really. And the Floyd-Steinberg dithering may eventually darken your image too. So you may need to apply gamma correction by calling Ghostscript as in
gs -sDEVICE=bjc600 gamma.ps myfile.ps
where gamma.ps
changes the gamma correction (here to 3 for
all colors); 0.45 gives me good results, but your mileage may vary. The
bigger the value the lighter the output:
{ 0.45 exp } dup dup currenttransfer setcolortransfer
The drivers support printing at 90dpi, 180dpi and 360dpi. Horizontal and
vertical resolutions must be the same or a limitcheck error will happen. A
rangecheck will happen too if the resolution is not
90 ×2^N. If the driver
is compiled with -DBJC_STRICT
a rangecheck also happens if
the resolution is not one of those supported. This is not the case, as we
expect that there may be a 720dpi bjc some day.
Here are the various options supported by the bjc drivers, along with their types, supported values, effects, and usage:
BitsPerPixel
(int)
Note that when this is set for the first time, the Colors
property is automatically adjusted unless it is also specified. The table
here shows the corresponding color models and the rendering method visible:
"GS" for Ghostscript halftoning and "F-S" for Floyd-Steinberg dithering.
When both are present it means that the dithering of halftones is visible.
Default choices are indicated by asterisk "*".
ValidColors
values for
allowed BitsPerPixel values
bpp Colors
Color model Dithering
32 4 CMYK F-S 24 4 * CMYK F-S 3 RGB F-S 16 4 CMYK GS, F-S 8 4 * CMYK GS 3 RGB GS 1 K (CMYK) F-S 1 1 * K (CMYK) GS
Also note that automagical change of one parameter depending on the
other one does not work in a setpagedevice
call. This
means that if you want to change BitsPerPixel
to a value
whose valid Colors
values do not include the actual
Colors
value, you must change Colors too.
Colors
(int)
ProcessColorModel
below
for what to use to change the number of colors with PostScript code.
Note that setting this property does limit the choices of
BitsPerPixel
. As for the previous property, its first
setting may induce a setting of the "other value"
(BitsPerPixel
here). The table here indicates valid
combinations with "V", default values with asterisk "*".
ValidBitsPerPixel
values
for allowed Colors values
BitsPerPixel
OK values
Colors Type 32 24 16 8 1
4 CMYK V * V V 3 RGB * V 1 K V *
Also note that automagical change of one parameter depending on the
other one does not work in a setpagedevice
call. This
means that if you want to change Colors
to a value whose
valid BitsPerPixel
values don't include the actual
BitsPerPixel
value, you must change
BitsPerPixel
too.
ProcessColorModel
(symbol)
/DeviceGray
,
/DeviceRGB
or /DeviceCMYK which can be used
to select 1, 3 or 4 colors respectively. Note that this parameter takes
precedence over Colors
, and that both affect the same
variable of the driver. (See Colors
above for values
combined with BitsPerPixel
.)
HWResolution
(floats array)
-r
switch.
ManualFeed
(bool)
false
by default. (Not meaningful on the BJC-600, I fear.)
MediaType
(string)
PlainPaper
",
"CoatedPaper
", "TransparencyFilm",
"Envelope
", "Card" and
"Other
". Default is "PlainPaper". For
"Envelope
", "Card" or
"Other
" the driver puts the printer into thick mode
automatically regardless of the actual media weight.
MediaWeight
(int or null)
BJC
???_MEDIAWEIGHT_THICKLIMIT) then the
printer will be set to use thick paper.
PrintQuality
(string)
Value | bjc600
| bjc800
| ||||
---|---|---|---|---|---|---|
Low
| X | Has the effect of making only two printing passes instead of four, so should be twice the speed; known as "CN" (Color Normal) mode | ||||
Draft
| X | X | Unlights the "HQ" light on a BJC-600 | |||
Normal
| X | X | Default for both drivers; lights the "HQ" light on a BJC-600 | |||
High
| X | X | Means 200% black and 100% CMY; lights the "Bk+" light on a BJC-600 |
DitheringType
(string)
Floyd-Steinberg
" and
"None
". "None" is the default for 1/1 print
mode, "Floyd-Steinberg
" for other modes. At the moment
this parameter is read-only, though no error is generated if one tries to
change it. This parameter is not of much value at the moment and is here
mainly to reserve the name for future addition of dithering algorithms.
PrintColors
(int)
PrintColors
;
otherwise, the image is printed by superimposing each requested color.
MonochromePrint
(bool)
false
by default.
Substitute black for Cyan, Magenta and Yellow when printing -- useful, for
example, to get some monochrome output of a dithered printing This is a
hardware mechanism as opposed to the previous software one. I think that
using this or setting PrintColors
to 0 will give the same
results.
Note that the MediaType
and ThickMedia
options will be replaced by the use of the device
InputAttributes
and OutputAttributes as
soon as possible. Please note too that the print mode may be reset at the
start of printing, not at the end. This is the expected behaviour. If you
need to reset the printer to its default state, simply print a file that
does just a showpage
.
Here is other information published by the driver that you will find
in the deviceinfo
dictionary.
OutputFaceUp
(bool)
true
, indicating that the
sheets are stacked face up.
Version
(float)
M.
mm will always be
the same for the bjc600
and bjc800
drivers).
VersionString
(string)
The BJC printers have top and bottom hardware margins of 3mm and 7.1mm respectively (Canon says 7mm, but this is unusable because of the rounding of paper sizes to PostScript points). The left margin is 3.4mm for A4 and smaller paper sizes, 6.4mm for U.S. paper sizes, envelopes and cards. It is 4.0mm for A3 paper on the BJC-800.
The maximum printing width of a BJC-600 printer is 203mm. The maximum printing width of a BJC-800 printer is 289mm on A3 paper, 203mm on U.S. letter and ISO A4 paper.
The files CBJC600.PPD
and CBJC800.PPD (whose
long names are, respectively, Canon_BubbleJetColor_600.ppd
and Canon_BubbleJetColor_800.ppd
) are PPD files to drive the
features of the bjc600
and bjc800 drivers.
They can be used, for example, on NextStep systems (presumably on OpenStep
systems too) and on Unix systems with Adobe's TranScript and
pslpr
(not tested). The files are not complete at the
moment. Please note that NextStep's printing interface does not
correctly enforce constraints specified in these files (in UIConstraints
descriptions): you must force yourself to use valid combinations of
options.
By default the PPD files are set for U.S. letter size paper, and they use a
normalized transfer function. If you choose to use A4 printing by default,
you must replace "Letter
" with "A4" in
these (noncontiguous) lines:
[...]
*DefaultPageSize: Letter
[...]
*DefaultRegion: Letter
[...]
*DefaultImageableArea: Letter
[...]
Some versions of Ghostscript have problems with normalized colors, which makes them add magenta in gray levels. If you experience this problem, in the PPD file replace the line
*DefaultTransfer: Normalized
with the alternate line
*DefaultTransfer: Null
The "thick media" option is implemented by choosing a value of 120 or 80
(for thick and thin media respectively) for the MediaWeight
feature of the drivers. If you ever change the threshold for thick media
in the driver code, you may need to change the values in the PPD files too.
All customization should be done using the "*Include:
"
feature of PPD files so that your local changes will be retained if you
update the PPD files.
Yves Arrouye no longer maintains this driver, and will not answer questions about it. If you are posting a question about it in a public form, please be as descriptive as possible, and please send information that can be used to reproduce the problem. Don't forget to say which driver you use, and in what version. Version information can be found in the source code of the driver or by issuing the following command in a shell:
echo "currentpagedevice /VersionString get ==" | gs -q -sDEVICE=bjc600 -
I am particularly grateful to Yoshio Kuniyoshi <yoshio@nak.math.keio.ac.jp> without whom I'd never make these drivers, and also to L. Peter Deutsch, who answered all my (often silly) questions about Ghostscript's driver interface.
Thanks also to the people who volunteered to beta-test the v2.x BJC drivers: David Gaudine <david@donald.concordia.ca>, Robert M. Kenney <rmk@unh.edu>, James McPherson <someone@erols.com> and Ian Thurlbeck <ian@stams.strath.ac.uk> (listed alphabetically) were particularly helpful by discovering bugs and helping find out exact paper margins on printers I don't have access to.
And many thanks to Klaus-Gunther Hess <ghess@elmos.de> for looking at the dithering code and devising a good CMYK dithering algorithm for the Epson Stylus Color, which I then adapted to the code of these drivers.
uniprint
)
This section was contributed by Gunther Hess
<ghess@elmos.de>, who also wrote
uniprint
, a later set of drivers. You should probably see
the section on uniprint
for whether
it might be better for your uses than this driver.
This driver is selected with "-sDEVICE=stcolor
", producing
output for an Epson Stylus Color at 360dpi resolution by default. But it
can do much more with this printer, and with significantly better quality,
than with the default mode; and it can also produce code for monochrome
versions of the printer. This can be achieved via either command-line
options or Ghostscript input. For convenience a PostScript file is
supplied for use as an initial input file. Try the following command:
gs -sDEVICE=stcolor -r
{Xdpi}x{Ydpi} stcolor.ps {YourFile.ps}
where {Xdpi} is one of 180, 360, or 720 and {Ydpi} is one of
90, 180, 360, or 720. The result should be significantly better. You may
use stcolor.ps
with other devices too, but I do not
recommend this, since it does nothing then. stcolor.ps
should be available with binary distributions and should reside in the same
directory as other Ghostscript initialization files or in the same
directory as the files to be printed. Thus if Ghostscript is part of your
printer-spooler, you can insert
(stcolor.ps) findlibfile { pop run } if pop
in files you want to use the improved algorithms. You may want to adapt
stcolor.ps
file to your specific needs. The methods and
options for this are described here, but this description is restricted to
Ghostscript options, while their manipulation at the PostScript level is
documented in the material on the relationship of
Ghostscript and PostScript and in stcolor.ps
.
Now to explain the options (as written on my UNIX system). The order is somehow related to their use during the printing process:
-dUnidirectional
-dMicroweave
-dnoWeave
-dMicroweave
)
-dSoftweave
Softweave
works only with the original Stylus Color and the PRO-Series.
-sDithering=
{name}
gscmyk
fast color output, CMYK process color model (default) gsmono
fast monochrome output gsrgb
fast color output, RGB process color model fsmono
Floyd-Steinberg, monochrome fsrgb
Floyd-Steinberg, RGB process color model (almost identical to the cdj550
/bjc algorithm)fsx4
Floyd-Steinberg, CMYK process color model (shares code with fsmono
and fsrgb, but is algorithmically really bad)fscmyk
Floyd-Steinberg, CMYK process color model and proper modifications for CMYK hscmyk
modified Floyd-Steinberg with CMYK model ("hs" stands for "hess" not for "high speed", but the major difference from fscmyk
is speed)fs2
algorithm by Steven Singer (RGB) should be identical to escp2cfs2
.
-dBitsPerPixel=
{1...32}
fsrgb
one can gain
some speed by restricting to 24 bits rather than the default 30.
-dFlag0
hscmyk
and all fs modes,
except for fs2, which always uses a constant initialization.)
-dFlag1
... -dFlag4
-dColorAdjustMatrix='{
three, nine, or sixteen
floating-point values}'
-dCtransfer='{
float float ...}' or
-dMtransfer=
..., -dY..., -dK... or
-dRtransfer='{
float float ...}' or
-dG
..., -dB... or
-dKtransfer='{
float float ...}'
setcolortransfer
at the
language level, but this takes more time and the underlying code for the
driver-specific parameters is still required. The size of the arrays is
arbitrary and the defaults are "{0.0 1.0}
", which is a
linear characteristic. Most of the code in stcolor.ps
are
better transfer arrays.
-dKcoding='{
float...}'
-dC
..., -dM... etc.
-sModel=st800
-sOutputCode=
{name}
plain
", "runlength" or
"deltarow
" and changes the ESC/P2 coding technique
used by the driver. The default is to use runlength encoding.
"plain
" selects uncompressed encoding and generates
enormous amounts of data.
-descp_Band=
1/8/15/24
-dnoWeave
. Larger Values yield smaller code, but this
doesn't increase the printing speed.
-descp_Width=
N
-descp_Height=
pixels
ESC(C
" in default initialization.)
-descp_Top=
scan lines
ESC(c
"
in default initialization.)
-descp_Bottom=
scan lines
ESC(c
" in default initialization.)
-sescp_Init=
"string"
-sescp_Release=
"string"
ESC @ FF
" by
default.
ESC/P2 allows any resolutions to be valid in theory, but only
-r360x360
(the default) and -r720x720 (not
on STC-IIs ? and st800) are known to work with most printers.
Valid option combinations
Stylus I & Pro-Series only
Resolution escp_Band
Weave usable escp_Band
&
number of passes
180x90 15 noWeave
180x180 1 , 8, 24 noWeave
, Microweave15/2 SoftWeave
180x360 15/4 SoftWeave
180x720 15/8 SoftWeave
360x90 15 noWeave
360x180 1, 8, 24 noWeave
, Microweave15/2 SoftWeave
360x360 1, 8, 24 noWeave
, Microweave15/4 SoftWeave
360x720 15/8 SoftWeave
720x90 15 noWeave
720x180 15/2 SoftWeave
720x360 15/4 SoftWeave
720x720 1 noWeave
, Microweave15/8 SoftWeave
Beware: there are only few validity checks for parameters. A good
example is escp_Band
: if you set this, the driver uses your
value even if the value is not supported by the printer. You asked for
it and you got it!
Quite a bunch of parameters. Hopefully you never need any of them, besides
feeding stcolor.ps
to Ghostscript in front of your input.
After answering some questions over fifty times I prepared a FAQ. Here is
version 1.3 of the FAQ, as of stcolor
version 1.20 (for
Ghostscript 3.50).
Yes, this driver supports the A3-size printer: merely set the required
pagesize and margins. A simple way to do this is to specify the
command-line switch "-sPAPERSIZE=a3
" or include the
procedure call "a3
" in the PostScript prolog section. To
optimize the printable area or set the proper margins, see the next
paragraph.
I refuse to add code to stcolor
that tries to guess the
proper margins or page size, because I found that such guessing is usually
wrong and needs correction in either the source or the parameters. You can
modify stcolor.ps
to do that, however. After the line
mark % prepare stack for "putdeviceprops"
insert these lines, which define page size and margins in points:
/.HWMargins [9.0 39.96 12.6 9.0] % Left, bottom, right, top (1/72") /PageSize [597.6 842.4] % Paper, including margins (1/72") /Margins [ % neg. Offset to Left/Top in Pixels 4 index 0 get STCold /HWResolution get 0 get mul 72 div neg 5 index 3 get STCold /HWResolution get 1 get mul 72 div neg ]
Feel free to change the values of .HWMargins
and
PageSize
to match your needs; the values given are the
defaults when the driver is compiled with "-DA4
". This
option or its omission may cause trouble: the Stylus Color can print up to
exactly 8 inches (2880 pixels) at 360dpi. The remaining paper is the
margin, where the left margin varies only slightly with the paper size,
while the right margin is significantly increased for wider paper, such as
U.S. letter size.
Note that if you are using an ISO paper size with a version of
stcolor
after 1.20 and compiled without
"-DA4
", then the default margin is too large, and you need
to add the proper ".HWMargins
" to the command line or to
stcolor.ps
.
First the good news: the driver can print on the Stylus Color II. Now the bad news:
stcolor.ps
).
To make things work, you MUST disable the driver's internal
weaving (Softweave
), in one of these two ways:
gs -dMicroweave
...
gs -dnoWeave -descp_Band=1
...
Version 1.90, current as of Ghostscript 5.10, fixes this bug by new default behaviour. I experienced significantly increased printing speed with the second variant on the old Stylus Color, when printing mostly monochrome data.
The next section is a contribution from Jason Patterson <jason@reflections.com.au> who evaluated a previous version (1.17). Ghostscript was invoked as follows:
gs
-sDEVICE=stcolor -r720x720 -sDithering=
...-sOutputFile=escp.out stcolor.ps whatsoever.ps
where "..." is the name of the desired algorithm.
stcolor.ps
was omitted for the gs-algorithms
(gsmono
, gsrgb and gscmyk),
for which it is useless and would not allow the selection of
"gscmyk
".
gdevstc
1.21Here are data about the EPSON Stylus Color driver's different dithering methods, based on a little experiment using four good quality scanned images of quite varied nature, to begin with, a summary of the results of the four experiments. Sanity note: the results here are from only four images and a total of 24 printouts (eight on 720dpi paper, sixteen on plain paper). Your results will almost certainly vary, and your standards might not be the same as mine, so use these results only as a guide, not as a formal evaluation.
Quality of output by method
gsmono
Pretty much what you'd expect from a mono ordered pattern. Looks like what a lot of mono laser printers produce. fsmono
Excellent for monochrome. gscmyk
Not very good, but expected from an ordered pattern. gsrgb
A little better than gscmyk
. More consistent looking.fs2
Good, but not quite as good as fsrgb
. Gets the brightness wrong: too light at 720dpi, too dark at 360dpi.fsrgb
Very good, but a little too dark and has a slight blue tint. hscmyk
Excellent. Slightly better than fsrgb
andfs2
. Better than fscmyk on some images, almost the same on most.fscmyk
Best. Very, very slightly better than hscmyk
. On some images nearly as good as the EPSON demos done with the MS Windows driver.
Overall visual quality (1-10), best to worst
Monochrome fsmono
******************
gsmono
**********
0 1 2 3 4 5 6 7 8 9 10
Colour fscmyk
*******************
hscmyk
*******************
fsrgb
******************
fs2
*****************
gsrgb
**********
gscmyk
*********
0 1 2 3 4 5 6 7 8 9 10
In the initial version of the driver distributed with Ghostscript 3.33, the
parameter "SpotSize
" was the only way to manipulate the
colors at the driver level. According to the parameters enumerated above,
this has changed significantly with version 1.16 and above as a result an
ongoing discussion about dithering algorithms and "false color" on the
Epson Stylus Color. This initiated the transformation of the
stcolor
driver into a framework for different dithering
algorithms, providing a generalized interface to the internal Ghostscript
color models and the other data structures related to Ghostscript drivers.
The main thing such a framework should be able to do is to deliver the values the dithering algorithm needs; and since this directly influences the optical image impression, this transformation should be adjustable without the need for recompilation and relinking. In general the process can be described as follows:
ColorAdjustMatrix
Coding Transfer | Ghostscript color | => | Ghostscript raster | => | Dithering data | | | | 1/2/4/8/16/32-bit | | | | 1/3/4 16-bit values | | 1/3/4 values | | (arbitrary type) |
Due to the limitations on raster storage, information is lost in the first
transformation step, except for the 16-bit monochrome mode. So any color
adjustment should take place before this step and this is where the optional
ColorAdjustMatrix
works.
The first transformation step, called "coding", is controlled by the
?coding
arrays. The decoding process expands the range of
values expontentially to a larger range than that provided by the initial
Ghostscript color model, and is therefore a reasonable place to make
device- or algorithm-specific adjustments. This is where the
?transfer
arrays are used. Array access might be not the
fastest method, but its generality is superior, so this step is always
based upon internally algorithm-specific array access. If 8 bits are stored
per color component and if the algorithm uses bytes too, the second
transformation is included within the first, which saves significant
computation time when printing the data.
ColorAdjustMatrix
The driver supports different values for ProcessColorModel
,
which raises the need for different color adjustments. Here
"CAM
" stands for "ColorAdjustMatrix".
DeviceGray
(three floats)
if ((r == g) && (g == b)) K' = 1.0 - R; else K' = 1.0 - CAM[0] * R + CAM[1] * G + CAM[2] * B;
According to the documentation on drivers, the latter (the "else" clause) should never happen.
DeviceRGB
(nine floats)
if((r == g) && (g == b)) R' = B' = G' = R; else R' = CAM[0]*R + CAM[1]*G + CAM[2]*B; G' = CAM[3]*R + CAM[4]*G + CAM[5]*B; B' = CAM[6]*R + CAM[7]*G + CAM[8]*B;
The printer always uses four inks, so a special treatment of black is provided. Algorithms may take special action if R, G, and B are all equal.
DeviceCMYK
(sixteen floats)
if((c == m) && (m == y)) K' = max(C,K); C' = M' = Y' = 0; else K = min(C,M,Y); if((K > 0) && ColorAdjustMatrix_present) { => UCR C -= K; M -= K; Y -= K; } C' = CAM[ 0]*C + CAM[ 1]*M + CAM[ 2]*Y + CAM[ 3]*K; M' = CAM[ 4]*C + CAM[ 5]*M + CAM[ 6]*Y + CAM[ 7]*K; Y' = CAM[ 8]*C + CAM[ 9]*M + CAM[10]*Y + CAM[11]*K; K' = CAM[12]*C + CAM[13]*M + CAM[14]*Y + CAM[15]*K;
Again we have a special black treatment. "max(C,K)
" was introduced
because of a slight misbehaviour of Ghostscript, which delivers
black under certain circumstances as (1,1,1,0). Normally, when
no special black separation and undercolor removal procedures
are defined at the PostScript level, either (C,M,Y,0) or (0,0,0,K)
values are mapped. This would make the extended ColorAdjustMatrix
quite tedious, and so during mapping, black separation is done for
(C,M,Y,0) requests; and if there is a ColorAdjustMatrix
, undercolor
removal is used too. In other words the default matrix is:
1 0 0 1 0 1 0 1 0 0 1 1 0 0 0 1
and it is applied to CMYK values with separated and removed black. Raising the CMY coefficients while lowering the K coefficients reduces black and intensifies color. But be careful, because even small deviations from the default cause drastic changes.
If no ColorAdjustMatrix
is set, the matrix computations are
skipped. Thus the transformation reduces to range inversion in monochrome
mode and black separation in CMYK mode.
BitsPerPixel
These two (groups of) parameters are arrays of floating-point numbers in
the range 0.0 to 1.0. They control the truncation to the desired number of
bits stored in raster memory (BitsPerPixel
) and the ink
density. The "truncation" may become a nonlinear function if any of the
?coding
arrays is set. Assume the following Ghostscript
invocation:
gs -sDEVICE=stcolor -sDithering=fscmyk -dBitsPerPixel=16 \ -dKcoding='{ 0.0 0.09 0.9 1.0 }' \ -dMcoding='{ 0.0 0.09 0.9 1.0 }' \ -dKtransfer='{ 0.0 0.09 0.9 1.0 }' \ -dYtransfer='{ 0.0 0.09 0.9 1.0 }'
We may have either or both of ?coding
and
?transfer
, giving four possible combinations. (These four
combinations appear in the given example.) The resulting mapping appears
in the following tables, where except for the internal Indices (4
components × 4 bits = 16 BitsPerPixel
), all values
are normalized to the range 0 to 1. The actual range is 0 to 65535 for the
Ghostscript color and 0 to 16777215 for the ink values delivered to the
fscmyk
algorithm. Sorry for the bunch of numbers
following, but you may try this example in conjunction with
stcinfo.ps
, which should give you a graphical printout of
the following numbers when you issue a showpage
command.
Cyan
Magenta
CI/15 gs_color_values CI Ink gs_color_values CI Ink
0.000 0.000 - 0.062 0 0.000 -0.123 - 0.123 0 0.000 0.067 0.063 - 0.125 1 0.067 0.123 - 0.299 1 0.247 0.133 0.125 - 0.187 2 0.133 0.299 - 0.365 2 0.351 0.200 0.188 - 0.250 3 0.200 0.365 - 0.392 3 0.379 0.267 0.250 - 0.312 4 0.267 0.392 - 0.420 4 0.406 0.333 0.313 - 0.375 5 0.333 0.420 - 0.447 5 0.433 0.400 0.375 - 0.437 6 0.400 0.447 - 0.475 6 0.461 0.467 0.438 - 0.500 7 0.467 0.475 - 0.502 7 0.488 0.533 0.500 - 0.562 8 0.533 0.502 - 0.529 8 0.516 0.600 0.563 - 0.625 9 0.600 0.529 - 0.557 9 0.543 0.667 0.625 - 0.687 10 0.667 0.557 - 0.584 10 0.571 0.733 0.688 - 0.750 11 0.733 0.584 - 0.612 11 0.598 0.800 0.750 - 0.812 12 0.800 0.612 - 0.639 12 0.626 0.867 0.813 - 0.875 13 0.867 0.639 - 0.715 13 0.653 0.933 0.875 - 0.937 14 0.933 0.715 - 0.889 14 0.778 1.000 0.938 - 1.000 15 1.000 0.889 - 1.111 15 1.000
The difference between cyan and magenta is the presence of a coding array. The coding process must map a range of color values to each of the sixteen component indices. If no coding array is given, this is accomplished by dividing by 4096, equivalent to a right shift by 12 bits. The final ink density resides in the given interval and moves from the left to the right side from 0 to 15. For magenta there is a coding array and the ink value matches the center of the intervals. But the distribution of the mapped intervals follows the given coding array and is nonlinear in the linear color space of Ghostscript.
Now let us take a look at the case with transfer arrays:
Yellow
Black
CI/15 gs_color_values CI Ink gs_color_values CI Ink
0.000 0.000 - 0.062 0 0.000 -0.123 - 0.123 0 0.000 0.067 0.063 - 0.125 1 0.018 0.123 - 0.299 1 0.067 0.133 0.125 - 0.187 2 0.036 0.299 - 0.365 2 0.133 0.200 0.188 - 0.250 3 0.054 0.365 - 0.392 3 0.200 0.267 0.250 - 0.312 4 0.072 0.392 - 0.420 4 0.267 0.333 0.313 - 0.375 5 0.090 0.420 - 0.447 5 0.333 0.400 0.375 - 0.437 6 0.252 0.447 - 0.475 6 0.400 0.467 0.438 - 0.500 7 0.414 0.475 - 0.502 7 0.467 0.533 0.500 - 0.562 8 0.576 0.502 - 0.529 8 0.533 0.600 0.563 - 0.625 9 0.738 0.529 - 0.557 9 0.600 0.667 0.625 - 0.687 10 0.900 0.557 - 0.584 10 0.667 0.733 0.688 - 0.750 11 0.920 0.584 - 0.612 11 0.733 0.800 0.750 - 0.812 12 0.940 0.612 - 0.639 12 0.800 0.867 0.813 - 0.875 13 0.960 0.639 - 0.715 13 0.867 0.933 0.875 - 0.937 14 0.980 0.715 - 0.889 14 0.933 1.000 0.938 - 1.000 15 1.000 0.889 - 1.111 15 1.000
Yellow uses a transfer array. There is no linear correspondence between the color and the ink values: this correspondence is defined through the given array. In other words, the transfer arrays define a nonlinear ink characteristic, which is exactly the same functionality that PostScript's "(color)transfer" function provides.
While for yellow the intervals match the intervals used with cyan, for black the intervals match the magenta intervals. But watch the correspondence between the CI/15 values and the ink density for black: this is a linear distribution in the ink domain.
Not a bad idea, I think. Consider the fs2
algorithm: it
uses values in the range 0 to 255. If any transfer array were alone, some
of the 256 possible values would never be used and others would be used for
adjacent intervals several times. Establishing an identical coding array
solves this problem, so the full potential of the algorithm is used.
Another useful feature of the coding arrays is that they are internally
normalized to the range 0-1. In 720x720dpi mode the transfer arrays in
stcolor.ps
limit the dot density to about 50%, so these
arrays end at 0.5 (and begin at 0.5 for RGB). Because of automatic
normalization, these arrays can also be used as coding arrays. But of
course in the fs2
case mentioned above, values from 0 to
127 will never be delivered to the algorithm, while values 128-255 are
delivered for adjacent intervals.
To clarify the intended use of the three parameters (parameter groups), keep this in mind:
ColorAdjustMatrix
is never used when transferring gray values. This restricts it to what the name says: adjustment of colors, that is, correction for miscolored ink. Do not use it for saturation or brightness control.?transfer
arrays control the values delivered to the driver, which in turn controls the ink quantity. Use these arrays to control saturation and brightness. In general these arrays are identical for all inks. If they differ they provide a simpler scheme for color correction, which is not necessarily faster than theColorAdjustMatrix
.?coding
arrays control the color value intervals mapped to the internal color indices.
The Epson Stylus Color has a head assembly that contains two physically identifiable heads, one for black and one for cyan, magenta, and yellow (CMY). This makes four "logical" heads, one for each color component. Each of these four heads has several jets at some vertical (Y) distance from one another, so several horizontal lines can be printed of a given color during one pass of the heads. From experience I think there are fifteen jets per color, spaced at 1/90in.
So the question arises of how to print at a Y resolution of 360dpi with 90dpi jets. Simply by division one gets 360dpi/90dpi = 4, which tells us that 4 passes of the head assembly are needed to achieve a Y resolution of 360dpi.
Weaving is the method of how the fifteen jets are used to print adjacent horizontal rows separated here by 1/360 inch:
Print-head jets used with and without weaving
Weaving
noWeave
Pass 1 2 3 4 1 2 3 4 Row 0 jet 0 -- -- -- jet 0 -- -- -- 1 -- jet 1 -- -- -- jet 0 -- -- 2 -- -- jet 2 -- -- -- jet 0 -- 3 -- -- -- jet 3 -- -- -- jet 0 4 jet 1 -- -- -- jet 1 -- -- -- 5 -- jet 2 -- -- -- jet 1 -- -- 6 -- -- jet 3 -- -- -- jet 1 -- ...
Now let's assume that the dot diameter is different for each individual jet, but the average among the jets matches the desired resolution. With weaving, adjacent rows are printed by different jets, thus some averaging takes place. Without weaving, adjacent rows are printed by the same jet and this makes the dot diameter deviations visible as 1/90in stripes on the paper.
The parameters "Unidirectional
",
"Microweave
", "noWeave",
"OutputCode
", "Model" and the given
resolution control the data generated for the printer.
Unidirectional
Simply toggles the unidirectional mode of the printer. Setting
"Unidirectional
" definitely slows printing speed, but may
improve the quality. I use this for printing transparencies, where fast
head movement could smear the ink.
Microweave
,
noWeave
and OutputCode=deltarow
The first are two booleans, which implies that four combinations are
possible. Actually only three exist (if you don't count for
deltarow
): Softweave,
Microweave
, and noWeave. The first and
second are functionally identical, the difference being whether the driver
or the printer does the job.
In the default Softweave
mode the driver sends the data
properly arranged to the printer, while in Microweave
mode,
it is the printer that arranges the data. But in general the host processor
is much faster than the printer's processor, and thus it is faster for the
host do the job. In addition to that, for 720dpi eight passes are
required, and the amount of buffer space needed to buffer the data for the
passes is far beyond the printer's memory. Softweave
requires an odd value of "escp_Band
"; the Stylus Color
provides fifteen for that.
"OutputCode
" controls the encoding used. In the basic
modes, the choice consists of "plain" and "runlength". The computation of
runlength-encoded data does not take much time, less than the data tranfer
to the printer; thus this is the recommended mode, and of course the
default. With the Stylus Color, Epson introduced some new encoding
principles, namely "tiff" and "deltarow". While the first was omitted from
this driver for lack of apparent advantages, "deltarow
" is
available as an option. "Softweave
" cannot be used with
this encoding, so if OutputCode=deltarow
is set,
Microweave
becomes the default. Maybe that the size of the
ESC/P2 code becomes smaller, but I have never observed faster printing
speed. Things tend to become slower with deltarow
compared
to Softweave
.
Model
Some ESC/P2 printers such as the Stylus 800 do not offer
Microweave
or the commands required to do
Softweave
. Setting Model just changes the
defaults and omits some parts of the initialization sequence which are not
compatible with the given printer model. Currently only
"st800
" is supported besides the default
stcolor
.
?coding
and ?transfer arrays
should be strictly monotonic.
WHITE
: that's your paper.
Thus RGB transfer should end at 1.0 and CMYK transfer should start at 0.0.
ColorAdjustMatrix
is not used in the reverse
transformation used when Ghostscript does the dithering
(gs
* modes). Expect funny results.
BitsPerPixel
is less than 6, the entire coding and
transfer process does not work. This is always true for the
gs
* modes and becomes true for the other modes if
BitsPerPixel
is forced to low values.
gs
*
modes and should always use stcolor.ps
. (I prefer
360×720.)
This section gives an overview of performance in terms of processing and printing times, from tests run after version 1.13. Printing was done offline (simply copying a processed file to the printer) to measure real printing speed without regard to speed of processing on the host, since at high resolutions, processing time is the same order of magnitude and thus may become the limiting factor.
I ran several files though Ghostscript and recorded the size of the resulting print code, the processing time, and the printing time, at least for some of the files, always using these options:
gs -sDEVICE=stcolor -sPAPERSIZE=a4 stcolor.ps - < file.ps
(Actually "-sPAPERSIZE=a4
" is in my
gs_init.ps
since I'm a germ.)
"deltarow
" is the new encoding principle
("ESC . 3 10 10 1
") with
Microweave
on. It is activated with
"-sOutputCode=deltarow
".
"Softweave
" actually means that nothing else was used:
it is the default, and implies that odd v=40/h=10/m=15 mode
("ESC . 1 40 10 15
").
"Microweave
" means "-dMicroweave",
equivalent to "ESC . 1 10 10 1
",
with full skip optimization and microweave activated.
Finally I wanted to see the plain Kathy Ireland, and used
"-sOutputCode=plain
", which just replaces runlength
encoding (RLE) by no encoding, thus using
"ESC . 0 40 10 15
". [So sorry
;-)
Kathy was still dressed in blue in front of the blue
sea on a blue air cushion -- nice to see but hard to dither.]
So here are the results.
File sizes and printing speeds with various weaving methods
golfer.ps
colorcir.ps
drawing.ps
brief.ps
deltarow
572751/48.180u 643374/41.690u 90142/46.180u/1:50 178563/49.350u/2:22 Softweave
559593/46.810u 669966/44.960u 296168/48.160u/1:30 269808/43.320u/1:55 Microweave
590999/56.060u 754276/42.890u 338885/47.060u/1:50 282314/44.690u/2:22
Kathy Ireland
kathy.ps
deltarow
3975334/111.940u/5:35 Softweave
3897112/101.940u/3:10 Microweave
4062829/100.990u/3:15 plain/soft
5072255/104.390u/3:05
It may be that I've not chosen the optimal deltarow
code,
but even if it saves at lot of bytes, printing-speed is not increased.
At least the printer prefers plain Kathy. In other words, sending 1
Megabyte or 20% more data has no impact on printing speed.
drawing.ps
is an exception to this rule: plain prints
slower than RLE.
"Unclever" coding -- especially with deltarow
-- can
significantly slow down printing. But even if very significant advantages
in the size of the code are achieved, "deltarow
" is not
competitive. colorcir.ps
shows savings with
deltarow
, but printing is a mess.
Full page halftone images printed, unless otherwise noted.
Printing time related to other options
dpi Print mode Size KB Time Comments
180x180 mono -/uni 358 1:15 -/bi 358 0:45 micro/bi 205 0:45 Not weaving soft/bi 179 1:25 color -/bi 641 2:45 soft/bi 556 1:32 360x360 mono -/uni 269 0:50 Monochrome text -/bi 269 0:35 Monochrome text micro/bi 269 2:25 Monochrome text soft/uni 250 3:15 Monochrome text soft/bi 250 1:55 Monochrome text color -/bi 346 1:00 Sparse-color page, visible displacements micro/bi 346 1:50 Sparse-color page, looks buggy -- printer? soft/bi 294 1:30 Sparse-color page, O.K. -/bi 2218 2:45 Visible stripes micro/bi 5171 3:17 soft/bi 3675 3:05 360x720 mono soft/bi 2761 5:40 color soft/bi 7789 6:15 Just a small difference! 720x360 color soft/bi 7182 5:40 720x720 color micro/bi 14748 30:26 Actually beyond printer's capabilities soft/bi 14407 11:08
This driver was copied from gdevcdj.c
(Ghostscript 3.12),
which was contributed by George Cameron, Koert Zeilstra, and Eckhard
Rueggeberg. Some of the ESC/P2 code was drawn from Richard Brown's
gdevescp.c
. The POSIX interrupt code (compilation option
-DSTC_SIGNAL
) is from Frederic Loyer. Several improvements
are based on discussions with Brian Converse, Bill Davidson, Gero Guenther,
Jason Patterson, ? Rueschstroer, and Steven Singer.
While I wish to thank everyone mentioned above, they are by no means responsible for bugs in the stcolor driver -- just for the features.
Gunther Hess
uniprint
is a unified parametric driver by Gunther Hess
<ghess@elmos.de> for several
kinds of printers and devices, including
- any Epson Stylus Color, Stylus, or Stylus Pro
- HP PCL/RTL
- Canon BubbleJet Color 610
- NEC P2X
- Sun raster file format
This driver is intended to become a unified printer driver. If you consider it ugly, please send me your suggestions for improvements. The driver will be updated with them. Thus the full explanation of the driver's name is:
Ugly- -> Updated- -> Unified Printer Driver
But you probably want to know something about the functionality. At the time of this writing uniprint drives:
It can be configured for various other printers without recompilation and offers uncompressed (ugly) Sun rasterfiles as another format, but this format is intended for testing purposes rather than real use. The usage of this driver is quite simple. The typical command line looks like this:
gs @
{MODEL}.upp -sOutputFile={printable file} MyFile.ps -c quit
For example, from my Linux box:
gs @stc.upp -sOutputFile=/dev/lp1 tiger.eps -c quit
Unified Printer Parameter files distributed with Ghostscript
Canon BJC 610 (color, rendered) bjc610a0.upp
360×360dpi plain paper, high speed bjc610a1.upp
360×360dpi plain paper bjc610a2.upp
360×360dpi coated paper bjc610a3.upp
360×360dpi transparency film bjc610a4.upp
360×360dpi back print film bjc610a5.upp
360×360dpi fabric sheet bjc610a6.upp
360×360dpi glossy paper bjc610a7.upp
360×360dpi high gloss film bjc610a8.upp
360×360dpi high resolution paper bjc610b1.upp
720×720dpi plain paper bjc610b2.upp
720×720dpi coated paper bjc610b3.upp
720×720dpi transparency film bjc610b4.upp
720×720dpi back print film bjc610b6.upp
720×720dpi glossy paper bjc610b7.upp
720×720dpi high-gloss paper bjc610b8.upp
720×720dpi high resolution paper HP Ink-Printers cdj550.upp
300×300dpi 32-bit CMYK cdj690.upp
300×300dpi Normal mode cdj690ec.upp
300×300dpi Economy mode dnj750c.upp
300×300dpi Color -- also good for 450C dnj750m.upp
600×600dpi Monochrome NEC P2X necp2x.upp
360×360dpi 8-bit (Floyd-Steinberg) Any Epson Stylus Color stcany.upp
360×360dpi 4-bit, PostScript halftoning stcany_h.upp
720×720dpi 4-bit, PostScript halftoning Original Epson Stylus and Stylus Pro Color stc.upp
360×360dpi 32-bit CMYK, 15-pin stc_l.upp
360×360dpi 4-bit, PostScript halftoning, weaved noWeave stc_h.upp
720×720dpi 32-bit CMYK, 15-pin Weave Epson Stylus Color II stc2.upp
360×360dpi 32-bit CMYK, 20-pin, Epson Stylus Color II(s) stc2_h.upp
720×720dpi 32-bit CMYK, 20-pin, Epson Stylus Color II stc2s_h.upp
720×720dpi 32-bit CMYK, 20-pin, Epson Stylus Color IIs Epson Stylus Color 200 stc200.upp
360×720dpi Plain Paper Epson Stylus Color 300 stc300.upp
360×360dpi 32-bit CMYK, plain paper stc300bl.upp
180×180dpi black only, plain paper stc300bm.upp
360×360dpi black only, plain paper Epson Stylus Color 500 (good transfer curves for plain paper) stc500p.upp
360×360dpi 32-bit CMYK, noWeave, plain paper stc500ph.upp
720×720dpi 32-bit CMYK, noWeave, plain paper Epson Stylus Color 600, 32/90-inch weaving stc600pl.upp
360×360dpi 32-bit CMYK, 32-pin, plain paper stc600p.upp
720×720dpi 32-bit CMYK, 32-pin, plain paper stc600ih.upp
1440×720dpi 32-bit CMYK, 30-pin, inkjet paper Epson Stylus Color 640 stc640p.upp
720×720dpi plain paper? st640p.upp
720×720dpi CMYK, plain paper st640pg.upp
720×720dpi grayscale, plain paper st640pl.upp
360×360dpi CMYK, plain paper st640plg.upp
360×360dpi grayscale, plain paper st640ih.upp
1440×720dpi CMYK, inkjet paper st640ihg.upp
1440×720dpi grayscale, inkjet paper Epson Stylus Color 800, 64/180-inch weaving stc800pl.upp
360×360dpi 32-bit CMYK, 64-pin, plain paper stc800p.upp
720×720dpi 32-bit CMYK, 64-pin, plain paper stc800ih.upp
1440×720dpi 32-bit CMYK, 62-pin, inkjet paper stc1520.upp
1440×720dpi 32-bit CMYK, 62-pin, inkjet paper Sun raster file ras1.upp
1-bit monochrome (Ghostscript) ras3.upp
3-bit RGB (Ghostscript) ras4.upp
4-bit CMYK (Ghostscript) ras8m.upp
8-bit grayscale (Floyd-Steinberg) ras24.upp
24-bit RGB (Floyd-Steinberg) ras32.upp
32-bit CMYK (CMYK-Floyd-Steinberg)
Thanks to Danilo Beuche, Guido Classen, Mark Goldberg and Hans-Heinrich Viehmann for providing the files for the stc200, hp690, stc500 and the stc640. Thanks to Michael Lossin <losse@germanymail.com> for the newer st640 parameter sets.
Please note the following:
- Changing the resolution with Ghostscript's
-r
switch is usually not possible.- For Epson Stylus Color models not listed above, the two
stc500
variants are likely to work in addition tostcany
, but their gamma correction might be wrong.
The coding of uniprint
was triggered by the requirements of
the various Stylus Color models and some personal needs for HP and NEC
drivers. Thus the Epson models are well represented among the distributed
parameter files. When this driver entered the beta test phase, three other
drivers appreared on the scene that could be at least partially integrated
into uniprint
: cdj850 by Uli Wortmann
(available at http://www.erdw.ethz.ch/~bonk/hp850/hp850.html),
hpdj
by Martin Lottermoser, and bjc610 by
Helmut Riegler.
Uli addresses features of the more recent DeskJet models that will not be
available in uniprint
soon. Martin taught me a lesson on
HP-PCL3 headers that will be available in uniprint
soon. Helmut in turn followed an almost similar idea, but targetted
primarily for printing on Canon printers from the pbmplus library. Starting
with version 1.68 of uniprint, BJC support is available. Work on the
hpdj
integration will start after the update of my website.
uniprint
's background
uniprint
is actually an update of stcolor,
but much more versatile than its predecessor; stcolor
, in
its turn, started as a clone of the color DeskJet family of drivers
(cdj
*). Finally, cdj* can be considered an
addition of features to the simpler monochrome drivers of Ghostscript. This
addition of features is useful to get an idea of the functionality of
uniprint
:
- Monochrome to advanced color (
cdj
*):- This adds color mapping and rendering functions to the driver. Error diffusion is especially important for the quality of printing.
- HP color to Epson Color (
stcolor
)- The Epson Stylus Color offered two features simultaneously: it could produce 720×720dpi output and it could soak the paper. In other words, it required more color management features inside the driver. This is still the major conceptual difference in the data generation for HP and Epson printers.
- Weaving techniques (
stcolor
)- Besides the internal color management, the Stylus Color did not provide enough buffer space to operate the printer fast at 720×720dpi. The use of weaving could yield triple the print speed. Weaving, also called interleaving, is present in some monochrome drivers too. The new thing in
stcolor
was the combination with error diffusion. Unfortunately the weaving was somehow hard-coded, as the problems with the newer members of the Stylus Color family of printers demonstrated.
- Generalized output format and weaving (
uniprint
)- The features mentioned above yield about 90% of
stcolor
's source code; only 10% is related to the formatting of the output. The idea to make the output format switchable came up soon after completingstcolor
, but its final design was triggered by the (personal) necessity to drive a NEC P2X and a Designjet 750c.
Thus uniprint
accumulates almost any features that can be
found among the other printer drivers, which clearly has some disadvantage
in processing speed -- true in particular of version 1.75, since it was
targetted for functionality, and several speed-gaining features were
(knowingly) omitted.
To summarize and to introduce the terms used in the description of the
parameters, the features of uniprint
that can be
parameterized are:
- color mapping,
- color rendering (error diffusion or Floyd-Steinberg),
- output format, including
- weaving.
.upp
) files
Here is one of the distributed parameter files (stc_l.upp
)
with some added comments. Also see the section that describes
all uniprint
's parameters in
brief.
-supModel="Epson Stylus Color I (and PRO Series), 360x360DpI, noWeave" -sDEVICE=uniprint -- Select the driver -dNOPAUSE -- Useful with printers -dSAFER -- Provides some security -dupColorModel=/DeviceCMYK -- Selects the color mapping -dupRendering=/ErrorDiffusion -- Selects the color rendering -dupOutputFormat=/EscP2 -- Selects the output format -r360x360 -- Adjusts the resolution -dupMargins="{ 9.0 39.96 9.0 9.0}" -- Establishes (L/B/R/T margins in points) -dupComponentBits="{1 1 1 1}" -- Map: bits per component (default: 8) -dupWeaveYPasses=4 -- Weave: Y-passes (default: 1) -dupOutputPins=15 -- Format/weave: scans per Command -dupBeginPageCommand="< -- Goes to the printer 1b40 1b40 -- ESC '@' ESC '@' -> dual reset 1b2847 0100 01 -- ESC '(' 'G' 1 0 1 -> graphics 1b2869 0100 00 -- ESC '(' 'i' 1 0 1 -> no HW weave 1b2855 0100 0A -- ESC '(' 'U' 1 0 10 -> 360dpi 1b5500 -- ESC 'U' 0 -> bidir print 1b2843 0200 0000 -- ESC '(' 'C' 2 0 xx -> page length 1b2863 0400 0000 0000 -- ESC '(' 'c' 4 0 xxxx -> margins >" -- as it is, unless: -dupAdjustPageLengthCommand -- Adjust page length in BOP requested -dupAdjustTopMarginCommand -- Adjust top margin in BOP -dupAdjustBottomMarginCommand -- Adjust bottom margin in BOP -dupEndPageCommand="(\033@\014)" -- Last (but one) data to the printer -dupAbortCommand="(\033@\15\12\12\12\12 Printout-Aborted\15\014)"
That's short, and if one removes upWeaveYPasses
and
upOutputPins
it becomes shorter, almost
stcany.upp
. This miniature size is because I am most
familiar with ESC/P2, and was able to add defaults for the omitted
parameters. Now a few notes about the parameters used in this example:
upModel
is a string serving as a comment (and nothing else).
DEVICE
,
NOPAUSE
, SAFER
are well-known Ghostscript
parameters described in the usage documentation.
upColorModel
is one of major uniprint
parameters: it selects the color mapping and in turn the PostScript color
model. It supports the devices /DeviceGray
, /DeviceRGBW, /DeviceRGB, /DeviceCMYK, and /DeviceCMYKgenerate.
upRendering
selects the (color) rendering, supporting
the values /ErrorDiffusion
and /FSCMYK32.
/ErrorDiffusion
is similar to fsmono,
fsrgb
and fsx4 of stcolor,
while /FSCMYK32
is (almost) identical to
fscmyk
and hscmyk, but is restricted to
32-bit data and should be used in conjunction with
/DeviceCMYKgenerate
.
upOutputFormat
selects the output method, supporting the values
/SunRaster
, /Epson, /EscP2, /EscP2XY, and/Pcl.
/SunRaster
creates Sun raster files and requires no other parameters /Epson
is used for the elderly ESC/P format (used by many printers) /EscP2
is used by more recent Epson printers (no X weaving supported) /EscP2XY
supports X-Weaving, used with 1440dpi printers and in stc2s_h
/Pcl
HP PCL/RTL-style output formatter without weaving
-r360x360
is Ghostscript's standard
resolution switch.
upMargins="{ 9.0 39.96 9.0 9.0}"
has function similar to the Ghostscript parameter
.HWMargins
: it sets the left, bottom, right, and top
margins in points. uniprint
provides this parameter to
enable automatic left-right exchange if upYFlip
is active.
upComponentBits
is an array of integers that selects
the bits stored in raster memory, by default 8 bits per component. In this
example, 1 bit is selected for each component, thus turning down the
Floyd-Steinberg algorithm (but still carrying out the time-consuming
computation). The related parameter "upComponentShift
"
controls positioning the components within raster memory. Each of the
numbers given corresponds to a component which depends on the selected
"upColorModel
":
/DeviceGray
/DeviceRGBW
/DeviceRGB
/DeviceCMYK
/DeviceCMYKgenerate
0 White White Red Black Black 1 -- Red Green Cyan Cyan 2 -- Green Blue Magenta Magenta 3 -- Blue -- Yellow Yellow This order may not be suitable for some printers, so another parameter "
upOutputComponentOrder
", also an array of integers, selects the output order using the numbers on the left.
One group of very important parameters not used in the example above
deserves to be mentioned here: the transfer arrays, named
"up{color}Transfer
", where
{color}
is one of the names in the table above.
These are
arrays of floats in the range 0.0 - 1.0 representing the color transfer
functions. They are used during mapping and rendering. In the simplest
case, these arrays ensure an equidistant distribution of the stored values
within the device space (which means a nonlinear mapping from Ghostscript's
point of view). If the given array does not cover the entire range from 0
to 1, which applies for the Stylus Color family at high resolution for some
media, only the relevant part gets mapped to raster memory (meaning that
is's fully utilized) and the rendering takes care of the "overhang" (in
this case the post-diffusion of 1-bit components makes sense).
Finally an important note on the transfer arrays: for monochrome devices
the stored component is White
, which is the way PostScript
defines these devices, but most printers require Black
.
Thus one has to provide a falling "upWhiteTransfer
" for
such printers.
upWeaveYPasses
is an integer that gives the number of
print head passes required to achieve the requested Ydpi. This makes sense
only if
upOutputPins
is set to something greater than 1. Thus
multiple pins or nozzles are transferred with a single command, and of
course such a command must be supported by the device.
If no other weave parameters are given, uniprint
computes
several defaults which together do no weaving. The /Epson
and /EscP2XY
formats take care of
"upWeaveXPasses
" too.
upBeginPageCommand
represents the data transferred to
the printer whenever a new page begins. Before that,
"upBeginJobCommand
" is written to the device only once per
output file. (Intended for the HP PJL sequences).
upAdjustBottomMarginCommand
,
upAdjustMediaSize
,
upAdjustPageLengthCommand
,
upAdjustPageWidthCommand
,
upAdjustResolutionCommand
, and
upAdjustTopMarginCommand
Normally uniprint
does not change the
"upBeginPageCommand
", nor does it provide a default.
However, if the above boolean values are set, the corresponding values are
changed (provided that the code of the formatters supports this change and
the commands to be adjusted are included in the BOP string).
upEndPageCommand
is the fixed termination sequence for
each page, and of course there is an "upEndJobCommand
" too.
upAbortCommand
is written if uniprint's
interrupt detection is enabled and a signal is caught. It replaces
"upEndPageCommand
" and "upEndJobCommand",
thus allowing the indication of an aborted job. (Ghostscript gets an error
return from uniprint
in this case, and abandons further
processing.)
For the ESC/P(2) formats all commands represent binary data, while for
the PCL/RTL formatter some of them are formats for fprintf
. These strings
must explicitly have a trailing "\0'.
I should write more, but the only recommendation is to take a look at the various parameter files. Here are a few more hints.
showpage
; then an error is raised and a message with
"CALL-REJECTED upd_print_page..." is printed on stderr.
uniprint
has lots of messages that can be activated by
setting bits in the preprocessor macro UPD_MESSAGES
. I
usually use the compile-time option -DUPD_MESSAGES=0x17
for
configuration development. (For the semantics, check the
UPD_M_
macros in the source.)
uninfo.ps
" distributed with Ghostscript
displays interactively in alphabetical order the contents of the current
pagedevice dictionary. This includes any parameters generated or changed by
uniprint
.
This table gives a brief explanation of every parameter known to
uniprint
, listing them in alphabetical order. "[ ]"
denotes that a parameter is an array, and "(RO)" that it is read-only.
Alluniprint
parameters
Parameter Type Use
upAbortCommand
String End of page and file on interrupt upAdjustBottomMarginCommand
Bool Manipulate bottom margin in upBeginPageCommand
upAdjustMediaSizeCommand
Bool Manipulate Mediasize
[intended]upAdjustPageLengthCommand
Bool Manipulate page length in upBeginPageCommand
upAdjustPageWidthCommand
Bool Manipulate page width in upBeginPageCommand
upAdjustResolutionCommand
Bool Manipulate resolution upAdjustTopMarginCommand
Bool Manipulate top margin in upBeginPageCommand
upBeginJobCommand
String Begin each output file upBeginPageCommand
String Begin each page upBlackTransfer
Float[ ] Black transfer (CMYK only!) upBlueTransfer
Float[ ] Blue transfer upColorInfo
Int[ ] struct gx_device_color_info
upColorModel
Name Select color mapping upColorModelInitialized
Bool (RO) Color mapping OK upComponentBits
Int[ ] Bits stored per component upComponentShift
Int[ ] Positioning within gx_color_index
upCyanTransfer
Float[ ] Cyan transfer upEndJobCommand
String End each file unless upAbortCommand
upEndPageCommand
String End each page unless upAbortCommand
upErrorDetected
Bool (RO) Severe (VM) error, not fully operational upFSFixedDirection
Bool Inhbits direction toggling in rendering upFSProcessWhiteSpace
Bool Causes white-space rendering upFSReverseDirection
Bool Run rendering in reverse (if fixed) upFSZeroInit
Bool Non-random rendering initialization upFormatXabsolute
Bool Write absolute X coordinates upFormatYabsolute
Bool Write absolute Y coordinates upGreenTransfer
Float[ ] Green transfer upMagentaTransfer
Float[ ] Magenta transfer upMargins
Float[ ] L/B/R/T margins in points upModel
String Comment string, holds some info upOutputAborted
Bool (RO) Caught an interrupt upOutputBuffers
Int Number of rendering buffers (2^N) upOutputComponentOrder
Int[ ] Order of components when printing upOutputComponents
Int Number of written components, not fully operational upOutputFormat
Name Select output format upOutputFormatInitialized
Bool (RO) Format data OK upOutputHeight
Int Output height in pixels upOutputPins
Int Number of pins / nozzles per command upOutputWidth
Int Output width in pixels upOutputXOffset
Int Offset in pixels, if upFormatXabsolute
upOutputXStep
Int Divisor or multiplier for X coords upOutputYOffset
Int Offset in pixels, if upFormatYabsolute
upOutputYStep
Int Divisor or multiplier for Y coords upRasterBufferInitialized
Bool (RO) GS buffer OK upRedTransfer
Float[ ] Red transfer upRendering
Name Select rendering algorithm upRenderingInitialized
Bool (RO) Rendering parameters OK upSelectComponentCommands
String[ ] Establish color (output order!) upSetLineFeedCommand
String Adjust linefeed (Epson only) upVersion
String (RO) Source code version upWeaveFinalPins
Int[ ] Number of bottom pins on EOP passes upWeaveFinalScan
Int Begin EOP passes (Y-coord) upWeaveFinalXStarts
Int[ ] X-pass indices for EOP passes upWeaveFinalYFeeds
Int[ ] Y increments for EOP passes upWeaveInitialPins
Int[ ] Number of top pins on BOP passes upWeaveInitialScan
Int End BOP passes (Y coord) upWeaveInitialXStarts
Int[ ] X-pass indices for BOP passes upWeaveInitialYFeeds
int[ ] Y increments for BOP passes upWeavePasses
Int XPasses × YPasses upWeaveXPasses
Int Number of X passes upWeaveXStarts
Int[ ] X-pass indices for normal passes upWeaveYFeeds
Int[ ] Y increments for normal passes upWeaveYOffset
Int Number of blank or incomplete scans at BOP upWeaveYPasses
Int Number of X passes upWhiteTransfer
Float[ ] White transfer (monochrome devices!) upWriteComponentCommands
String[ ] Commands to write each component upWroteData
Bool (RO) Something ( BeginJob
) written to outputupXMoveCommand
String X positioning command upXStepCommand
String Single step to the right upYFlip
Bool Flips output along the Y axis upYMoveCommand
String Y positioning command upYStepCommand
String Single step down upYellowTransfer
Float[ ] Yellow transfer
uniprint
's Roll of Honor
I should mention all of the people who were involved in
stcolor
's evolution, but I've decided to start from scratch
here for uniprint
:
Gunther Hess
- John P. Beale
- for testing the
stc600
modes- Bill Davidson
- who triggered some weaving research and tested
stc2s_h
- L. Peter Deutsch
- who triggered ease of configuration
- Mark Goldberg
- who prepared the
stc500
transfers- Scott F. Johnston and Scott J. Kramer
- for testing the
stc800
modes- Martin Lottermoser
- for his great commented H-P DeskJet driver
- Helmut Riegler
- for the BJC extension
- Hans-Gerd Straeter
- for some measured transfer curves and more
- Uli Wortmann
- for discussions and his
cdj850
driver- My family
- for tolerating my printer-driver hacking
I wrote this because the documentation was very brief and I really struggled with it for a while, but it is very simple once you understand what is going on.
This only describes how to work out the Y parameters, I haven't looked at the X parameters yet.
You need to know how many nozzles the printer has and the spacing between them. Usually you can find this out from the printer manual, or the printer supplier, but you may have to dissect a couple of printer output files produced with the driver supplied with the printer. There is a utility called escp2ras* that will help with that. Sometimes the term pin is used instead of nozzle but they mean the same thing.
The number of nozzles will be the value assigned to the upOutputPins parameter.
Actually you don't have to print with all the pins available but for the purpose of demonstration I'll assume that we are using them all.
* escp2ras is available from Gunther Hess' page at http://www-md.e-technik.uni-rostock.de/ma/gunther/gs/index.html
The number of passes required is going to depend on the required resolution and the nozzle spacing.
passes = resolution * nozzle spacingThis will be the value assigned to the upWeaveYPasses parameter.
For example if the desired resolution is 360 dpi and the nozzles are spaced at 1/90in then 360 * 1/90 = 4 passes are required. For 720 dpi 8 passes would be required. The printer would, of course, have to be capable of moving the paper in increments of either 360 or 720 dpi too.
You need to work out how much to feed the paper so that when the paper has moved by one head length in however many passes you have then each row space on the paper has been passed over by at least one nozzle. There will be one feed value for each pass and the feed values must comply with the following rules:
sum of feeds = passes * nozzles
feed%passes != 0 (feed is not exactly divisible by passes)
sum of (nozzles - feed) = 0
For example if passes=4 and nozzles=15, then sum of feeds=60. The feed values could be 1,1,1,57 or 15,15,15,15 or 14,15,18,13.
These values will be assigned to the upWeaveYFeeds parameter.
You would need to experiment to see what combination looks best on the printer.
I found it convenient to draw several lines of nozzles and then move them around to see how the different combinations would fill the paper. A computer drawing tool makes this easier than pencil and paper (I used Dia, a GNOME app). The number of nozzles would probably be be a good place to start.
Remember that if the number of passes is more than 1 then the feed increment will be less than the nozzle spacing and passes × feed increment size must equal the physical distance between each nozzle.
These values will be assigned to the upWeaveInitialPins parameter and are the numbers of nozzles to operate in each of the initial passes at the top of a page. The nozzles that the values refer to are the topmost nozzles on the head, nearest the top margin. If the image doesn't start at the top margin then uniprint doesn't use these feeds.
I don't know a mathematical relation for this except that at least one of the values must be the number of nozzles, but I'm sure that there must be one. I used a graphical method, the description that follows refers to the ascii diagram in below.
Draw a line of nozzles for each pass arranged as they would be using the normal Y feed increment determined in step 3. In the diagram below this would be passes 5-8.
Draw a line of nozzles that would print just before the first normal pass. The feed increment for this pass will be close to and most likely 1 or 2 units less than the feed increment of the last normal pass. In the example below this line is pass 4 and the feed increment is 13 whereas the normal feed increment is 15.
Draw each pass before that with a small feed increment so that if all of the nozzles appearing above the first nozzle of the first normal pass operate then all of the spaces will be filled. This feed increment is usually 1 except in cases where some jiggery pokery is going on to make the printer print at an apparent higher resolution than the nozzle diameter.
Now select the nozzles that will operate in each of theses initial passes so that the paper is filled. In each pass the nozzles must be adjacent to each other and at least one of the passes will have all the nozzles operating. I suspect that for each combination of normal Y feed increments there will only be one set of valid beginning of page increments.
The following diagram shows which nozzles operate during each pass.-dupWeaveYPasses=4 -dupOutputPins=15 -dupWeaveYFeeds="{15 15 15 15}" -dupWeaveInitialYFeeds="{1 1 1 13}" -dupWeaveInitialPins="{ 4 15 11 7}"
x=nozzle operates, o=nozzle not used in this pass
1 2 3 4 5 6 7 8 - pass no
0 x
1 x
2 x
3 x
4 x
5 x
6 x
7 x
8 x
9 x
0 x
1 x
2 x
3 x
4 x
5 x
6 o x
7 x
8 x
9 x
0 o x
1 x
2 x
3 x
4 o x
5 x
6 x
7 x
8 o x
9 x
0 x
1 o x
2 o x
3 x
4 x
5 o x
6 o x
7 x
8 x
9 o x
0 o x
1 x
2 x
3 o x
4 o x
5 x
6 o x
7 o x
8 o x
9 x
0 o x
1 o x
2 o x
3 x
4 o x
5 o x
6 o x
7 x
8 o x
9 o x
0 x
1 x
2 x
3 x
4 x
5 x
6 x
7 x
8 x
9 x
0 x
1 x
2 x
3 x
4 x
5 x
6
7 x
8 x
9 x
0
1 x
2 x
3 x
4
5 x
6 x
7 x
8
9 x
0 x
1
2
3 x
4 x
5
6
7 x
8 x
9
0
1 x
2 x
3
4
5 x
6
7
8
9 x
0
1
2
3 x
4
5
6
7 x
These parameters would also work:
-dupWeaveYPasses=4 -dupOutputPins=15 -dupWeaveYFeeds="{14 15 18 13}" -dupWeaveInitialYFeeds="{1 1 1 13}" -dupWeaveInitialPins="{ 4 11 7 15}"
The Epson Stylus Color 300 uses a different command set to other Epson
Stylus Color printers that use the ESC/P2 language. As far as I can
tell its commands are a subset of ESC/P2. In ESC/P2 the colour to be
printed is selected by a 'set colour' command and then the data sent
is only printed in that colour until the colour is changed with another
'set colour' command. The Stylus Color 300 lacks this functionality.
The data sent to the printer maps directly to the ink nozzles and colour
of an output scan line in the printed output is determined by the position
of the scan line within the data. This means that the driver must know
how the nozzles are arranged and must format the output accordingly.
The extension adds a format that I have called EscNozzleMap and adds some
additional parameters to uniprint.
upOutputFormat
selects the output method, and should be set to the value
/EscNozzleMap
to select this format.
/EscNozzleMap
produces output for the Epson Stylus Color 300
uniprint
parameters for the EscNozzleMap formatParameter Type Use upNozzleMapRowsPerPass
Int output rows to generate for each pass of the head upNozzleMapPatternRepeat
Int no. of rows that correspond to the repeat pattern of the nozzles upNozzleMapRowMask
Int[] mask indicating the colour of the nozzles upNozzleMapMaskScanOffset
Int[] mask indicating the physical position of the nozzles
upNozzleMapRowsPerPass
upNozzleMapPatternRepeat
upNozzleMapRowMask
A value of 0 means that the nozzle is not used and the row in the output data will be padded with zeros.
colour mask value K
1 C
2 M
3 Y
4 no data
0
upNozzleMapMaskScanOffset
etc ... | |||||||||||||||||||
The weaving parameters are the same as for any other uniprint driver but they must be consistent with the nozzle map parameters. In this printer the coloured nozzles are spaced at 1/60" so 6 passes are required for 360 dpi resolution.-dupWeaveYPasses=6 -dupOutputPins=11 -dupWeaveYFeeds="{ 11 11 11 11 11 11 }" -dupWeaveInitialYFeeds="{ 1 1 1 1 1 7 }" -dupWeaveInitialPins="{ 2 11 9 7 5 3 }" -dupNozzleMapRowsPerPass=64 -dupNozzleMapPatternRepeat=6 -dupNozzleMapRowMask="{ 2 4 1 3 0 0 }" -dupNozzleMapMaskScanOffset="{ 0 1 2 3 0 0 }"
In the example there are 64 rows of data required for each head pass. Each row must be completely filled with data for each pass so if certain nozzles do not print in the pass then the rows for those nozzles will be padded with zeroes.
The row mask translates to "C Y K M 0 0" so in the output data rows 0,7,13,... will contain data for cyan, rows 1,8,14,... will contain data for yellow, etc. Rows 4,10,16,... and 5, 11,15,... will always be padded with zeroes. The upNozzleMapPatternRepeat parameter defines the length of the mask.
The row mask is repeated for each group of upNozzleMapPatternRepeat rows in the output data. In this case there are 64 rows so there will be 10 groups of "C Y K M 0 0" followed by "C Y K M" which is equivalent to 11 output pins.
The upNozzleMaskScanOffset array indicates how the data from the scan buffer is mapped to the output data. The data is presented to the formatter as a buffer of four colour scanlines. The index of the scanline being printed, lets call it y, always corresponds, in this example, to the physical position of the cyan nozzle but since the nozzles are not on the same horizontal line then the other colours for the current pass must come from other scanlines in the scan buffer. The example is { 0 1 2 3 0 0 }, this means that when printing a 4 colour image the magenta data would come from scanline y+3, the black from scanline y+2, etc. It would have been possible in this case to use the array index instead of the upNozzleMaskScanOffset parameter however the parameter is necessary to be able to use the full capability of the printer in black only mode.
In this example there is no weaving.-dupMargins="{ 9.0 39.96 9.0 9.0}" -dupWeaveYPasses=1 -dupOutputPins=31 -dupNozzleMapRowsPerPass=64 -dupNozzleMapPatternRepeat=6 -dupNozzleMapRowMask="{ 0 0 1 0 1 1}" -dupNozzleMapMaskScanOffset="{ 0 0 0 0 1 2 }"
The ESC300 has black nozzles evenly physically arranged as K K K but the data must be sent to the printer as 00K0KK. This is handled by the upNozzleMapRowMask and upNozzleMaskScanOffset arrays. The upNozzleMapRowMask array is { 0 0 1 0 1 1} which translates to { 0 0 K 0 K K } so rows 0, 1 and 3 will always contain zeros and the other rows will contain data.
The upNozzleMaskScanOffset array in this case is { 0 0 0 0 1 2 } so if the data for the 1st nozzle comes from row y in the scan buffer then the data for the 2nd and 3rd nozzles will come from rows y+1 and y+2.
In this example 2 weave passes are required to achieve the desired resolution.-dupWeaveYPasses=2 -dupOutputPins=31 -dupWeaveYFeeds="{31 31}" -dupWeaveInitialYFeeds="{1 31}" -dupWeaveInitialPins="{16 31}" -dupNozzleMapRowsPerPass=64 -dupNozzleMapPatternRepeat=6 -dupNozzleMapRowMask="{ 0 0 1 0 1 1}" -dupNozzleMapMaskScanOffset="{ 0 0 0 0 2 4 }"
The upNozzleMaskScanOffset array in this case is { 0 0 0 0 2 4 } because there are two weave passes so if the data for the first nozzle comes from row y in the scan buffer then the data for the 2nd and 3rd nozzles must come from rows y+(1*2) and y+(2*2).
Glenn Ramsey
Copyright © 2000-2006 Artifex Software, Inc. 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 that license. Refer to licensing information at http://www.artifex.com/ or contact Artifex Software, Inc., 7 Mt. Lassen Drive - Suite A-134, San Rafael, CA 94903, U.S.A., +1(415)492-9861, for further information.
Ghostscript version 8.64, 3 February 2009