Notes about Linux printing (very draft)

Printing overview (231230)

Printing is not complicated:

Files to print are converted by some document processor from some kind of text markup or image format into a display format, often PDF or PostScript.
Then the PDF or PostScript files are rendered into whatever format the printer requires (which can be a simple bit or pixel raster) unless the printer accept PDF or PostScript directly.
Note: sometimes it is better to render on the print server even if the printer supports PDF or PostScript if the printer support is very slow or is constrained by limited memory.
Note: in addition to PDF or PostScript many printers support the PCL by HP or many others.
Finally the data is sent to the printer using some kind of transmission protocol.

So in general all that is needed apart from a queueing system is a way for PDF or PostScript to be rendered or left alone, and then for a way to send the data to the printer.

The rest of this document is mostly about the spooler CUPS and related tools, because it is by far the most complicated, and underdocumented (and most common unfortunately), but it also covers more general issues.

Print spooler (231230)

CUPS (231230)

CUPS is designed to be user friendly (actually developer job security friendly) so all this is done in as complicated and fragile a way as possible by using a creepy web frontend that actually edits files under /etc/:

CUPS has these crucial directories:
- /etc/cups/mime/: this contains various specifications of page languages and which filter to use to convert it to another format, usually another page language or a printer language, for example raster or PDF or PostScript.
- /usr/lib/cups/filter/: this contains various programs mentioned in the MIME tables that convert from several page languages to several printer languages, usually to PDF or bare PostScript, sometimes to some kind of raster format; or from raster format to some printer language.
- /etc/cups/ppd/: this contains PostScript-related PPD files that describe a printer type and its default characteristics (for example paper size) and printing options. PPD file are used for both PostScript and non-PostScript printers, as there are so many ready-made.
- /usr/lib/cups/driver/: programs that take a page language and convert it to some printer languages using some filter. The lpinfo -m command lists drivers and the printers they support.
- /usr/lib/cups/backend/: programs that connect to a printer with various protocols, notably IPP, LPD, USB, HP JetDirect, and send to the printer the printer language data and receive printer or job status in return. The lpinfo -v command lists backends known to CUPS.

Future releases of CUPS will only support IPP Everywhere printers, which must support as page languages JPEG, PWG raster and PDF and therefore CUPS will become driverless:

CUPS printer drivers and backends are deprecated and will no longer be supported in a future feature release of CUPS. Printers that do not support IPP can be supported using applications such as ippeveprinter(1).

The critical details are:

In the printer description the name of the backend that handles the protocol to the printer, followed by the printer identification. For example:
```
DeviceURI			usb://EPSON/WF-110%20Series
```
The printer identification is used to determine the backend for the printer, in the example usb and the identification is passwd to the backend so it can send the printer language data
In the PPD the cupsFilter setting, which indicates which driver to use to convert the page language to the printer language and the expected type of the page language. For example these describe printer drivers that can directly accept PDF or PostScript:
```
*cupsFilter: "application/vnd.cups-pdf 0 foomatic-rip"
*cupsFilter: "application/vnd.cups-postscript 100 foomatic-rip"
```
These describe printer drivers that accept as input raster data and convert it to the format needed for ESC/P-R printers or HP PCL printers:
```
*cupsFilter: "application/vnd.cups-raster 0 /usr/lib/cups/filter/epson-escpr-wrapper"
*cupsFilter: "application/vnd.cups-raster 0 hpcups"
```
Once CUPS has the printer language name MIME string, and it has the MIME string for the page language file it has been sent, it needs to deduce the renderer that converts the document language to the page language, and to do this it uses a table

LPR-ng (231230)

`lpr` (231230)

LPD (231230)

Page languages (231230)

`groff_out` (231230)

DVI (231230)

PostScript (231230)

PDF (231230)

XPS (231230)

Printer languages (231230)

PCL (231230)

PCL comes in several different levels and dialects for HP printers, and many other printer manufacturers offer PCL compatibility. The most common PCL level are PCL5 and PCL6.

ESC/P (231230)

This is the first printer language for IBM PC-compatible printers, as the first printer for that was an EPSON printer with this command language. It also comes in several variants and levels, of which the most common is ESC/P-R.

Prescribe (231230)

This is the printer language for Kyocera printers and it is somewhat similar in concept to PostScript. The most common level seems to be version 3.

Main renderers (231230)

Renders can be divided in high-level renderers, that translate a page language into a similarly high-level printer language, and low-level renderers also called rasterizers that translate a page language into a bit or pixel raster, for those printers that do not have a built-in rasterizer, or their rasterizer is too limited in speed or memory.

Main high-level renderers (231230)

dvips
dvipdf*
dvilj*

Main low-level renderers (231230)

Ghostcript
CUPS filters
dvi2tty

Notes about Linux printing