WO1983003487A1 - Page printing system - Google Patents

Abstract

A page printing system in which high level encoded page layout information is processed to form a printed page. An image processor (3) operates to form page image data, at a variable rate, during a processing time. A window buffer (16-2) is filled at the rate at which the image processor processes (3) the page layout information. The rate at which the window buffer (16-2) is emptied, to supply page image data to a printing device (4), is determined by the rate of printing of the printing device (4). The printer (4), operating at a preestablished printing rate, prints the printed page during a printing time. The variable rate of the image processor (3) is determined such that the duration of the processing time does not exceed the duration of the printing time.

Description

PAGE PRINTING SYSTEM

BACKGROUND OF THE INVENTION

The present invention relates to the field of page printing systems, and specifically to image processors for page printing systems.

This invention was made with Government support under Grant MCS77-23738 awarded by the National Science Foundation. The Government has certain rights in this invention.

Page printing systems are well-known and utilize many different types of printers. For example, electrically actuated mechanical print wheels, xerographic drums, and laser printers are all commonly used to form page printing systems.

In page printing systems, a printed page is formed by printing discrete picture elements (pixels) at fixed physical locations on an output medium such as paper. The picture elements have different intensities or color such as black and white. When the printing device is a matrix printer, the printed page is defined by a matrix of small locations which register either a black or white pixel. In a typical laser printer, each pixel is a square measuring 1/240 inch on a side. Each pixel is much smaller than the smallest character or

^ J- other shape to be printed, and therefore, each character or shape is formed by a number of pixels.

The printer operates by scanning the output media along one of its two axes at a constant speed. The paper moves parallel to a direction P called the "pageward" direction. The laser beam scans in a direction S called the "scanward" direction. The scanward direction is orthogonal to the pageward direction. The laser beam is turned on and off at each pixel location thereby forming either black or white pixels as the laser beam scans across the page. A full line in the scanward direction is called a scanline. A full page of scanlines results in the printed page.

In order for a printed page to be formed by the printer, data for turning the laser beam on or off is supplied to the printer.

The data which represents the -printed page and which is supplied to the printer is stored in a computer memory and is called a "page image" or page image data. The page image is stored in the memory locations of a computer or other storage device. In an example where pixels are black or white, one bit (representing a pixel) can be stored in one memory cell. Each bit of the digital representation which constitutes a page image must have a correspondence to a pixel in the printed page both as to pixel intensity (black or white) and location.

In one example, the printed page is represented as a sequence of 2640 vectors, each vector composed of 2040 pixels. Correspondingly, the page image can be stored

-£TjREX£-

OMPI in 2640 memory sections with each section having 2040 cells. Each memory cell stores one bit of information with the value "0" denoting a white pixel and the value "1" denoting a black pixel. Each memory section corresponds to one scanline (vector) of the printed page and hence there is a one for one bit to pixel map from bits in the memory cells of memory to pixels on a printed page.

An alternative representation for a page image is achieved by using run-length encoding of sequences of pixels of the same intensity. In run-length encoding, scanlines are represented as sequences, each sequence being defined of the form (length) (color) , where length denotes the number of bits or pixels and "color" is either " " for white, or "B" for black. There are many other types of digital encoded representations which can be used to represent page. images. Although there is a correlation between the page image data stored in memory and the pixels of a printed page, that correlation is not required to be a one for one bit to pixel map.

The page image data itself is usually decoded from a "page layout". A "page layout" is a high-level encoded representation of an entire printed page. A page layout is encoded using a page layout language. The page layout language employs a library or table of basic shapes called "glyphs". Glyphs include letters, numbers, symbols and characters or shapes of all types and sizes. Additionally, the page layout language encompasses instructions which define where glyphs are to be located on a printed page. A page layout expressed in a page layout language is decoded to form page image data which correlates pixels to locations on a printed page.

An image processor is a device which accepts the high-level encoded page layout data stored in digital form and process the page layout to form decoded page image data, also in digital form. The page image data is then transmitted to the printer to cause the printer to form the printed page.

Image processors for high-speed printers are faced with a number of limitations. High-speed printers normally perform their printing function at a uniform rate. In prior art devices, image processors have processed the encoded page layout data to generate the decoded page image data at a rate which can match the constant data rate required by the printer. If the image processor is too slow in generating the page image data, then an incorrect page will be printed since the printers normally do not permit the stopping of the printing of a page at any point between the beginning and the end.

Prior art image processors have been designed for uniform rate printers. One type of prior art image processor requires that the page image for the entire printed page be processed and stored in a full-page buffer before the printing operation commences. In such a full-page buffer system, there is no problem ensuring that the page image will be available when the page image information is required by the printer. Such full-page buffer systems do have the problem of greater hardware cost and complexity. Additionally, such full-page buffer systems have an inter-page delay problem when multiple printed pages are to be printed in rapid succession. The inter-page delay results from

^' the delay required to ensure that the page image is fully formed prior to starting the printing operation. The inter-page delay causes the overall printing speed for many printed pages to be greatly reduced. Accordingly, it is desirable to avoid the inter-page delay for high-speed printing.

In order to increase the speed of processing, other prior art image processors have employed alternating buffers. The page layout information is processed to fill one buffer with digital representations constituting a first part of the page image. After the first buffer is filled with a part of the page image, that first buffer is emptied to the printer for printing the printed page. While the first buffer is being emptied to the printer, the second buffer is being filled by processing of the page layout to form the next portion of a page image. After the first buffer is emptied and the second buffer is filled, the roles of the two buffers are exchanged. The second buffer is emptied to the printer while the first buffer is again filled. The process continues of alternately filling and emptying the buffers. In this manner, the inter-page delay is avoided or reduced provided the buffer fill rate equals the buffer empty rate.

Prior art systems which have equal buffer-fill and buffer-empty rates face the processing problem presented by "locally" complex page layouts. If the buffer-fill rate is not fast enough to process locally complex page layouts at any time during the processing, the page image data will not be available at the time it is needed by the printer. While the alternating buffer system effectively, under some circumstances, eliminates the inter-page delay, it often is not effective for complex processing where high local complexity is present.

A processing time problem frequently arises in the prior art when the page layout has a complexity which requires a great deal of processing time to form some part of the page image. Complexity typically arises in a situation where a large number of glyphs are to be located in a relatively small area of the printed page. When many instructions (steps in the layout language) are required to be executed in order to form some local portion of a page image, then the image processor may produce the page image at a rate slower than the rate at which the printer prints. In prior art devices of the type described, the slower rate results in an error in the printed page.

The prior art devices have not been successful in solving both the inter-page delay problem and the local complexity problem and which provides an improved and economical page printing system.

In view of the above background, it is an objective of the present invention to provide an improved image processor and printing system which reduces both the inter-page delay problem and the local complexity error problem.

SUMMARY OF THE INVENTION

The present invention is a page printing system in which highly-encoded page layout information is processed to form a printed page. An image processor processes the page layout information to form decoded page image data. The image processor operates to form

* E ff the page image data, at a variable rate, during a processing time. A printer operating at a preestablished printing rate prints the printed page, during a printing time. The printer forms a scanned array of variable intensity pixels in response to the page image data. The variable rate of the image processor is determined such that the duration of the processing time does not exceed the duration of the printing time. A printer interface connects the image processor to the printer so that the page image data determines the intensity (black or white) of the printed pixels which form the printed page.

The image processor generates the decoded page image data and stores the data in a dynamic window buffer. The rate of filling the window buffer is a function of the rate at which the image processor processes the page layout information. The rate at which the window buffer is emptied, to supply page image data to the printing device, is determined by the rate of printing of the printing device. Accordingly, the rate at which the dynamic window buffer is filled is variable and different from the rate at which the buffer is emptied.

The rate of filling the dynamic window buffer at times can be less than the rate at which the dynamic window buffer is emptied; provided that, at other times the rate at which the dynamic window buffer is filled is greater than the rate at which it is emptied. The only . requirement is that the printing duration, occurring to empty the buffer, cannot exceed the processing duration, occurring to fill the buffer, for any period of time which will cause the window buffer to be empty and the printer to be without information to print.

O PI In general, the capacity of the dynamic window buffer is less than the capacity required for a full printed page. Accordingly, the dynamic window buffer scrolls through the page image, in the pageward direction, so that the page image data stored in memory cells at any given point in time is less than the amount of data required for a full printed page. Because the window buffer size can be made small, the image processor of the present invention is economical.

The present invention is able to process page layouts which are locally complex and which require long processing times. At times during the processing, the local complexity slows down the rate at which the page image data fills the dynamic window buffer. At times, the slower rate may be less than the rate at which the printer forms the printed page, provided that, at other times, the image processor can fill the dynamic window buffer at a compensatingly greater rate than the rate at which the printed page is formed.

The size of the dynamic window buffer is selected to accommodate the maximum local complexity of the page layout. Typically, the number of scanlines in the window buffer is greater than four times the maximum character height to be processed.

The greater the local complexity, the larger the size of the dynamic window buffer required. Generally, the dynamic buffer window size is measured in terms of the number of scanlines of data that may be stored. For a typical printed page with a laser printer scanned by 2640 lines, a typical dynamic buffer size is 64 scanlines. With a dynamic window buffer of this size, up to 64 scanlines are processed and stored in the

f OMPI window buffer at any one time. The window buffer is emptied on a first-in, first-out basis. If the window buffer is emptied at a rate which is greater than the rate at which the window buffer is being filled, fewer than 64 scanlines of data will be available in the buffer.

The fullness of the buffer is indicated by a top scanline . indicator (Paint Top) which indicates the current scanline being filled. The top scanline of the window buffer (Window Top) and the bottom scanline (Window Bottom) are recorded and changed as processing progresses. The difference between Window Top and Paint Top within the window buffer is the number of scanlines occupied with data to be transferred to the printer. If the Window Top equals the Paint Top before the printed page is printed, . then an error in the printed page will have occurred since the image processor fill rate has failed to keep up with the printer print rate. The size of the dynamic window buffer is selected so as to avoid situations where the window buffer is emptied of valid data before the complete page image is printed.

It is apparent from the above summary that the present invention achieves the objective of providing an economical page printing system and an improved page printing system which greatly facilitates the handling of local complexity in the generation of page images and the printing of printed pages.

Additional objects and features of the present invention will appear from the following description in which the preferred embodiments of the invention have

OMPI been set forth in detail in conjunction with the drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

Fig. 1 depicts an overall block diagram of a page printing system including an image processor and a printer.

Fig. 2 depicts a printed page field which is printed by the printer of the Fig. 1 system.

Fig. 3 is a block diagram representation of the image generator within the image processor of the Fig. 1 system.

Fig. 4 is an electrical schematic representation of the printer interface which forms part of the image processor of Fig. 2.

Fig. 5 is a representation of an expanded view of a portion of the printed page of Fig. 2.

DETAILED DESCRIPTION

General - Figs. 1, 2, 5

In Fig. 1, a host computer ? connects to an image processor 3 which in turn connects to a printing device 4. The host computer 2 specifies a page to be printed using an encoded page layout. The image processor 3 receives the page layout information over the bus 5 and processes the page layout to form a page image which is digitally stored by the image processor. The image processor 3 provides over the bus 6 page image data

OMPI which is received by the printing device 4 and which is used to print the printed page.

The. printing device 4 is typically any well-known laser printer. Such a device will move a sheet of paper, for example, of standard size such as 8.5 x 11 inches, along a pageward axis while scanning a laser beam orthogonally thereto along a scanward axis. The P and

S axes are indicated in Fig. 1 for a sheet of paper 10.

The paper will typically be advanced in the pageward direction at the rate of 565 scanlines per second.

Also, the laser will scan along the scanward axis with a scanward rate of 1.84 x 10 pixels per second. The laser printer will typically have a retrace time between the end of one scanline and the beginning of

-3 the next one of 0.66 x 10 seconds.

The bus 6 normally receives information serially by bit in the form of a stream of digital l's and 0's. For the typical laser printer described above, the bit rate on the bus 6, once a scanline starts, must provide a new bit every 544 x 10 — 9 second. The printer will

-3 start a new scanline every 1.77 x 10 second. A laser printer, which has these typical characteristics is manufactured and sold by Canon, model LBP-10.

In Fig. 2, a printed page field 11 of the same size as the paper 10 in the printing device 4 of Fig. 1 is shown. As indicated in Fig. 2, the printed page 11 is represented by 2640 scanlines 0, 1, ...» 2639 along the P-axis direction. Similarly, each scanline of the printed page 11 is represented by 2040 pixels designated by the pixel locations 0, 1, 2, ..., 2039 in the S-axis direction. Accordingly, the entire printed page 11 is represented by 5.3856 x 10 pixels. Each

OMPI pixel is either white or black depending upon the page image data supplied by the image processor 3 of Fig..1.

In Fig. 2, the printed page 11 consists entirely^* of white pixels except within region 12. The region 12 is located with its upper left-most corner commencing at the 1,000th pixel location in the S-axis ^'direction and at the 500th scanline location in the P-axis direction of the printed page 11.

Further details of the printed page region 1? are shown in Fig. 5. In Fig. 5, the upper left-hand corner along the P-axis starts with the scanline 500. Only a portion of scanline 500 is shown in the S-axis direction running from pixel 1,000 through pixel 1023. In Fig. 5, the printed page portion 12 includes three glyphs including "H" 63, "i" 64 which are two normal alphabet characters. Additionally within the region 12, underscore graphic representation " " is designated glyph 65.

The printed page of Fig. 2, including the printed page portion 12 of Fig. 5, is specified by the host computer 2, or any other convenient device, using a page layout language. The page layout language is encoded and is transferred to the image processor 3 of Fig. 1. The image processor of Fig. 1 functions to process the encoded page layout information to form page image data. The page image data, from the image processor 3 of Fig. 1, is transferred, a bit at a time, to the printer 4 of Fig. 1 to cause the printer to print the printed page of Fig. 2 including the printed page portion 12 of Fig. 5. As a result of the printing process, all of the area within the glyphs 63, 64 and 65, will be black pixels while all of the rest of the area in Fig. 5 and Fig, 2 will be white pixels.

In Fig. 5, the glyph 63, the character "H", is 15 scanlines high as measured in the P-axis direction and 9 pixels wide as measured in the S-axis direction. Since, in the example being described, each pixel is 1/240 inch, the glyph 63 in Fig. 5 has a dimension of 0.0625 inch high by 0.0375 inch wide. This size is roughly the size of characters from standard typewriters or printers.

In Fig. 1, the image processor 3 is comprised of an image generator 7 and a printer interface 8. The image generator 7 connects to the host computer 2 by means of the bus 5 and connects to the printer interface 8 via a bus 9. For convenience, bus '9 is defined to be the well known Multibus commonly used for interconnecting microprocessors. The printer interface 8 in turn connects via the bus 6 to the printer 4.

The image processor 3 of Fig. 1 processes the high-level encoded page layout information from the host computer 2 in a process which is called "painting." The painting forms and stores the page image data which is in turn transferred over the Multibus 9 to the printer interface 8 a scanline at a time. The printer' interface 8 transfers the data from the interface over the bus 6 a bit at a time to the printer 4. The transfer rate over the bus 6 must be at a rate which matches the rate of operation of the printer 4. The printer 4 requires a constant rate of data on the bus 6 since the paper 10, once printing has

OMPI started, is moved at a constant rate. If data is not available on bus 6 at a rate which matches the required rate of printer 4, an error in printing will occur. -

While the output rate from the printer interface over bus 6 is fixed, the rate at which the painting process in image generator 7 occurs is asynchronous with respect to the rate at which data is transferred out over bus 6. Accordingly, the image generator 7 is capable of painting at a high rate when the page layout from the host computer 2 is not complex. In a similar manner, the image generator 7 paints at a slow rate whenever the page layout is complex. The image generator 7 therefore can average the slow painting rates and the fast painting rates provided that the overall average painting process does not leave the printer interface without valid page image data to be transferred over the bus 6 when required by the printer 4.

Image Generator - Fig. 3

In Fig. 3, the image generator 7, which is part of the image processor 3 of Fig. 1, is shown in greater detail. The image generator 7 includes any well-known processor 15. In one typical example, processor 15 is a Motorola 68000. Processor 15 connects to a memory 16 via an internal bus 17. Processor 15 and bus 17 also connect to a universal asynchronous receiver/. transmitter (UART) 14. The UART 14 connects bus 17 to the bus 5 for communication between the image generator 7 and the host computer 2 of Fig. 1.

The processor 15 also connects to an interface 18 which in turn connects to the Multibus 9. The interface 18 is a standard device for connecting the bus 9 to processors, such as processor 15. The interface^" 18 also connects to the internal bus 17 for communication between bus 17 and the bus 9.

In Fig. 3, the processor 15 is associated with a conventional random access memory 16. Memory 16 includes a page layout buffer 16-1, a dynamic window buffer 16-2, a glyph table 16-3, a program section 16-4 and a utility section 16-5. The sizes of these different sections of memory are selected to ensure that they have adequate room for the various tables and information which they store as will be apparent from the description which follows. In the example described, a 128K word memory, organized in 16-bit words, is adequate.

In operation, the image generator 7 is downloaded with information from the host computer 2. While down- r loading is a convenient way of loading the information into the memory 16, the memory 16 can be loaded in any conventional way and does not require the use of a host computer. For example, the information can be keyed in from a keyboard, transferred from a word processor, or obtained from any other convenient source.

Page layout information is loaded into the page layout buffer, memory section 16-2. A glyph table is loaded into the memory section 16-3. The glyph table defines a mask for each of the characters that can be painted by the image generator. Control programs and other routines are loaded into the memory section 16-4. The memory section 16-5 is for any ordinary utility functions which are used by processor 15. In Fig. 3, the dynamic window buffer, memory section 16-2, is the section of memory 16 in which the results of the painting operation are stored. In the present example, section 16-2 stores 64 scanlines of page image data with 128 16-bit words per scanline in approx¬ imately 8K words of memory.

The operation of the image generator 7 after being downloaded from the host computer 2, is to fetch the page layout commands from the buffer 16-1 process the commands to form and to store the page image data within the dynamic window buffer 16-2.

During the processing, references to character glyphs in the page layout commands causes a table look-up to access a character mask from the glyph table of section 16-3. The mask for the glyph from table 16-3 is overlaid at the appropriate location in the dynamic window buffer 16-2 under the control of the processor 15. Accordingly, the "painting" process occurs when the dynamic window buffer 16-2 is loaded by the decoding and processing of page layout information from the layout buffer 16-1. The dynamic window buffer 16-2 is emptied under control of the processor 15 through the interface 18 to the bus 9. From the bus 9, the page image data is loaded into the printer interface of Fig. 4.

Printer Interface - Fig. 4

In Fig. 4, the printer interface 8 of Fig. 1 is shown in further detail. The printer interface 8 is connected to the bus 9 from the image generator of Fig. 3. In Fig. 4, the bus 9 is shown in further detail to include the control lines 48, the 16-bit MDATA bus 49, and the 20-bit MADDR bus 50.

The printer interface of Fig. 4 accepts the page image data, on data bus 49, and stores it in the scanline buffer 21 through a receiver 47 and a data register 20. The data in the scanline buffer 21 represents the portion of the page image data required to specify a full scanline of pixels (2040 pixels) for a printed page as indicated, for example, in the printed page of Fig. 2. The page image data from the buffer 21 is selected by the multiplexer 22 to be transferred a bit at a time through the flip-flop 23 and the driver 24 to the video control lines (IVID) 28. Lines 28 connect as a part of the bus 6 to the printer 4. The "1" or "0" bit on the lines 28 determines the black or white, respectively, pixel which is printed by the printer 4.

In Fig. 4, the MDATA(00-15) bus 49 connects to the receiver (RCVR) 47. Receiver 47 is a standard device which is energized to connect the bus 49, when enabled by the control line IMASEL, to the 16-bit bus 61. The 16-bit bus 61 is connected as an input to the 16-bit data register 20. The data on bus 61 is stored in register 20 under control of the LOAD DATA signal on line 58 from the address decoder 52. The bus 61 has its 11 lowest-order bits connected to the address counter 32 which is loaded under control of the LOAD ADR signal on line 57 from the address decoder 52. The four lowest-order bits of address are loaded into the. pixel counter (PIXCTR) 35 and the seven higher-order address bits are loaded into the WORD counter (CTR) 33.

In a similar manner, control information is loaded from the bus 49 into the control register 54 under control of the WRCTRL signal on line 56 from the address decoder 52. The control register 54, includes the register location for the IPRINT signal which, when set to 1, commands the printer of Fig. 1 to commence, a printing operation. The IPRINT signal is connected to the printer of Fig. 1 on line 70 which is part of the bus 6 in Fig. 1.

The status information from the status register (STAT REG) 53 is gated onto the MDATA bus 49 under control of the READ STAT signal on line 55 from the address decoder 52. The status register 53 records the ITOP and the IPRINT END signals received on lines 71 of bus 6 from the printer 4 of Fig. 1.

The decoding of the signals by decoder 52 is under control of a device decoder 59. The device decoder 59 decodes logical "l's" for the M(16-19) bits from the address bus 50 to enable the output line 51. When line 51 is enabled to energize the IMASEL signal, the address decoder 52 accepts the bits M(0,1) from the bus 50 and decodes them to enable one of the lines 55, 56, 57 or 58. At the same time, the receiver 47 is enabled to transfer any of the information on bus 49 through to the bus 61.

In Fig. 4, the address counter 32 includes the word counter 33 and the pixel counter 35. The word counter 33 addresses through its 7-bit output X(04-10) any one of 128 words stored in the scanline buffer 21. Buffer 21 is, in the particular example being described, a random access memory of 128 x 16 bits. The buffer 21 has the 16-bit word from the data register 20 loaded into the buffer 21 at the address specified by the word counter 33 whenever the LOAD DATA line 58 from the address decoder 52 is enabled. When the LOAD DATA line 58 is not enabled, then the data at the word location specified by the word counter 33 appears output from the buffer 21 on bus 25 as an input to the multiplexer 22. The multiplexer 22 performs a 16 to one demultiplexing of the word output from the buffer 21 under control of the 4-bit output from the pixel counter 35. The signal output (BUF OUT) on line 26 from the multiplexer 22 connects as the D input to the flip-flop 23. The 1 or 0 data value of the BUF OUT line 26 is clocked into the flip flop '23 by the BIT CLK signal on line 43. The data value stored in flip flop 23 connects from the Q output on line 27 (VID LAT) as an input to the driver 24. The driver 24 converts the single signal line VID LAT to the dual-line 28 signal I VID. The I VID signal turns the laser beam on for a black pixel or off for a white pixel during the printing operation hereinafter described.

In Fig. 4, the address counter 32 is counted by the BIT CLK signal on iine 43 from the divide-by-10- circuit 36. The divide-by-10 circuit 36 divides the clock signal from the 18.43 MHz clock 37 to provide the BIT CLK signal at a 1.843 MHz frequency. The BIT CLK on line 43 only appears when the circuit 36 is enabled

O PI by the VID GO signal on line 42 which is output from the D-type flip flop 38. The flip flop 38 has a "1" clocked to its Q-output by the START LINE signal on line 40 from the receiver- 39. The D input to the flip flop 38 is wired to a logical "1". The receiver 39 receives the dual-line 40 IBD signal from the printer 4 of Fig. 1 to signal that the printer requires the data to be sent for a scanline. When that signal is received in receiver 39, the START LINE clocks the flip-flop 38 which in turn enables the VID GO signal on line 42 causing the BIT CLK signal to be generated on line 43 to start the address counter 32 counting. Prior to this time, the address counter 32 has been loaded with all zeros so the address counter, in the present embodiment, always starts at the zero address and counts 2048 counts representing each of the pixels in a scanline. The pixels are stored in buffer 21 in 128 words, 16-bits per word, where each bit represents one pixel. The 16-bits (pixels) represented by each word are addressed in order one at a time by the stepping of the pixel counter 35 from its all zero condition through 16 counts which cause a carry-out on line 44. The carry-out on line 44, through the OR gate 34, counts the word counter 33 to the next word count. As the counter 35 steps through its 16 counts by the BIT CLK signal on line 43, the multiplexer 42 selects the 16-bits output from the buffer 21 one at a time in the manner previously described.

Each time the word counter steps to a new word, by the operation of OR gate 34, the pixel counter 35 is again counted through all 16 counts in the word. The counting of the pixel counter 35 and the incrementing of the word counter 33 continues until the word counter 33 reaches the maximum count, 128. After

OMTI the maximum count is reached, a carry output (MAX CT) appears on line 31. The MAX CT signal on line^"31 clocks the flip-flop 45. Flip-flop 45 has a logical

"1" connected on its D input. Accordingly, the MAX CT signal is clocked to provide a "1" on the Q output on flip-flop 45 to energize the LINE DONE signal on line 46. The LINE DONE signal resets the flip-flop 38, disabling the VID GO signal and preventing any further

BIT CLK clock signals on line 43. The LINE DONE signal is also transferred on control line 48 to the

Multibus 9. The purpose of the LINE DONE signal on the control line 48 is to signal the image generator of

Fig. 3 that another scanline of data from the dynamic window buffer 16-2 can be transferred over the

Multibus 9 to the scanline buffer 21 in preparation for the next scanline of data which is to be printed by the printer 4 of Fig. 1.

In Fig. 4, after the new scanline data is loaded into buffer 21 in the manner previously described, the scanline data is transferred through multiplexer 22 flip-flop 23 and driver 24 to repeat the process for the next scanline in the same manner as described in the previous scanline. This process continues until the whole printed page has been printed.

DETAILED OPERATION

In order to describe the operation of the page printing system of Fig. 1, the detailed processing for the printing of the portion of the printed page of Fig. 5 will be described in detail. The glyphs of Fig. 5 and their location within the final printed page, as shown in Fig. 2, are specified in terms of a high-level page and layout language. A typical example of the page layout language is shown in the following TABLE 1.

OMPI TABLE 1 - PAGE LAYOUT LANGUAGE

COMMAND .

CLASS FORMAT

Word-0 Word-1 Word-2 Word-3 Word-4

TEXT CHAR=1 P-pos S-pos CHAR-ID

GRAPHIC RULE=2 P-pos S-pos Height Width

CONTROL END=3

where: CHAR-ID = [Font number, ASCII code for character]

P-pos = scanline location in the pageward direction between 0 and 2639

S-pos = pixel location in scanward direc¬ tion between 0 and 2039

Height = dimension in scanlines in the pageward direction

Width = dimension in pixels in the scan¬ ward direction

In TABLE 1, commands of three different classes are shown, namely, TEXT, -GRAPHIC and CONTROL. Each command comprises up to 5, 16-bit words of data denominated as Word-0, Word-1, . . . Word-4. The contents for each of the words within a command are specified in the columns under FORMAT in TABLE 1. The command CHAR (identified- by a Word-0 equal to 1) is a typical example of TEXT commands. Similarly RULE (with Word-0 equal to 2 ) belongs in the GRAPHIC command class. The command END (with Word-0 equal to 3) is a CONTROL command. For both the CHAR and RULE commands, the Word-1 stores a

JURE J5 OMPI 16-bit primary designation, P-pos, which represents the P-axis starting position of the glyph. For both CHAR and RULE commands, Word-2 stores a 16-bit representation, S-pos, of the S-axis starting position of the glyph. For the CHAR command, Word-3 stores a character identification code, CHAR ID, which in a preferred embodiment is a standard ASCII code.

For a RULE command, the Word-3 stores a Height representation which is a 16-bit representation of the height of the graphic glyph, and Word-4 stores a 16-bit representation Width, which designates the width of the graphic glyph.

In TABLE 1, the CHAR ID can also include a font number in addition to the ASCII code. In the present example, however, only a single font is employed and therefore the font number can be ignored.

Using the page layout language of TABLE 1, the representation of Fig. 5 is specified. The page layout data is down loaded from the host computer 2 into the page layout buffer 16-1 of Fig. 3. The page layout buffer 16-1 in Fig. 3 includes two portions, an unsorted page layout buffer and a sorted page layout buffer. The starting address of the unsorted page layout buffer is given as UB and the starting address of the sorted page layout buffer is given as SB. The unsorted page layout for the Fig. 5 representation appears in the following- TABLE 2. TABLE 2 - UNSORTED PAGE LAYOUT BUFFER

UNSORTED

BUFFER DATA ADDRESS WORD (HEX) COMMENT

UB+0 0 0001 Text command, CHAR = 1 ϋB+1 1 01F7 Pageward starting position

503

UB+2 2 03EB Scanward starting position

1003

UB+3 3 0048 Font type = 0; ASCII code for "H"

UB+4 0 0002 Graphic command, RULE = 2 UB+5 1 020C Pageward starting position

524

UB+6 2 03EA Scanward starting position

. 1002

UB+7 3 0003 Height = 3 scanlines

UB+8 4 0012 Width = 18 pixels

UB+9 0 0001 Text command, CHAR = 1

UB+A 1 01F8 Pageward starting position

504

UB+B 2 03F6 Scanward starting position

1014

UB+C 3 0069 Font type = 0; ASCII code for "i"

UB+D 0003 Control command End = 3

where: UB = Starting address of Unsorted Page Layout Buffer in image generator memory.

In TABLE 2, the addresses and data are indicated in hexadecimal notations. The page layout buffer of TABLE 2 includes four commands, two CHAR commands commencing at the address UB+0 and UB+9. The table includes a RULE command beginning at address UB+4 and an END command beginning at UB+D.

The Word-0 location at address ϋB+0 specifies that it is a character. The Word-3 location at address UB+3 specifies the ASCII code for "H". Referring to Fig. 5, that "H" has its starting position, the upper left-hand most corner at scanline 503 and with pixel address 1003. These values appear in the address locations UB+1 and UB+2 of TABLE 2. Accordingly, the first four addresses in the unsorted page layout buffer, that is addresses UB+0 through UB+3, specifies that the character "H" is to be painted starting at the location in the P-axis 503 and in the S-axis 1003.

In a similar manner, the next five word addresses, namely, UB+4 through UB+8, specify that a RULE command for the glyph 65 of Fig. 5 is present. The glyph 65 is to start at the P-axis scanline 524 and at the S-axis pixel address 1002. The height of the glyph is to be 3 scanlines and the width in the S-axis direction is to be 18 pixels.

The next four words in the unsorted page layout buffer of TABLE 2, that is addresses UB+9 through UB+C, specifies that the character "I" is to be printed starting with the upper left-most corner at scanline 504 at the pixel location 1014. It should be noted that the pixel in scanline 504 which is at pixel address 1014 is a white pixel and that the first black pixel is at 1015. In TABLE 2, at the address UB+D, and END command indicates that it is the end of the page layout data for the page to be printed.

It is apparent from examining TABLE 2 that the examination of Word-1 for each of the glyphs has the glyphs organized in the order of the "H" at the P-axis scanline 503, followed by the glyph 65 at the P-axis scanline 524, followed by the glyph "I" at the P-axis scanline 504. The glyphs, therefore, are not in the order of their upper-most location on the printed page.

In order to organize the unsorted page layout information with the glyphs of the upper left-most (from lowest to highest number P-axis ordering) , the unsorted page layout data of TABLE 2 is sorted, using a standard sorting routine based on the contents of Word-1, for each of the glyphs in the unsorted buffer. The results of that sorting appears as the sorted page layout data and is shown in the following TABLE 3.

TABLE 3 - SORTED PAGE LAYOUT BUFFER

SORTED

BUFFER

ADDRESS DATA

(SBA) WORD (HEX) COMMAND

SB+0 0 0001 CHAR

SB+1 1 01F7

SB+2 2 03EB

SB+3 3 0048

SB+4 0 0001 CHAR

SB+5 1 01F8 ^*

SB+6 2 03F6

SB+7 3 0069

SB+8 0 0002 RULE

SB+9 1 020C

SB+A 2 03EA

SB+B 3 ^■ 0003

SB+C 4 0012

SB+D 0003 END

where: SB = Starting address of Sorted Page Layout Buffer in image generator memory

The starting address of the sorted page layout buffer is SB. With this reordering, the sorted page layout buffer is ready to be used by the processor 15 Fig. 3 to paint the page image into the dynamic window buffer 16-2. The sorted page buffer of TABLE 3 is accessed in the order of SB+0 to the end at SB+D. During the processing of the CHAR commands on TABLE 3, the details concerning each character must be obtained from a library called a glyph table. In order to be able to address the glyph, however, the glyph starting address must be accessed from a glyph address pointer table. The glyph address pointer table is shown in the following TABLE 4.

TABLE 4 - GLYPH ADDRESS POINTER TABLE

ADDRESS GLYPH TABLE^' POINTER CHAR ADDRESS

GA + 48 (HEX) -H' Kl GA + 69 (HEX) II J It K2

Where: GA is starting address of GLYPH

ADDRESS POINTER TABLE in image gener¬ ator memory.

In TABLE 4, a pointer address for addressing the pointer table is the ASCII code specified in the CHAR ID from Word-3 of the CHAR command. That code (48 (HEX) in the case of the character "H" and 69 (HEX) for "i") is added to the starting address, GA of the glyph address pointer table and the contents of the resulting address yields the desired glyph address.

As shown in TABLE 4, the glyph starting address for the character "H" is Kl. Similarly, the starting address for the character "i" is the address K2. Whenever the character is to be painted, such as for the characters "H" and "i" in Fig. 5, then the starting address for those characters is obtained from the TABLE 4 pointer table. After the starting address has been obtained, the proper addressing of the glyph table can be made. The glyph table entries for the characters ^HH" and "i" are shown in the following TABLE 5. TABLE 5 - GLYPH TABLE

ADDRESS DATA

(HEX) (HEX) COMMENT

Kl + 00 OOOF Height = 15 scanlines

Kl + 01 0009 Width = 9 pixels

Kl + 02 E380 1st scanline of "H"

Kl + 03 E380 2nd scanline of "H"

Kl + 04 E380 3rd scanline of "H"

Kl + 05 E380 4th scanline of "H"

Kl + 06 E380 5th scanline of "H"

Kl + 07 FF80 6th scanline of "H"

Kl + 08 FF80 7th scanline of "H"

Kl + 09 FF80 8th scanline of "H"

Kl + 0A FF80 9th scanline of "H"

Kl + OB E380 10th scanline of "H"

Kl + OC E3.80 11th scanline of "H"

Kl + OD E380 12th scanline of "H"

Kl + OE E380 13th scanline of "H"

Kl + OF E380 14th scanline of "H"

Kl + 10 E380 15th scanline of "H"

K2 + 0 000E Height = 14 scanlines

K2 + 1 0004 Width = 4 pixels

K2 + 2 7000 1st scanline of "i"

K2 + 3 7000 2nd scanline of "i"

K2 + 4 7000 3rd scanline of "i"

K2 + 5 0000 4th scanline of "i"

K2 + 6 0000 5th scanline of "i"

K2 + 7 7000 6th scanline of "i"

K2 + 8 7000 7th scanline of "i"

K2 + 9 7000 8th scanline of "i"

K2 + A 7000 9th scanline of "i"

K2 + B 7000 10th scanline of "i"

K2 + C 7000 11th scanline of "i"

K2 + D 7000 12th scanline of "i"

K2 + E 7000 13th scanline of "i"

K2 + F 7000 14th scanline of "i"

In TABLE 5, the first word for a glyph entry specifies its height, which for the "H" is 15 scanlines and for the "i" is 14 scanlines, The second word specifies the width, which for the "H" is 9 pixels and for the

OMPI 4 pixels .

Referring now to Fig. 5 we can compare the aspect of the sample characters with their entries in the glyph table. It is apparent that the height of the character "H" is 15 scanlines in that it extends from scanline 503 to scanline 517. Similarly, the height of the character "i" is 14 scanlines and it extends from scanline 504 to scanline 517.

The character "H" extends from pixel address 1003 to pixel address 1011. For the character "i", the black pixels extend from S-axis address 1015 through 1017. However, the CHAR command at address UB+9 in TABLE 2 specified the S-axis location 1014 so that the white pixel in scanline 504 and S-axis location 1014 together with the black pixels in S-axis locations 1015, 1016 and 1017 define the first hexadecimal digit for the character "i" (the character 0111 represents a hexadecimal 7) . All of the characters after 0111 for the character "i" are zeros so that the remainder of the hexadecimal representation for the first scanline for the character "i" is 000 and the full representation is 7000 as shown in TABLE 5.

In a similar manner, the starting address for the character "H" in Fig. 5 is the S-axis location 1003. The first four bits, from 1003 through 1006 are 1110 which correspond to a HEX E. Accordingly, E is the first HEX character in the first scanline of "H" of TABLE 5. The second digit for the first scanline of the character "H" from the S-axis addresses 1007 through 1010 is the binary 0011 which is a 3 HEX. The next four bits of the character "H" are 1000 running from the pixel S-axis address 1011 through 1014 is

O PI binary 1000 which converts to 8 "HEX. The final digit for the character "H" is binary 0000 which is 0 (HEX) . Accordingly, the data for the first scanline of "H" is E380 (HEX) as shown in TABLE 5. In a similar manner, all of the other data representations for each of the scanlines for each of the characters appear in the glyph table of TABLE 5.

In order to start processing the sorted page layout buffer data of TABLE 3, using the glyph table data of TABLE 5, a number of register or memory locations must be identified for storing certain values used in the process page routine which paints the page image into the dynamic window buffer of Fig. 3. The contents of the register or memory locations are specified in the following TABLE 6.

OMPI S'- WIPO ^~~ TABLE 6 - REGISTER CONTENT

MEMORY/ REGISTER CONTENT COMMENT

Rl PSB Pointer to current sorted buffer address

R2 Char-Id Character from CHAR command R3 S-pos Current scanward position from command

R4 Width Current scanward dimension from command

R5 Height Current pageward dimension from command

R6 Paint Top Current Window Buffer top scanline for painting

R7 Window Top Current top scanline for transfer Window Buffer (SB + 0)

R8 Window Bottom Current Window Buffer Bottom Scanline

R9 Window Width Number of pixels per scanline

RIO Window Height Maximum number of scanlines from Window Top to Window Bottom

Rll Start Printer Number of scanlines required

Delay in the Window Buffer before printer commanded to start

R12 Printer 1 = Started; 0 = Stopped

Started

R13 PGT Pointer to Glyph Table

R14 Window Word Number of words required to

Width store one scanline = [ (Window Width + 15) "div" 16]

R15 WPTR Pointer to window

OMPI TABLE 6 - REGISTER CONTENT (Cont'd)

MEMORY/ REGISTER CONTENT COMMENT

R16 PixVal Pixel Value register. Stores pixel value in its rightmost bit

R17 Pixel scanward position in page image

R18 Y Pixel pageward position in page image

R19 Top Reached 1: Paper Page Top reached 0: Otherwise

R20 SPTR Pointer within scanline to be transferred

R21 PM P-axis index

R22 SM S-axis index

The meaning of the various register contents set forth in TABLE 6 are apparent from the comment which appears in the right-hand column of the table.

With all of the information set forth above, properly loaded into the memory 16, a process page routine from the program section 16-4 of the memory 16 is ready to commence operating to paint the page image into the dynamic buffer which is section 16-2 of the memory 16. As indicated in TABLE 6, the dynamic window buffer is a section of random access memory, or other storage which stores a predetermined number of scanlines of data. That number is set forth as the Window Height, which is

-g5RE_ R10 in TABLE 6. In a typical example, the Window Height is equal to approximately four times the height of the largest character to be printed. In the present example, the Window Height is equal to 64. Similarly, the Window Width in the present example is set equal to 2040 pixels which can be stored in 128 16-bit words per scanline.

The above conditions are established during an initialize sequence in the process page routine hereinafter described. In addition to selecting a window size^*, the printer 4 of Fig. 1 requires that sufficient information be entered into the dynamic window buffer before the paper is started in order to ensure that the page image data will be available in sufficient time for printing pixels on the paper. In the particular example of the present invention, the number of scanlines required to be processed before the printer is commanded to start is 32.

The process page routine which is executed to paint the dynamic window buffer relies on a number of operations. Specifically, those operations are as follows:

Set (register) = (expression)

Wait (condition)

For (index) (from) (to)

If (condition) (then) (sequence) (else) (sequence)

Call (subroutine) Go to (statement number)

(load) (interface register)

In addition to the above operations, the expressions in the present example employ the following operators:

"MOD" = Modulo arithmetic

"DIV" implements integer division

"OR" = logical -"OR"

"AND" = logical "AND"

"LEFT SHIFT" = logical shift in zeros from right and dicard shift out on left

"RIGHT SHIFT" = logical shift in zeros on left and discard shift out on right.

Using the above parameters, the process page routine for painting the dynamic window buffer is set forth in the following TABLE 7.

TABLE 7 - PROCESS PAGE ROUTINE

Initialize Sequence

1.1 Window parameters

1.1.1 set (Window Width) = 2040

1.1.2 set (Window Word Width) =

I (Window Width + 15) div 16J

1.1.3 set (Window Height) = 64

1.2 Printer

1.2.1 set (Start Printer Delay) = 32

1.2.2 set (Printer Started) = 0

1.2.3 set (Top Reached) = 0

Clear Window Sequence

2.1 For all window buffer addresses PSB from

PSB = [ (Window Base) ] to PSB = [ (Window Base) +

(Window Height) (Window Word Width) ]

2.1.1 set (Word (PSB)) = 0

2.2 set (Window Top) = 0

2.3 set (Window Bottom) = [(Window Top) +

(Window Height) - 1]

Paint Loop Sequence

3.1 Initialize

3.1.1 set (PSB) = (SB)

3.1.2 set (Paint Top) = Word (SB+1)

3.1.3 go to 3.6

3.2 If [Word (PSB)] = (CHAR) , then

3.2.1 set (Paint Top) = Word (PSB + 1)

3.2.2 set (S-pos) = Word (PSB + 2)

3.2.3 set (Char-Id) = Word (PSB + 3)

3.2.4 Paint Character Subroutine (4)-

3.2.5 set (PSB) = (PSB + 4)

3.2.6 go to (3.5)

3.3 If [Word (PSB)] = (RULE), then

3.3.1 set (Paint Top) = Word (PSB + 1)

3.3.2 set (S-pos) = Word (PSB + 2) TABLE 7 - PROCESS PAGE ROUTINE (Cont'd)

3.3.3 set (Width) = Word (PSB + 4)

3.3.4 set (Height) =- Word (PSB + 3) Call Paint Rule Subroutine (5)

3.3.6 set (PSB) = (PSB + 5)

3.3.7 go to (3.5)

3.4 If [Word (PSB)] = (END), then go to

Terminate (6)

3.5 If (Printer Started) = 1 go to (3.2)

3.6 If [(Paint Top - Window Top) >

(Start Printer Delay) ]

3.6.1 load (CTRL REG, bit I PRINT) = 1

3.6.2 set (Printer Started) = 1

3.7 go to (3.2)

4. Paint Character Subroutine

4.1 set (PGT) [Word (GA + Char-Id)]

4.2 set (Height) = [Word (PGT)]

4.3 set (Width) = [Word (PGT + 1)]

4.4 wait [(Window Bottom) - (Paint Top)] >

(Height)

4.5 For every scanline address SM, from ^"(SM) = 0 to (SM = (Height - 1)

^•4.5.1 For every pixel address PM, from (PM) = 0 to (PM) = (Width - 1)

4.5.1.1 set (Y) = [(Paint Top) + (SM) ]

4.5.1.2 set (X) = [(S-pos) + (PM) ]

4.5.1.3 Call Fetch Mask Pixel (7)

4.5.1.4 Call Set Window Pixel (8) .6 Return

5. Paint Rule Subroutine.

5.1 wait [(Window Bottom) - (Paint Top)] >

(Height)

5.2 For every scanline address SM, from (SM) = 0 to (SM = (Height - 1)

- yi E it? TABLE 7 - PROCESS PAGE ROUTINE (Cont'd)

5.2.1 For every pixel address PM, from (PM) = 0 to (PM) - (Width - 1)

5.2.1.1 set (Y) = [(Paint Top) + (SM) ]

5.2.1.2 set (X) = [(S-pos) + (PM) J

5.2.1.3 set (PixVal) = 8000 (hex)

5.2.1.4 Call Set Window Pixel (8)

5.3 Return

6. Terminate

6.1 wait [(Window Top) > (Paper Height)]

6.2 set (Top Reached) = 0

6.3 PROCESS FINISHED

7. Fetch Mask Pixel Subroutine

7.1 set (WPTR) = [(PGT + 2 + SM ((Width + 15)

"div" 16) + (PM "div" 16) ) ]

7.2 set (PixVal) = [Word (WPTR) "left shift"

(PM "mod" 16) ] "and" 8000 (hex)

7.3 Return

8. Set Window Pixel Subroutine

8.1 set (WPTR) = [(Window Base) +

( (Y) "mod" (Window Height) ) (Window Word Width) + ((X) "div" 16)] .

8.2 set Word (WPTR) =

Word (WPTR) "or"

(PixVal "RIGHT SHIFT" (X "mod" 16))

8.3 Return

In TABLE 7, the first sequence is to initialize the various factors as previously described, the Window Width register is set to 2040 in 1.1.1. The Window

- X O PI Word Width register is set to 128 in 1.1.2. The Window Height is set to 64 in 1.1.3. The Start Printer Delay, the Printer Started, and the Top Reached registers are set to 32, 0 then 0, respectively.

With the above initial conditions, the clear window sequence is entered. The purpose of this sequence is to ensure that the contents of the dynamic window buffer are set to represent a blank portion of a page.

In the clear window sequence, the sequence 2.1 is to clear the window buffer by resetting all bits in all words to a logical "0" starting with the Window Base and extending through the entire dynamic buffer window. The Window Base is the starting address of the dynamic window buffer 16-2 in the memory 16 of Fig. 3. Every word within the window buffer is accessed and set to logical "0" in the step 2.1.1. In step 2.2, the Window Top register is set to "0".

In step 2.3, the Window Bottom register is set equal to the Window Height - 1, which is 64 - 1 or 63. Accordingly, at this point, the dynamic window buffer is the 64 scanlines which correspond to scanlines 0 through 63 in the P-axis direction of the printed page of Fig. 2.

Having established the dynamic buffer window, the paint loop sequence is entered and- the pointer to the current sorted buffer address, PSB, is set equal to the base address SB, starting address of the sorted page layout buffer. In 3.1.2, the Paint Top register is set to Word (SBH) which is the scanline index corresponding to the topmost character in the page which is 503. After this the Paint Loop Sequence is entered by jumping to 3.6.

In 3.6, the Paint Top was set to 503 in step 3.2.1 while the Window Top is still at 0 as set in step 2.2. Hence, the Paint Top is greater than or equal to the Start Printer Delay, which was set equal to 32 in step 1.2.1.

Once the printer has been thus started, the process jumps to 3.2.

Therefore, the CTL register 54 in Fig. 4 is set so that the IPRINT signal equals 1 and the Printer Started register in the image generator 7 of Fig. 3 is set equal to 1.

With these initializations, word (PSB) (this is the first entry of TABLE 3) , is examined to see if it is a character command, CHAR, which it is. The Paint Top register is set to word (PSB+1) , which is the data in SB+1.

In 3.2.2, the S-pos register is set to word (PSB + 2), which is the data from the address SB + 2 in TABLE 3. Similarly, the CHAR-ID register is set word (PSB+3) , which is at the address SB + 3 in TABLE 3.

In 3.2.4, the routine jumps to 4, the Paint Character Subroutine.

In 4.1, the pointer to the glyph table PGT is set equal to the address of the glyph entry for "H", which is Kl. In 4.2, the Height register is set to word (PGT), with PGT=Kl+0.

The data which is addressed from TABLE 5 is 000F (HEX) which is the equivalent of 15.

In step 4.3, the Width register is set to the contents of the word at PGT + 1 location, which is the Kl + 01 address in the TABLE 5. The data from the glyph table from the TABLE 5 at this location is 0009 (HEX) indicating that the width of the character is 9 pixels.

In step 4. 4 , the processing waits until the contents of the Window Bottom register, storing 63 at this time, minus the Paint Top register, storing 503 at this time, is greater than or equal to the contents of the Height register which was set to 15 in the step 4.2. Where this condition is satisfied, which occurs after the printer has printed 455 scanliens, and thus the

Transfer Process has incremented Window Bottom to 518 as will be explained below, the routine continues with step 4.5. Step 4.5 defines a loop which will be carried out for a scanline address, SM, from (SM) equal to 0 to (SM) equal to 14. The loop of step 4.5 assures that each scanline required for the character, the character "H" in the present example, will be accessed from the glyph table.

The sequence 4.5.1 is nested within the sequence of 4.5 and operates for every pixel address, TM, from (TM) equal to 0 to (TM) equal to 8. The step 4.5.1 assures that the full pixel width of the character, 9 pixels in the present example of an "H" will be accounted for. For each of the values of SM in 4.5 and of PM of 4.5.1, the steps 4.5.1.1 and following are executed.

The step 4.5.1.1 sets the Y register equal to the Paint Top register contents added to the current one of the values of SM. For the first value of SM = 0, the Y register is set equal to the contents of the Paint Top, which at this time is equal to 503 in accordance with step 3.1.2 previously executed. In step 4.5.1.2, the X register is set equal to the contents of the S-pos register, which in accordance with step 3.2.2 was set equal to 03EB (HEX) , which is the S-axis position 1003 at which the character "H" in Fig. 5 is to commence.

In 4.5.1.3, the sequence goes to 7, the Fetch Mask Pixel routine.

In step 7.1, the WPTR register, which is a pointer to the glyph .mask is set. The PGT + 2 portion is the initial address of the glyph mask (of TABLE 5) , which for the current operation is Kl + 02. The quantity ((Width + 15) "div" 16) determines the number of 16-bit words required to store the bits representing the pixels ^'for this scanline. In the present example, the width of the character "H" is 9, so that 9 + lb = 24 and the whole number division by 16 is 1. This means that one word is required to store the bit data representing pixels for the first scanline. Since the first value of SM is 0, however, nothing is added to the glyph table pointer PGT + 2 by the SM term. Finally the term (PM "div" 16) determines which word within the scanline corresponds to pixel position PM. Since PM is also equal to 0, the window pointer, WPTR is simply set to PGT + 2. The pointer, therefore, points to the word at the Kl + 02 address of the glyph table, TABLE 5.

In step 7.2, the PixPal register takes word (WPTR), which is the data E380 (HEX) from the Kl + 02 address of the glyph table. This data is left shifted by the amount of the PM, which in the present example is 0 modulus 16. Accordingly, there is no left shift.

In 7.2, the "and" function logically AND's the number 8000 (X). The binary value of this number has a 1 in the left-most bit position and all the remainder of the bits are 0. When this number is AND'ed with the other number in the 7.2, it has the effect of setting only the left-most bit as the single value for storing in the PixVal register. That value will be either a logical "0" or "1".

The 7.3 step returns to the 4.5.1.3 step which then is followed by the 4.5.1.4 step, which calls step 8, the Set Window Pixel Subroutine.

In step 8.1, the word pointer register WPTR is set to point to the correct word within the dynamic window.

The pointer WPTR is set equal to the Window Base plus the displacement of the beginning of the scanline Y from the beginning of the window, plus the displacement of the word that stores pixel X within the scanline Y.

Window Base is the starting address of the dynamic window buffer of the memory section.16-2 of Fig. 3.

Scanline Y is stored in the dynamic window at

(Y modulus Window Height) scanlines from the window base. So at this time the displacement from window base is (503 modulus 64) times 128 (the length of each scanline) , yielding 7040. The displacement of the

OMPI X pixel within the scanline is (X div 16) , which is 62. Thus step 8.1 sets WPTR equal to (Window Base + 7102).. This result is the word location in the dynamic window buffer that stores the first bit of the character "H" and at a location which corresponds to the S-axis location 1003 and the P-axis location 503. Having found the address of that location in the window buffer, as done in step 8.1, step 8.2 sets the contents of that location as pointed to by the pointer WPTR, equal to the contents of what already existed in that location as logically OR'ed with the logical "1" or "0" determined in step 7.2. If there was a logical one already in that location, then it remains; or if there was a logical one specified by the PixVal, then a "1" will be stored into the dynamic buffer at the location corresponding to S-axis 1003 and P-axis 503 in Fig. 5. Since in the present example, the dynamic buffer will nave already cleared to all zeroes during the Clear Window Sequence 2. The contents prior to step 8.2 of the bit location in the dynamic window buffer is 0. However, the PixVal value, being the first bit of the character "H" is a logical 1. However, the PixVal value was placed in the left-most position of the word in step 7.2

In step 8.2, the PixVal before the logical OR'ing is shifted from its left-hand-most position within a word to its correct position within the word, which in the case of the first bit of the character "H" is an 11-bit shift. This 11-bit shift is determined by the 1003 modulus 16 arithmentic which equals 11. The step 8.2 then OR's the logical "1" bit in the 11th bit position of the word at WPTR. At this point, a first bit of the page image data for the character "H" has been loaded into the dynamic buffer window at a location which will ultimately result in the pixel being printed at the location S-axis 1003 and the P-axis position 503 of Fig. 5.

In 8.2, the program returns to 4.5.1.4 where the processing of 4.5.1 continues for the next value of the pixel mask pointer, PM = 1. The processing then continues as before for PM = 0 until the bit corresponding to location S-axis 1004, and P-axis 503 in Fig. 5 is processed and stored at the appropriate location in the buffer memory.

This process continues until all of the remaining pixels in the scanline 503 of Fig. 5 have been determined and stored. Specifically, the remaining pixels are for the S-axis locations 1005, through 1011. After the pixel at location P-axis 503 and S-axis 1011 have been stored in the buffer memory, then the processing is at 4.5.1.4 and then the processing continues for step 4.5 wherein SM is equal to the next number 1 corresponding to the P-axis scanline 504 in Fig. 5. Again, the processing of 4.5.1 continues for all values of PM equals to 0 to PM equals to 8. This processing of 4.5.1 and 4.5. continues until all of the scanlines corresponding to the P-axis numbers 504 through 517 completes the painting of the entire glyphs "H". At that point, the process goes to 4.6 and returns to 3.2.4 to continue the Paint Loop Sequence.

The next step is 3.2.5 where the pointer to the sorted buffer, PSB, is set equal to the old value of PSB + 4. The step 3.2.5 steps the PSB address to the next location in the sorted page layout buffer which is TABLE 3. Since there were four words in the sorted page layout buffer for the CHAR command just processed incrementing by 4 is done in step 3.2.5, setting the pointer PSB at the beginning address for the next command in the sorted page layout buffer.

Processing continues at step 3.5, and since the Printer Started register has been set to one the next step is 3.2.

At this time, the processing continues for the CHAR command corresponding to the character "i" in the same way that was previously described for the character "H". When the character "i" has been painted and the sorted buffer pointer, PSB, has been incremented by 4 in step 3.2.5, the processing goes to 3.5 and again returns to 3.2.

In 3.2, the PSB register points to the sorted buffer at the SB + 8 address of TABLE 3. Since the command is not a CHAR command, then the processing jumps to 3.3. The RULE command is recognized so that the processing continues with 3.3.1. The various registers are loaded with the data from the sorted page layout buffer of TABLE 3, and in 3.3.5, the program goes to the Paint Rule Subroutine, which is step 5 of TABLE 7. The Paint Rule Subroutine is processed in a manner similar to the Paint Character Subroutine. After the underscore glyph has been painted, the processing returns in step 5.3 to step 3.3.5.

The next step is 3.3.6 in which the sorted page layout buffer pointer, PSB, is incremented by 5. ^~ Referring to the sorted buffer table, TABLE 3, the next command at

-

O PI the sorted buffer address, SB + D is a CONTROL command END.

The next step of 3.3.7 causes the processing to go to 3.5 and from there to 3.2. Since the next command is END, the processing steps from 3.2 to 3.3 and 3.4. In step 3.4, the END command is detected and the process¬ ing goes to 6, the Terminate Sequence.

In step 6.1, the processing waits until the Window Top is greater than or equal to the Paper Height. At this point, nothing in the process page routine of TABLE 7 increments the Window Top. This incrementing occurs by the TRANSFER PROCESS ROUTINE described hereinafter in connection with TABLE 8.

When the Window Top is incremented to a value greater than the Paper Height value and the processing in TABLE 7 continues to 6.2 where the Top Reached register is reset to 0 in preparation for the next processing. Thereafter, the painting process is finished as indicated in step 6.3.

At the point in time when the TABLE 7 routine set the control register in step 3.6 where IPRINT, the register 54 in Fig. 4 transmitted to the printer 4 of Fig. 1, the IPRINT signal-. When the printer sees the IPRINT signal equal to 1, it starts a print cycle. The print cycle starts the printer moving, and when the top edge, that is the first edge, of the paper reaches a prespecified point, the printer sends out a signal ITOP as a logical "1" which is loaded into the

OMPI status register 53 which is regularly loaded by the processor 15 of Fig. 3.

The printer regularly sends an IBD signal on line 40 of Fig. 4 (part of the bus 6 in Fig. 1) to signal the request for the IVID pixel data on line 28. The IBD signal starts the pixel transfer (that will be described in more detail below) to the printer. When no page is being printed, this transfer has no effect. When the transfer finishes the MAX CT 31 signal clocks the LINE DONE 46 signal, whihc is transmitted to the interrupt circuit of the processor 15. The processor 15 immediately interrupts the processing which is currently going on and executes an interrupt routine which is the transfer process routine of TABLE 8.

- fREA

OMPI TABLE 8 - TRANSFER PROCESS ROUTINE

1. Save Status of Interrupted Process

2. If (Top Reached = 1) then go to (4)

3. Check for Paper Top Reached

3.1 If [(STAT REG, bit ITOP) = 0) then go to (6)

3.2 Printer signals Paper Top

3.2.1 set (Top Reached) = 1

3.2.2 load (CTRL REG, bit IPRINT) = 0

4. If [(Window Top) = (Paint Top)] then go to (6)

5. Transfer Window Top Scanline

5.1 load (ADDR CTR) = 0

5.2 for each word address, SPTR, in the Window Top scanline.: from (SPTR) = [(Window Base) + ((Window Top) ^' "mod" (Window Height) ) x (Window Word Width) ] . to (SPTR) = [ (Window Base) + ( (Window Top) "mod" (Window Height) ) x

(Window Word Width) + (Window Word Width) - 1]

5.2.1 load (DATA REG) = Word (SPTR)

5.2.2 set word (SPTR) = 0

5.3 Advance Dynamic Buffer Window

5.3.1 set (Window Top) = [(Window Top) + 1]

5.3.2 set (Window Bottom) = [(Window Top) +

(Window Height) - 1]

6. load (ADDR CTR) = 0

7. Restore Status and Resume Interrupted Process In step 1 of the transfer process, the first step is to save the status of the interrupted process, usually the process of TABLE 7, so that after the transfer process of TABLE 8, the processor 15' can continue processing at exactly the step that it was in before.

The next step is 2 and the routine examines whether or not the Top Reached register is equal to 1. When Top Reached has not been set equal to 1 the routine in TABLE 8 goes to 3. In 3.1, the status register 53 of Fig. 4 is examined to see if ITOP is equal to 0. If so, then the routine of TABLE 8 goes to 6, loads the address counter 32 of Fig. 4 with all 0's and m step 7 restores status and resumes the interrupted process. When the printer has been started (by the Process Page Routine of table 7) , eventually the paper top is reached, at which time the printer signals ITOP 71 _f which causes the routine to go from 3.1 to 3.2. In

3.2.1, the Top Reached register is set equal to 1. In

3.2.2, the control register 54 is reset so that IPRINT is "0", so that the next page will not be started until it is requested by the Process Page Routine.

In step 4, if the Window Top equals the Paint Top, then an error has occurred and the routine of TABLE 8 exits through step 6 and 7. Assuming that an error has not occurred, a transfer occurs in step b .

In step 5.1, the address counter 32 of Fig. 4 is loaded to all 0's

In step 5.2, the pointer within the scanline to be transferred, SPTR, identifies the word in the buffer memory to be transferred over the data bus 49 to the scanline buffer 21. In 5.2, the word address, SPTR, for each word in the Window Top scanline is stepped from the starting word to the ending word. In step 5.2.1, each of the words specified by the SPTR address determined in 5.2 is loaded into the data register 20 in Fig.4. In 5.2.2, after the word is loaded, and 5.2.1, the contents of that word in the buffer memory are set to 0, thereby clearing the buffer in readiness for the next painting operation.

After all of the words in the scanline have been transferred and cleared as set forth in 5.2, the dynamic buffer window is advanced.

In step 5.3.1, the contents of the Window Top register are incremented by 1.

In step 5.3.2, the contents of the Window Bottom register are incremented by 1.

In step 6, the address counter 32 of Fig. 4 is loaded with all O's to put it in the starting condition for addressing the next scanline.

In step 7, the status is restored in the processor 15 and the process previously interrupted is resumed at the same point in the processing.

Every time the transfer process of TABLE 8 is entered by means of an interrupt caused by the carryout of the address counter 32 of Fig 4, the Window Top scanline is transferred from its location in the dynamic window buffer 16-2 over the image generator of Fig. 3. The effect of transferring out the Window Top scanline is to make that scanline available for new data to be painted by the painting process described in connection with TABLE 7. The Window Top scanline effectively become the bottom scanline in the dynamic window buffer. The rate at which each new Window Top scanline is transferred from the window buffer 16-2 to the scanline buffer 21 of Fig. 4 is fixed by the operation of the printer 4. The printer 4 at regular fixed intervals sends the IBD signal requesting a new scanline, thereby empyting the scanline buffer 21. As soon as the buffer 21 is emptied, the scanline buffer 21 is refilled by the transfer process routine of TABLE 8. In being filled, the word counter 33 is initially set to 0 in the step 5.1 each time a new LOAD DATA signal is decoded by the address decoder 52, the word counter 33 is incremented to a new word address until all 128 words have been loaded into the buffer 21. The amount of time it takes to fill the scanline buffer 21 with the Window Top scanline from the dynamic window buffer is less than the amount of time taken for the retrace cycle of the printer 4 of Fig. 1. Typically, the amount of time it takes to load the scanline buffer 21 is less than 15 percent of the time that the printer takes in a single scanline cycle. For this reason, the time spent in the transfer process routine of TABLE 8 does not interfere with the processors ability to do the painting routine of TABLE 7. Most of the time of the processor 15 is spent in filling the dynamic window.

The processing done in accordance with the TABLE 7 routine is asynchronous with respect to the processing done with the TABLE 8 transfer process routine. As previously described, the rate of filling the dynamic window is a function of the local complexity of the data in the sorted page layout buffer. When that data is complex, the data filling the dynamic window slows

-f& E down, and when the data is less complex, the filling increases in rate. On the other hand, the emptying of the dynamic window is a fixed rate as determined by the laser printer.

In the example described with the three glyphs of Fig. 5, an example of local complexity can be understood in connection with the painting of the P-axis scanlines 503 through 517, as compared with the scanlines 518 through 523. In order to paint the characters "H" and "i", the TABLE 7 routine executed a number of steps sequentially in order to form "1" or "0" bits in the appropriate locations of the dynamic window buffer. However, since all of the pixels between scanline 528 and scanline 533 are white, no processing time was required for this region. Then again, from scanline 534 through 536, processing was required by the painting routine of TABLE 7.

Obviously, the rate of filling the buffer for scanlines 503 through 517 and 524 through 526 is much slower than the rate of filling the lines 518 through 523, which required no time. Accordingly, the average time for filling the scanlines 503 through 526 inclusive is faster, because no time was spent on the lines 528 through 533.

While the example of local complexity described in connection with Fig. 5 demonstrates the concept, much greater complexity than is ^• shown m Fig. ^* 5 can be processed in accordance with the present invention.

An example of severe local complexity exists if, for example, the sorted page layout buffer of TABLE 3 were expanded so that the exact page image which produces the printed page of Fig. 5 were to be painted 500 times, then the painting process would be extremely complex in the local region of the Fig. 5 printed page. The image generator would require 500 times the amount of processing time to produce the very same printed page which was originally produced by the page layout data of TABLE 3 before it was expanded. However, the average number of glyphs on the total printed page on an average would not be excessive. However, the 500 times local complexity might cause the image generator to fail to be able to paint at sufficiently high-enough rate to keep up .with the rate at which the laser printer required to page image data.

In the present invention, the problems presented by local complexity are significantly reduced because of the ability of this system to paint at a variable rate. The slow rate of filling the buffer is averaged with a fast rate of filling the buffer so that the average rate without causing errors in the printed page is effectively much higher. ^*

FURTHER AND OTHER EMBODIMENTS

While the present invention has been described in terms of an image generator in which access to the memory 16 of Fig. 3 is through the processor 15, direct memory accessing techniques can be employed. For example, the printer interface 8 within the image processor 3 of Fig. 1 can be connected through direct memory access circuits to the memory 16 within the image generator 7 of Fig. 3. Such direct memory access connections will, of course, enhance the speed at which transfers can be made from the dynamic window buffer to the printer interface.

OMPI Also, a direct memory access (DMA) circuit may be connected between the processor 15 and the memory 16 -so that certain memory accesses such as required to clear the dynamic window buffer, can be carried on in parallel with other processing by the processor 15.

In the present invention, the dynamic window buffer has been described having a one-for-one map between bits in a cell and pixels on a printed page. While the amount of time required to paint the dynamic window buffer is not great when only white pixels are called for, the dynamic window buffer still has a space occupied when a one-for-one bit-to-pixel map exists. In order to conserve space within the dynamic window buffer, encoding schemes can be employed so that the data is stored more compactly. For example, run length encoding could be employed within the dynamic window buffer as one compaction technique. If page image data is compacted with an encoding scheme, a given physical size for the dynamic window buffer creates an effective dynamic window buffer of a larger size. For example, referring to Fig. 2, the entire printed page can be represented within the dynamic window buffer of only 64 lines. In the previous example, with no encoding,• only 64 scanlines worth of data, even they are all white pixels, can appear in the dynamic window buffer at any one time. Although no time is required in filling the buffer, there is time required in emptying the buffer. Furthermore, with a one-for-one bit-to-pixel map, no more than the equivalent of 64 lines can be stored into the dynamic window buffer. For this reason, the averaging of the high rate of painting when the local complexity is low with the slow rate of painting when the local complexity is high, is limited to a 64 scanline area. However, when encoding is employed

OMPI within the dynamic window buffer, the average can occur over a much larger effective dynamic window buffer, even when the physical size of the dynamic window buffer is not increased.

In the present invention, the painting process of TABLE 7 was carried on a bit at a time. In order to speed up the painting process, a bite or word processing can be carried out. In such a case, the Paint Character and the Paint Rule procedures will be modified to account for the multi-bit processing of page image data.

If encoded information is stored in the dynamic window buffer, then an appropriate decoding of the encoded information can be included within the printer interface of Fig. 4. For example, in Fig. 4, the output from the data register 20 would be connected through a decoder before entry into the scanline buffer 21. Accordingly, an encoded representation from data register 20 would be further decoded into the scanline buffer 21. The size of the scanline buffer 21 can be increased if desired. With this alternate embodiment in accordance with the present invention, a plurality of different independent data rates will exist in the system. A data rate for painting the dynamic window buffer in the memory 16 will exist. Another data rate for decoding the encoded information from the dynamic window buffer will occur in the decoder in Fig. 4, and finally, the predetermined data rate to the printer will exist. Accordingly, the decoding of page layout information will be spread into three separate and distinct decoding rates, each asynchronous with respect to the other. While the invention has been particularly shown and described with reference to preferred embodiments thereof, it will be understood by those skilled in the art that the foregoing and other changes in form and detail may be made therein without departing from the spirit and scope of the invention.

OMPI

Claims

What is claimed is:

1. A page printing system in which encoded page layout information is processed to form a printed page comprising, a printer operating at a preestablished printing rate to print the printed page, during a printing time, as an array of variable intensity pixels in response to stored page image data, an image processor for processing the encoded page layout information to form said page image data, said processor operating to form said page image data, at a variable rate, during a processing time where said variable rate is such that the duration of said processing time does not exceed the duration of said printing time, said processor including interface means connecting said image processor to said printer, whereby said page image data is transferred to said printer to control the printing of pixels to form the printed page.

2. The system of Claim 1 wherein said image processor includes a dynamic window buffer for storing said page image data, wherein said image processor fills said dynamic window buffer at said variable rate and wherein said interface means includes means to receive said page image data so as to empty said dynamic window buffer at a second rate.

3. The system of Claim Λ wherein said printer is a laser printer operating to print said printed page^"by moving said printing page in a pageward direction while scanning a laser beam in a scanward direction orthogonal to said pageward direction and wherein said page image data must be received at said second rate in order to print said printed page without error.

4. The system of Claim 3 wherein said interface means includes a scanline buffer for storing page image data for a scanline of said printed page, said page image data emptied from said dynamic window buffer for filling said scanline buffer, and said scanline buffer connected to empty said page image data to said printer at said second rate.

5. The system of Claim 1 wherein said image processor includes an image generator, wherein said image generator includes a processor and a memory, said memory including a page layout buffer for receiving encoded page layout information, said memory including a dynamic window buffer for storing said page image data decoded from said page layout information, said memory including a glyph table for storing a mask representation of the characters to be utilized in the formation of said page image data, said processor processing routines .for decoding said page layout data to form said page image data temporary storage in said dynamic window buffer.

6. The system of Claim 5 wherein said processor executes a first routine for forming said page image data and executes a second routine for transferring information from said dynamic window buffer to said interface means, said processor operating in an interruption mode to interrupt the processing of said first routine forming page image data to transfer data to said interface means whenever said interface means s empty of page image data.

7. The system of Claim 1 wherein said printer provides a data request signal to request page image data, and wherein said interface means includes _. a scanline buffer for storing page image data representing a scanline of the printed page, an address counter for addressing said scanline buffer, clock means for counting said address counter when enabled to sequence through the addresses of the page image data in said scanline buffer, means for sensing said request signal from said printer to enable said clock means to step said address counter whereby the page image data is transferred to said printer.

8. A page printing system including a printer operating at a preestablished printing rate to print a printed page, during a printing time, as an array of variable intensity pixels, each pixel having an intensity and a location determined in response to page image data, said system processing encoded page layout information to form a printed page, said system comprising, an image processor for processing the encoded page layout information to form said page image data, said image processor including an image generator operating to form said page image data, at a variable first rate, during a processing time where said variable first rate is such that the duration of said processing time does not exceed the duration of said printing time, said image processor including interface means connecting said image processor to said printer, said interface means transferring said page image data to said printer at a second rate to control the printing of pixels to form the printed page.

9. The system of Claim 8 wherein said image processor includes a dynamic window buffer for storing said page image data, wherein said image generator fills said dynamic window buffer at said variable first rate and wherein said interface means includes means to receive said page image data thereby emptying said dynamic window buffer at said second rate.

10. The system of Claim 9 wherein said dynamic window buffer has a capacity to store a number of scanlines of page image data less than the number of scanlines for said printed page.

11. The system of Claim 10 wherein said image generator includes means for specifying a Window Top address and means for specifying a Window Bottom address having a predetermined offset from said Window Top address, said Window Top and Window Bottom addresses corresponding to the top scanline and the bottom scanline of page image data for corresponding scanlines of the printed page, and including means for specifying the Paint Top scanline at which page image data is being entered into the dynamic window buffer, said interface means including means for interrupting said image generator for accessing a scanline of information from said Window Top address.

12. The system of Claim 11 wherein said image generator includes first means for incrementing said Window Top and said Window Bottom addresses in response ^* to a transfer of a scanline from said Window Top address, and includes second means for incrementing said Paint Top address each time a page image scanline is stored in said Paint Top address, said first means and said second means incrementing at rates which are asynchronous with respect to each other.

13. The system of Claim 11 wherein said dynamic window buffer has a page image bit location for each pixel in a corresponding scanline of the printed page whereby there is a one for one correspondence between page image bits and printed page pixels.

14. The system of Claim 11 wherein the local complexity of the page layout data varies from whereby the rate of forming the page image data correspondingly varies.

15. A method of page printing in a page printing system including a printer operating at a preestablished printing rate to print a printed page, during a printing time, as an array of variable intensity pixels, each pixel having an intensity and a location determined in response to page image data, said system processing encoded page layout information to form a printed page, said method comprising, processing encoded page layout information to form said page image data, at a variable first rate, during a processing time where said variable first rate is such that the duration of said processing time does not exceed the duration of said printing time, storing said page image data in a window buffer transferring said page image data from said window buffer at a second rate to control the printing of pixels to form the printed page.