SuSE Linux: Versions since 8.2
/etc/cups/mime.types
and /etc/cups/mime.convs
.
Where appropriate for each printing queue, the *cupsFilter
entries in the PPD file are used.
/etc/cups/mime.types
,
data in PostScript format has the MIME type
application/postscript
.application/postscript application/vnd.cups-postscript 66 pstops
/etc/cups/mime.convs
, data with the MIME type
application/postscript
is converted to data with the MIME type
application/vnd.cups-postscript
by means of the CUPS filter pstops
(i.e., with /usr/lib/cups/filter/pstops
).66
units.
application/vnd.cups-postscript
is sent to the PostScript printer.
/etc/cups/mime.types
, ASCII texts have the
MIME type text/plain
.text/plain application/postscript 33 texttops
/etc/cups/mime.convs
, data with the mime type text/plain
is converted to data with the mime type application/postscript
by means
of the CUPS filter texttops
(i.e., with
/usr/lib/cups/filter/texttops
).33
units.
application/postscript
is
converted to data with the MIME type application/vnd.cups-postscript
by
way of the CUPS filter /usr/lib/cups/filter/pstops
with a cost of 66
.application/vnd.cups-postscript
is sent to the PostScript
printer.
application/postscript
is converted to data with the MIME type application/vnd.cups-postscript
by way of the CUPS filter /usr/lib/cups/filter/pstops
.
*cupsFilter
entry in a PPD file, such as a Foomatic PPD file:*cupsFilter: "application/vnd.cups-postscript 0 foomatic-rip"
,application/vnd.cups-postscript
is converted to
printer-specific data (e.g., PCL data for a PCL printer) by way of the Foomatic filter
/usr/lib/cups/filter/foomatic-rip
.
text/plain
is converted to data
with the MIME type application/postscript
by means of the CUPS filter
/usr/lib/cups/filter/texttops
.
application/postscript
is converted to data with
the MIME type application/vnd.cups-postscript
with the CUPS filter
/usr/lib/cups/filter/pstops
.
application/vnd.cups-postscript
is converted to
printer-specific data with the Foomatic filter /usr/lib/cups/filter/foomatic-rip
.
/usr/lib/cups/filter/texttops
-- see
CUPS Software User Manual: text options
/usr/lib/cups/filter/pstops
-- see
CUPS Software User Manual: document options
/usr/lib/cups/filter/foomatic-rip
-- see
CUPS Software User Manual: printer options
A 1200x1200 dpi bitmap graphic requires sixteen times as much memory as a 300x300 dpi one. 32-bit color depths need 32 times as much as a 1-bit black and white image. Thus, a 1200x1200 dpi bitmap graphic with a 32-bit color depth requires more than 500 times as much memory as the same graphic in 1-bit black and white with a 300x300 dpi resolution.
The direct solution is to reduce the resolution and color depth values in the application used to create the PostScript file. The printing system can convert problematic PostScript documents to PCL data (with a smaller resolution or color depth, if necessary) as described above. To be printed, PCL data requires (depending on the resolution and color depth) a printer with substantially less memory. PostScript printers usually can also be addressed via PCL. Most PostScript+PCL printers automatically detect the data type and switch back and forth between the PostScript and PCL mode.
The easiest approach consists of creating an additional queue for a PostScript+PCL printer. This queue always produces PCL data by using a PPD file for a compatible PCL printer.
The main disadvantage of using several queues for the same printer is that it is necessary to query all queues to display all waiting or active print jobs for that printer. Although not a problem for single printers or stand-alone systems, the use of several queues per printer might prove too complicated in the case of several network printers used by many users. For this reason, there should only be one queue for each PostScript+PCL printer that can alternatively produce PCL data to enable problematic PostScript documents to be printed via PCL (with a smaller resolution and color depth, if necessary).
A more general, simpler approach consists of creating an additional queue for the printer. This queue
uses the generic Foomatic PPD file
/usr/share/cups/model/Generic/PostScript_Printer-Postscript.ppd.gz
,
because this way there is an option to produce PostScript level 1 or 2
through preprocessing with Ghostscript.
/etc/cups/ppd/queue.ppd
and insert the line
*cupsFilter: "text/plain 0 TextToPrinter"
under the line*cupsFilter: "application/vnd.cups-postscript 0 foomatic-rip"
The purpose of *cupsFilter
entries in PPD files is the conversion to
printer-specific data, which is subsequently sent to the printer.
This particular entry directly converts all data with the MIME type text/plain
to printer-specific data by way of /usr/lib/cups/filter/TextToPrinter
, without
the intervention of other filters.
Therefore it is not possible to customize the printout when printing data with the MIME type
text/plain
in this queue because the necessary CUPS and Foomatic filters
are missing.
/usr/lib/cups/filter/TextToPrinter
is the filter script that must be
created for the conversion of ASCII text to printer-specific code.
This script must be exactly tuned to the printer model.
Many dot matrix printers include a character code compatible with IBM PC.
You can use the command recode "lat1..ibmpc"
to convert the ASCII text
to IBM PC-compatible character code.
If the printer is attached to the first parallel interface, use the following command
echo -en "\rline 1\numlauts: ÄÖÜäöüß\nline 3\f" | recode "lat1..ibmpc" >/dev/lp0to test if
recode "lat1..ibmpc"
produces the right printer-specific code. If this is not
the case, recode
offers many more recoding possibilities. As a
last resort, you can use (additionally) tr
to convert single characters
or sed
to convert character strings. Refer to the relevant man pages.
This script displays the printable characters along with their octal codes:
#! /bin/bash # carriage return before printing echo -en "\r" # print printable 8-bit characters (CR, NL, TAB, BS, 32-126, 128-254) echo -en "the special characters horizontal tab and backspace:\r\n" echo -en "the next line consists of 5 horizontal tabs each followed by I\r\n" echo -en "\tI\tI\tI\tI\tI\r\n" echo -en "the next line consists of C backspace and =\r\n" echo -en "C\b=\r\n" echo -en "the printout of C backspace and = may look like an Euro sign\r\n" echo -en "\nthe printable 7-bit octal codes (040-176) and characters:\r\n" for i in 04 05 06 07 10 11 12 13 14 15 16 do for j in 0 1 2 3 4 5 6 7 do echo -en "${i}${j} \\${i}${j} " done echo -en "\r\n" done for i in 170 171 172 173 174 175 176 do echo -en "${i} \\${i} " done if test "$1" = "7" then # form feed after printing echo -en "\r\f" exit 0 fi echo -en "\r\n" if test "$1" = "a" then echo -en "\nthe 8-bit octal codes (200-237) and characters:\r\n" for i in 20 21 22 23 do for j in 0 1 2 3 4 5 6 7 do echo -en "${i}${j} \\${i}${j} " done echo -en "\r\n" done fi echo -en "\nthe printable 8-bit octal codes (240-376) and characters:\r\n" for i in 24 25 26 27 30 31 32 33 34 35 36 do for j in 0 1 2 3 4 5 6 7 do echo -en "${i}${j} \\${i}${j} " done echo -en "\r\n" done for i in 370 371 372 373 374 375 376 do echo -en "${i} \\${i} " done # form feed after printing echo -en "\r\f"Without entering any additional parameters, the output is the usually easy-to-print 8-bit code. By introducing
7
as a parameter, only printable 7-bit ASCII code will be
produced.
The parameter a
produces all printable 8-bit code, but this may overwrite the
terminal settings in the process. Thus, the parameter a
is not suitable
for display on screen.
If the printer is attached to the first parallel interface, you can find out the required recoding by launching this script with a command similar to
Script a >/dev/lp0The output will be the character set integrated in the printer. This way, the necessary character encoding can be exactly determined.
If the recode
command above produces the right printer-specific code,
/usr/lib/cups/filter/TextToPrinter
may look like this:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # have the input at fd0 (stdin) in any case [ -n "$6" ] && exec <"$6" # carriage return before printing echo -en "\r" # printing recode "lat1..ibmpc" # form feed after printing echo -en "\f"
/usr/lib/cups/filter/
.
cupsd
.
echo -en "line 1\numlauts: ÄÖÜäöüß\nline 3" | a2ps -1 -o - | lp -d queue lp -d queue /usr/share/doc/packages/ghostscript/examples/colorcir.psPostScript is processed by the CUPS filter system as described above. As a result, the above-mentioned CUPS filter calls can be found in
/var/log/cups/error_log
:
I ... Started filter /usr/lib/cups/filter/pstops I ... Started filter /usr/lib/cups/filter/foomatic-rip
echo -en "line 1\numlauts: ÄÖÜäöüß\nline 3" | lp -d queue lp -d queue /usr/lib/cups/filter/TextToPrinterNow
/var/log/cups/error_log
contains only the filter call:
I ... Started filter /usr/lib/cups/filter/TextToPrinterIf
LogLevel debug
has been activated in /etc/cups/cupsd.conf
,
the debugging output from /usr/lib/cups/filter/TextToPrinter
can be seen
in /var/log/cups/error_log
:
D ... + '[' -n /var/spool/cups/... ']' D ... + exec D ... + echo -en '\r' D ... + recode lat1..ibmpc D ... + echo -en '\f'
text/plain
:
If you want to use a dot matrix printer to fill in forms with carbon
copies on continuous stock by printing plain ASCII text in printer-specific code,
it usually makes no sense to accept data with a MIME type other than text/plain
.
To ignore all data with a MIME type other than text/plain
, open the PPD
file and change the *cupsFilter
entry for the MIME type
application/vnd.cups-postscript
as follows:
*cupsFilter: "application/vnd.cups-postscript 0 /bin/true"By doing this,
/bin/true
is activated for all data whose MIME type
is not text/plain
in the last filtering stage. This logs a
successful conclusion without any processing and all temporarily-stored data is
subsequently deleted.
text/plain
except the
relevant form data:
If you want to use a dot matrix printer to fill in forms with carbon
copies on continuous stock, it usually makes no sense to accept data with the
MIME type text/plain
other than the relevant form data.
To accept form data only, this must be distinguishable,
for instance, by a particular character string in the first line.
If the first line contains, for example, the string Foo...Bar
,
/usr/lib/cups/filter/TextToPrinter
might be similar to:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # pattern must match by "egrep -i" in first input line pattern="foo.*bar" # have the input at fd0 (stdin) in any case [ -n "$6" ] && exec <"$6" # testing read -t 1 -r line echo $line | egrep -i -q "$pattern" || exit 0 # carriage return before printing echo -en "\r" # printing echo $line | recode "lat1..ibmpc" recode "lat1..ibmpc" # form feed after printing echo -en "\f"When testing with the command
echo -en "line 1\numlauts: ÄÖÜäöüß\nline 3" | lp -d queuenothing is printed and
/var/log/cups/error_log
contains
... D ... + egrep -i -q 'foo.*bar' D ... + exit 0However, the test command
echo -en "line 1: FooBar\numlauts: ÄÖÜäöüß\nline 3" | lp -d queueproduces the requested output.
In the above case (dot matrix printer prints only plain ASCII text), it is sufficient to create the queue without a PPD file. Instead, use the filter script above as "System V style interface script":
lpadmin -p queue -i /usr/lib/cups/filter/TextToPrinter ...The filter script actually executed by CUPS is
/etc/cups/interfaces/queue
, which is
a copy of /usr/lib/cups/filter/TextToPrinter
.
Any kind of input data is only processed by the "System V style interface script". Therefore, it is not possible to customize the printout in this queue because the necessary CUPS and Foomatic filters are missing.
/usr/share/cups/model/Postscript.ppd.gz
or the generic Foomatic
PPD file /usr/share/cups/model/Generic/PostScript_Printer-Postscript.ppd.gz
to operate the printer as a generic PostScript printer.
/etc/cups/ppd/queue.ppd
as follows:
*cupsFilter: "application/postscript-problematic 0 PsToPCL" *cupsFilter: "application/vnd.cups-postscript 0 foomatic-rip"or insert the following lines in
/etc/cups/ppd/queue.ppd
as in the
generic Foomatic PPD file:
*cupsFilter: "application/postscript-problematic 0 PsToPCL" *cupsFilter: "application/vnd.cups-postscript 0 ToPrinter"The purpose of
*cupsFilter
entries in PPD files is the conversion to
printer-specific data that is subsequently sent to the printer.
This particular entry directly converts all data with the MIME type
application/postscript-problematic
to printer-specific data by way of /usr/lib/cups/filter/PsToPCL
without
the intervention of other filters.
It is not possible to customize the printout when printing data with the MIME type
application/postscript-problematic
in this queue because the necessary
CUPS and Foomatic filters are missing.
application/postscript-problematic
as an additional
line:
application/postscript-problematicin
/etc/cups/mime.types
. Otherwise, CUPS will not accept this MIME type.
Additionally, look at
CUPS Software Administrators Manual: Adding Filetypes and Filters.
/usr/lib/cups/filter/PsToPCL
is the filter script that must be
created for the conversion of PostScript to printer-specific code.
This script must be exactly tuned to the printer model.
Most PostScript+PCL printers understand the print language PCL5e, which is produced by
the Ghostscript drivers ljet4
and lj4dith
for Floyd-Steinberg
dithering and ljet4d
for duplex printing with resolutions up to 600 dpi.
If the printer is attached to the first parallel interface, use the following Ghostscript
command to test whether ljet4
(or other PCL5e drivers) produces the right
printer-specific code.
gs -q -dBATCH -dNOPAUSE -sDEVICE=ljet4 -sOutputFile=/dev/lp0 /usr/share/doc/packages/ghostscript/examples/colorcir.psIf this is not the case, Ghostscript offers additional PCL drivers (see the SDB article "Purchase of Printers and Compatibility" (http://sdb.suse.de/en/sdb/html/jsmeix_print-kompatibel.html)).
If the color ellipse has been properly printed with the command gs
mentioned above, the filter
/usr/lib/cups/filter/PsToPCL
to convert data with the MIME type
application/postscript-problematic
with ljet4
to PCL5e with a resolution of 300 dpi might look like this:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # have the input at fd0 (stdin) in any case [ -n "$6" ] && exec <"$6" # printing gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=ljet4 -r300 -sOutputFile=- -
application/vnd.cups-postscript
and will be either processed with /usr/lib/cups/filter/foomatic-rip
or directly sent to the printer by /usr/lib/cups/filter/ToPrinter
.
/usr/lib/cups/filter/ToPrinter
may be similar to:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # have the input at fd0 (stdin) in any case [ -n "$6" ] && exec <"$6" # printing cat -
/usr/lib/cups/filter/
.
cupsd
.
-o document-format=application/postscript-problematicenables you to set the MIME type of the PostScript document to print to
application/postscript-problematic
on the command line.
Depending on whether this option is set, data will be processed with the
specific filter /usr/lib/cups/filter/PsToPCL
or with the common CUPS filters.
Because Ghostscript only accepts PostScript data as input from stdin, the MIME type
application/postscript-problematic
can only be used for PostScript documents.
You can print a PostScript test page with /usr/lib/cups/filter/PsToPCL
with the command:
lp -d queue -o document-format=application/postscript-problematic /usr/share/doc/packages/ghostscript/examples/colorcir.psAs a result,
/var/log/cups/error_log
contains:
I ... Started filter /usr/lib/cups/filter/PsToPCL ... D ... + '[' -n /var/spool/cups/... ']' D ... + exec D ... + gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=ljet4 -r300 -sOutputFile=- -
-o document-format=application/postscript-problematicis already preset:
lpoptions -o document-format=application/postscript-problematic -p queue/problematicBy doing this, you avoid needing to enter this option on the command line every time by simply entering the queue instance:
lp -d queue/problematic /usr/share/doc/packages/ghostscript/examples/colorcir.ps
application/postscript-problematic
is not available on the network, but only on the local host.
To print from a remote client where a local cupsd
is running,
/etc/cups/mime.types
on the client host
or specify the CUPS server in the print command:
lp -d queue -h server -o document-format=application/postscript-problematic
cupsd
but a ServerName
entry
in /etc/cups/client.conf
).
Thus, if you want to print from a remote client, the option must be explicitly entered on the command line every time or the instance must be created on the client host.
Ghostscript can also handle PDF documents directly, but only if they have been received as ordinary files instead of via stdin.
According to
CUPS Software Programmers Manual: Writing Filters: Command-Line Arguments,
only the first filter in the chain receives its input from CUPS spool file and
/usr/lib/cups/filter/PsToPCL
is the only filter. Therefore, this filter
can be changed as follows so Ghostscript can receive its input directly from
CUPS spool file:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # set inputfile to where the input comes from inputfile="-" [ -n "$6" ] && inputfile="$6" # printing gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=ljet4 -r300 -sOutputFile=- $inputfile
Many PostScript+PCL printers understand the job control language PJL.
If your printer does not switch automatically from PostScript to PCL but supports
PJL, the switch can be forced with PJL commands.
/usr/lib/cups/filter/PsToPCL
can be expanded to enable
the corresponding PJL commands to be sent before and after the PCL data:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # set inputfile to where the input comes from inputfile="-" [ -n "$6" ] && inputfile="$6" # switch to PCL and do a PCL reset echo -en "\033%-12345X@PJL ENTER LANGUAGE = PCL\n\033E" # printing gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=ljet4 -r300 -sOutputFile=- $inputfile # PCL reset and PJL end of job echo -en "\033E\033%-12345X\n"In the same way, control commands in job control languages other than PJL can be sent to the printer.
After having switched from PostScript to PCL with PJL commands, the
final PJL string \033%-12345X
should switch the printer back to
its original PostScript mode.
To force the switch from PCL to PostScript with PJL commands, expand
/usr/lib/cups/filter/ToPrinter
as follows:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # have the input at fd0 (stdin) in any case [ -n "$6" ] && exec <"$6" # switch to PostScript echo -en "\033%-12345X@PJL ENTER LANGUAGE = POSTSCRIPT\n" # printing cat - # PostScript end of transmission and PJL end of job echo -en "\004\033%-12345X\n"If a queue has been created with the printer-specific PPD file of the manufacturer, the corresponding job control commands should be included in the PPD (as
*JCL...
entries). CUPS automatically sends these commands to the printer and, thus, any additional
job control commands will not be required.
If your printer understands PCL and PJL, you can use PJL commands to activate some printing options.
The syntax of a PJL+PCL print job is:
\033%-12345X@PJL SET option-1 = value-1 @PJL SET option-2 = value-2 ... @PJL SET option-n = value-n @PJL ENTER LANGUAGE = PCL PCL-commands+data\033%-12345XEvery PJL print job must begin and end with exactly one "Universal Exit Language" command
\033%-12345X
.
Every PJL line must end with exactly one linefeed character \n
.
Possible options and their values depend on the printer model.
If the printer is attached to the first parallel interface, use the following command to test if the PJL commands work as requested. This example activates the toner economy mode and the manual confirmation before printing (e.g., to be able to insert special paper):
echo -en "\033%-12345X@PJL SET ECONOMODE = ON\n@PJL SET MANUALFEED = ON\n@PJL ENTER LANGUAGE = PCL\n" >/dev/lp0 gs -q -dBATCH -dNOPAUSE -sDEVICE=ljet4 -sOutputFile=/dev/lp0 /usr/share/doc/packages/ghostscript/examples/colorcir.ps echo -en "\033%-12345X\n" >/dev/lp0Expand
/usr/lib/cups/filter/PsToPCL
as follows to send the corresponding
PJL commands:
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # set inputfile to where the input comes from inputfile="-" [ -n "$6" ] && inputfile="$6" # PJL printer setup echo -en "\033%-12345X@PJL SET ECONOMODE = ON\n@PJL SET MANUALFEED = ON\n" # switch to PCL and do a PCL reset echo -en "@PJL ENTER LANGUAGE = PCL\n\033E" # printing gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=ljet4 -r300 -sOutputFile=- $inputfile # PCL reset and PJL end of job echo -en "\033E\033%-12345X\n"
application/postscript-pswrite
as an additional line
application/postscript-pswritein
/etc/cups/mime.types
.
Additionally, have a look at
CUPS Software Administrators Manual: Adding Filetypes and Filters.
application/postscript-pswrite application/postscript 33 PsWritein
/etc/cups/mime.convs
.
Additionally, have a look at
CUPS Software Administrators Manual: Adding Filetypes and Filters.
By doing this, all data with the MIME type application/postscript-pswrite
will be converted to data with the MIME type application/postscript
by means of
/usr/lib/cups/filter/PsWrite
.
This filter is available for all queues.
The printout of data with the MIME type application/postscript-pswrite
can be customized to a large extent because data with the MIME type
application/postscript
goes through the common CUPS and Foomatic filters. However, the possibilities of
/usr/lib/cups/filter/pstops
according to
CUPS Software Users Manual: Document Options
do not always work in connection with PostScript preprocessing. Nevertheless, at least the
printer-specific options according to the PPD file should work.
pswrite
is used for PostScript preprocessing with Ghostscript.
If the printer is attached to the first parallel interface, use the following Ghostscript commands
gs -q -dBATCH -dNOPAUSE -sDEVICE=pswrite -sOutputFile=/dev/lp0 /usr/share/doc/packages/ghostscript/examples/colorcir.ps gs -q -dBATCH -dNOPAUSE -sDEVICE=pswrite -dLanguageLevel=2 -sOutputFile=/dev/lp0 /usr/share/doc/packages/ghostscript/examples/colorcir.ps gs -q -dBATCH -dNOPAUSE -sDEVICE=pswrite -dLanguageLevel=1 -sOutputFile=/dev/lp0 /usr/share/doc/packages/ghostscript/examples/colorcir.psto find out which
LanguageLevel
produces the right printer-specific data.
If the printer is equipped with PostScript level 1, the filter
/usr/lib/cups/filter/PsWrite
may be similar to
#! /bin/bash # see http://localhost:631/spm.html#WRITING_FILTERS # debug info in /var/log/cups/error_log set -x # set inputfile to where the input comes from inputfile="-" [ -n "$6" ] && inputfile="$6" # printing gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=pswrite -dLanguageLevel=1 -sOutputFile=- $inputfile
/usr/lib/cups/filter/
.
cupsd
.
-o document-format=application/postscript-pswriteenables you to set the MIME type of the PostScript document to print to
application/postscript-pswrite
on the command line.
Depending on whether this option is set, data will be preprocessed with the
specific filter /usr/lib/cups/filter/PsWrite
or only the common CUPS filtering is done.
Because /usr/lib/cups/filter/PsWrite
is the first filter in the chain, it receives
its input directly from CUPS spool file as described in
CUPS Software Programmers Manual: Writing Filters: Command-Line Arguments.
Thus, preprocessing PDF documents is possible, too.
You can print a PostScript test page with /usr/lib/cups/filter/PsWrite
with the command:
lp -d queue -o document-format=application/postscript-pswrite /usr/share/doc/packages/ghostscript/examples/colorcir.psAs a result,
/var/log/cups/error_log
contains:
I ... Started filter /usr/lib/cups/filter/PsWrite I ... Started filter /usr/lib/cups/filter/pstops ... D ... + gs -q -dBATCH -dPARANOIDSAFER -dNOPAUSE -sDEVICE=pswrite -dLanguageLevel=1 -sOutputFile=- /var/spool/cups/...
-o document-format=application/postscript-pswriteis preset.
In any case, Ghostscript must be able to process the PostScript or PDF document. If both the printer's PostScript interpreter and Ghostscript fail to process the document, it is probably so faulty that it is impossible to print.
The attempt to print a particular document from an application might fail because the application's PostScript output cannot be completely processed by the printing system (or not at all). This can be verified by printing from the application used to create the problematic PostScript or PDF document to a PostScript file. Alternatively, you can also take the existing PostScript or PDF document and display it page by page on your graphical interface by executing
gs -r60 file_namein a terminal and confirming with the enter key. To close the displayed document, press the key combination [Ctrl]+[C] in the terminal. If the PostScript or PDF file is not properly displayed on a second window or Ghostscript error messages are displayed in the terminal where the gs command has been executed, Ghostscript is not able to process the application's PostScript output.
The problem is sometimes caused by special characters or fonts that cannot be produced in PostScript by the application in such a way that enables Ghostscript or the printer to process them. The problem can be avoided by not using these characters or fonts.
SDB-jsmeix_print-cups-filters
)