IPP> MOD and printers with separate RIP processor

IPP> MOD and printers with separate RIP processor

IPP> MOD and printers with separate RIP processor

Anthony Porter anthony.porter at computer.org
Wed Mar 24 08:14:41 EST 1999


There are a number of minor problems regarding MOD and high-end printers
that use a separate RIP engine.

The RIP converts the document source from PostScript or pdf to raw image
data.  Office printers with a PostScript processor usually RIP each page
just before printing it, and can RIP most office documents pretty quickly.
Documents that contain a lot of graphics may take an appreciable amount of
time to RIP, and so most high-end printing systems have a separate RIP
engine.  Web printers, that print from a huge roll and chop up the output as
it emerges, cannot stop and start without wasting a few yards of paper, so
it is important that the source is RIPped before it is printed.

This means that as jobs enter the system, the printer first tries to get
them RIPped, according to priority, and in parallel to this it is trying to
ensure that the print unit is kept supplied with RIPped jobs.  If the print
unit stops, because of a paper jam, or because the operator is replenishing
the consumables, the printer will still continue to RIP jobs.  Conversely,
if the RIP stops because there is no more space available for image data,
the print unit will continue.

MOD 1.1 does not make any distinction between RIPping and printing, so if
the printer is engaged in either of these activities the "printer-state"
attribute is "processing".  This means that the state would be "processing"
even though the actual print unit has stopped because of a paper jam, but
that contradicts 4.4.10 line 3620 which states that none of the reasons may
prevent a job from completing.  If we say that the state is not "processing"
but "stopped" that will contradict line 3626 which says that the job being
RIPped must transit to the pending state.

Furthermore, when the printer is in the "processing" state, line 3619 states
that new jobs may only transit into the "processing" state when all the jobs
ahead of it have been completed, implying that there is only one job in the
processing state.  The printer will be obliged to break this rule, since it
must start process jobs in parallel in order to maintain throughput.  This
could break clients that only expect to find one job in the processing
state.  Even if we ignore the RIP, the print path of these machines is so
long that they will start printing a new job well before the previous job
has finished, so there may be three or four jobs that are in the processing
(printing) state.  The printer cannot mark these jobs as completed when the
last page of the job is started, because the printer might fail before the
job actually emerges.

The printer might just ignore the RIP process for IPP and only transit the
job to "processing" when it is actually being printed, but MOD 4.3.7 line
3119 states that a job being RIPped is in the "processing" state. 4.3.8 line
3265 states the "job-state-reason" may be "job-interpreting" or
"job-transforming"  When a job has been completely RIPped, but is waiting to
be printed, the diagram on line 3180 indicates that its state should be
"processing-stopped" and that it will transit to "processing" when it is
printed.  It is likely that there will be quite a number of jobs in this
state, but there is no "job-state-reason" available.  It is also possible
for the operator or user to hold the job after it has been RIPped, so there
will be a transition between "pending-held" and "processing-stopped"

MOD 3.2.7 states that when a printer is paused, it must prevent jobs from
entering the "processing" state.  That implies that the pause-printer
operation also stops the RIP processor, which might not be the intention.
This is an optional operation however, so a high end printer can avoid the
issue by not implementing it.

If we ignore these issues, each implementer of an IPP server for these
machine is likely to bend the rules in different ways.

Perhaps the simplest way to resolve these issues is to use the "processing"
state for physical printing only and to introduce a new optional job
attribute "job-rip-state" or "job-transform-state" with as value the enum
from "job-state"  The printer would then need an attribute to indicate
whether it is RIPping or not, irrespective of the print unit status.

Regards
Anthony Porter

-------------- next part --------------
A non-text attachment was scrubbed...
Name: Anthony Porter.vcf
Type: application/octet-stream
Size: 723 bytes
Desc: not available
Url : http://www.pwg.org/archives/ipp/attachments/19990324/3c25a787/AnthonyPorter-0001.obj


More information about the Ipp mailing list