JP2002223360A - Encoding device and method, decoding device and method, storage medium, printer driver and storage medium for storing the same - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reversibly encode a multi-level image with high compressibility or to efficiently decode this encoded multi-level image. SOLUTION: A printer driver 4 encodes multi-level image data based on print data indicated by a computer application and outputs the encoded multi- level image data to a printer 6 through a port driver 5. In this case, the printer driver 4 generates a code corresponding to the number of values of the preceding pixel which continues, a code corresponding to a difference value with respect to a previous pixel, and a code showing how many pieces of data that continue from the same position in a scan direction in the preceding line are used and outputs those codes.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an apparatus, a method, and a storage medium for performing encoding for compressing multivalued image data and decoding for decoding the code, and a printer driver to which the apparatus is applied. .

[0002]

2. Description of the Related Art To compress multi-valued image data, JPE
It is common to use lossy compression such as G. However, although lossy compression can reproduce an image close to the original image, the same image as the original image cannot be reproduced, and an unintended image may be reproduced. In a lossy compression such as JPEG, a high compression ratio can be obtained,
The amount of calculation in encoding is large, and when encoding with software, encoding requires a considerable amount of time. In addition, there is a disadvantage that the scale of the decoder becomes large when decoding is performed by hardware.

On the other hand, lossless compression can reproduce the same image as the original image, but it is difficult to achieve a high compression ratio. There is also a disadvantage that encoding requires time.

For example, as one of the lossless compression methods, there is a method using a run-length code. The run-length code is used to encode the repetition length and data when the same data repeats. Run-length codes can be encoded very quickly by software.However, even when image data has correlation in both horizontal and vertical directions, only horizontal correlation contributes to compression and vertical correlation However, it does not contribute to the compression even if it exists, so it is difficult to obtain a high compression ratio.

[0005] As another reversible compression, there is a method using a delta row code. The delta row code encodes the length of the continuous data when the same data as the immediately preceding line continues. The Delta Row code can be encoded at a considerably high speed by software.However, even when there is a correlation in both the horizontal and vertical directions such as image data, only the vertical correlation contributes to the compression, and the horizontal correlation is reduced. Even if it does not contribute to compression, it is difficult to obtain a high compression ratio.

There is a method using Huffman codes as another reversible compression. The Huffman code checks the distribution of data and encodes data with a high frequency of appearance into a short code. Even when the Huffman code has a correlation in both the horizontal and vertical directions as in image data, it is difficult to obtain a high compression rate because the correlation in either direction does not contribute to compression.

Various other codes such as LZ77 code, LZ78 code, JBIG code have been devised.
In both cases, it is necessary to examine the data other than the data immediately above and to the left of the horizontal and vertical correlations, so that the amount of calculation in the coding is large. It takes a considerable amount of time, and has the disadvantage that the size of the decoder increases when decoding is performed by hardware.

[0008]

SUMMARY OF THE INVENTION The present invention provides an encoding apparatus and method, a decoding apparatus and method, a storage medium, and a storage medium for losslessly encoding a multi-valued image at a high compression rate or efficiently decoding this code. It is intended to provide a printer driver and a storage medium for storing the printer driver.

[0009]

In order to solve such a problem, for example, an encoding apparatus according to the present invention has the following arrangement.
That is, a coding apparatus for coding multivalued image data to be output, a continuous pixel coding means for generating a code corresponding to the number of consecutive values of the immediately preceding pixel, and a difference value with respect to the immediately preceding pixel. A difference value encoding means for generating a code corresponding to the preceding line; a previous line reference encoding means for generating a code indicating how many consecutive data are used from the same position in the scanning direction in the immediately preceding line; Means,
The image processing apparatus further includes an output unit that outputs a code generated by adaptively using the difference value encoding unit and the previous line reference encoding unit.

In the present invention, decoding is performed by a simple operation such as copying the immediately preceding line, repeating the immediately preceding left data, or adding to the immediately preceding left data, using the line buffer holding the immediately preceding line. I do.

It is to be noted that, in addition to the above, a preferred embodiment of the present invention provides a coding method in which the amount of calculation when compressing a multi-valued image is reduced and the time required for coding is reduced when coding by software. It is to provide. Another object of the present invention is to reduce the amount of calculation when decoding a code, reduce the time required for decoding when decoding by software, and reduce the circuit scale required for a decoder when decoding by hardware. That is.

[0012]

Embodiments of the present invention will be described below in detail with reference to the accompanying drawings.

<First Embodiment> FIG. 1 is a block diagram showing the configuration of the apparatus of the present invention. In FIG. 1, reference numeral 1 denotes a computer (for example, a personal computer or the like using Microsoft's Windows as an OS), such as a CPU, a memory, a hard disk, a floppy (registered trademark) disk drive, a keyboard, a mouse, a monitor, and a parallel port. (Not shown). Reference numeral 2 denotes an operating system, which includes hardware included in the computer 1, an application 3, a printer driver 4,
It manages software such as the port driver 5. The application 3 is, for example, application software such as a word processor, and creates and prints a document in accordance with an instruction from an operator. A printer driver 4 receives a print command issued by the application 3 via the operating system 2 and converts the print command into a printer command that can be interpreted by the printer 6. Reference numeral 5 denotes a port driver which receives a printer command converted by the printer driver 4 via the operating system 2 and transmits the command to the printer 6 via a parallel port. Reference numeral 6 denotes a printer, and a port driver 5
Print according to the printer command received from the printer.

FIG. 2 is a block diagram showing the configuration of the printer 6. In the figure, a parallel port 11 receives a printer command from the computer 1. 12 is FIF
O (first in first out) memory,
The encoded data received by the parallel port 11 is stored,
The stored data is output to the decoding circuit 13 in a first-in first-out order. The decoding circuit 13 decodes the code string data stored in the FIFO memory 12 and outputs it to the printer engine 14. The printer engine 14 is a laser beam printer engine, and performs printing in accordance with the image data output from the decoding circuit 13 according to an instruction from the control circuit 15. The image data is output in plane order for each color of cyan, magenta, yellow, and black. Each color pixel is composed of 8 bits.
256 gradations can be expressed. Reference numeral 15 denotes a control circuit, which is formed of, for example, a one-chip CPU, and controls the parallel port 11, the FIFO memory 12, the decoding circuit 13, and the printer engine 14. Hereinafter, the printing operation will be described.

When the operator operates the application 3 on the computer 1 to generate print data and gives a print instruction, a print command is passed from the application 3 to the printer driver 4 via the operating system 2. The printer driver 4 creates RGB image data of three colors of red, green, and blue based on a print command issued from the application 3, and then converts the RGB image data of four colors of cyan, magenta, yellow, and black. CMYK
Convert to image data. And the printer driver 3
Generates encoded data from the created image data based on an encoding procedure to be described later, and outputs the encoded data along with a print control command for specifying a paper size, a line length and the number of lines of bitmap data, and the like. The port driver 5 transmits to the printer 6 a series of printer commands created by the printer driver 3 and including a print control command and encoded data.

On the other hand, the printer 6 forms an image on a recording medium (recording paper or the like) based on the data transmitted as described above, and the operation is as follows.

The control circuit 15 receives a printer command via the parallel port 11. If the received printer command is a print control command, it is held in the control circuit 15 for print control. If the received printer command is encoded data, it is stored in the FIFO memory 12. Thereafter, when it is detected that the reception of the printer command constituting one page is completed by receiving a page end command or the like, the printer engine 14 is instructed to start printing. When the start of printing is instructed, the printer engine 14 feeds paper from the paper feed cassette, and requests the decoding circuit 13 to output image data when the paper reaches a predetermined position. The decoding circuit 13
The encoded data is read from the FIFO memory 12 in advance, and the decoded image data is stored in an internal buffer. When the printer engine 14 requests the output of the image data, the image data stored in the internal buffer is stored. Is output. The decoding circuit 13 reads out the subsequent coded data from the FIFO memory 12 when there is free space in the buffer holding the image data, decodes the coded data, and stores it in the internal buffer. In this manner, the encoded data is sequentially decoded and output as image data, and when the output of one page of image data is completed, printing is completed.

Next, the codes generated by the printer driver 3 shown in FIG. 1 will be described with reference to the tables shown in FIGS.

FIG. 3 shows the printer driver 3 shown in FIG.
FIG. 3 is a diagram illustrating an example of an encoding table generated by. The code described in the present embodiment has a variable length in bit units,
For example, it is represented by a bit string from 3 bits to 23 bits. Like the Huffman code, each code is configured so that the code can be identified by sequentially examining the code from the beginning. Note that each color component of each pixel data is represented by 1 byte (256 gradations) and has any of 0 to 255.

In order to simplify the description, one color component will be described here. Switching to another color component is performed by designating a control command to that effect. That is, the printer driver outputs the codes of the Y, M, C, and K color components for each block, and switches between the color components is performed by giving a control command. Note that the output order is not limited to blocks, and may be plane (plane) sequential.

FIG. 3 shows, for example, that the bit sequence of the code is "10
“110100100” is an “EOL” command, indicating that the same position of the immediately preceding line is copied to the end of the line. Generally, print data has a right margin. In this case, a blank exists at the end of each line.
The EOL command is not essential because it can be replaced by a Copy command that explicitly specifies the number of pixels to be copied. However, since the blank on the line immediately above can be copied without explicitly specifying the number of pixels to be copied. , Can contribute to the improvement of the compression ratio.

When the code bit string is "0110011"
0101000001010001 ”, the EOB
Command indicating the end of the code block. Generally, image data is transmitted after being divided into a number of blocks, and the EOB command indicates the end of the block and plays a role of aligning a bit unit code on a byte boundary.

The bit sequence of the code is "1011010".
0011 "," 000 "," 10111 "," 0011 "
1000100010 "and so on, from 0 bytes to 63
This is a Copy command up to a byte, and copies the data at the same position on the immediately preceding line by the number of pixels specified by the command. The 0-byte Copy command is not used alone, but is used in combination with an AddCount command described later.

The bit sequence of the code is "1011010".
0110110101 "," 010 "," 0111 "
In the case of "0", "101101001101101000", etc., it is a Repeat command from 0 bytes to 63 bytes, and the immediately preceding pixel data is repeated by the number of pixels specified by the command. Note that the 0-byte Repea
The t command is not used alone, and A
Used in combination with the ddCount command.
Note that the immediately preceding pixel is usually the pixel immediately to the left of the pixel to be decoded, but if the pixel to be decoded is the leftmost pixel of the line and there is no pixel to the left of the line, the line of the previous line is Use the last pixel instead. Also, if the pixel to be decoded is the leftmost of the first row,
0 pixel data is used instead.

The bit sequence of the code is "1011010".
000 "," 01100101000 "," 01110 "
10011111010 ", etc., an AddC of 64 bytes to 4032 bytes (however, an integral multiple of 64)
This is an out command, and the number specified by this command is added to the number of pixels of either the subsequent Copy command or Repeat command. Since the number of pixels to be copied or repeated reaches a maximum of several thousand bytes, assigning an independent command to each of them significantly increases the number of commands, so that the scale of the restorer becomes large when performing restoration by hardware. There is a disadvantage that. On the other hand, if the number of copying or repetition is reduced in order to reduce the number of commands, when the number of pixels of copying or repetition is large, it must be coded into a large number of commands, resulting in a problem that the compression ratio is reduced. By providing the AddCount command having a value that is an integer multiple of 64, the number of commands can be reduced without limiting the number of pixels for copying or repeating. For example, when the number of repetitions is large, it can be realized by designating a rough repetition by 64 × n, and then designating a fine repetition. As a result, it is possible to avoid the problem that the scale of the decompressor becomes large when performing decompression by hardware without deteriorating the compression ratio.

The code bit string is "110", "1"
001 "," 01101001000000010110
001 "," 1010 "," 111 ", etc., are PixelDiff commands from 1 to 255, and the difference from the immediately preceding pixel data is 1 to 255, respectively.
Indicates a pixel.

The point to be noted here is that the value to be added to the value of the immediately preceding pixel is such that the code length at 1 or 255 is minimized and the value at the center 128 is maximized. The first reason is that adjacent pixels of a multi-valued image often have similar pixel data, that is, the difference between adjacent pixel data in a multi-valued image is distributed around 0. The reason why the code length is short when the value to be added is as large as 255 is that when a binary image such as a character or a line drawing is read by a multi-valued scanner, the density of the edge portion of the character or a line drawing is generally 0 to 0. It changes to 255 or conversely from 255 to 0. Therefore, in the case of a character line drawing, such a change is frequent, so that the code length is reduced even when the density change is large.

By encoding the difference between adjacent pixel data using the above-mentioned PixelDiff command, the distribution of the appearance frequency of the command is biased. Therefore, by assigning a short code to a value of a difference having a high frequency such as 1 or 255, ,
The compression ratio can be increased.

Since the calculation between pixel data is performed modulo 256, -1 is represented by 255. If there is no difference between adjacent pixel data,
Since it can be expressed by a t command, a PixelDiff command with a difference of 0 is unnecessary.

For these codes, the appearance frequency of each command is obtained in advance from a large number of image data, and a short code is used for a command having a high appearance frequency and a command is used for a command having a low appearance frequency, similarly to the Huffman code. By assigning a long code, the compression ratio can be increased.

Next, an example of the reference numerals shown in FIG. 3 will be described with reference to FIG.

The code string "101111101010011"
101101100111010110100100 "
(39 bits in this case) is composed of eight codes as shown in FIG. The pixel to be decoded is the leading end (leftmost) of the line, and the decoded data of the immediately preceding line is “0, 0, 0, 0, 0, 0, 128, 128, 1”.
28, 128, 128, 128 ".

The first code "10111" is a Copy2 command, which indicates the copying of 2-byte data "0, 0" from the position immediately above the immediately preceding line. Next, the code “110”
Is a PixelDiff1 command, which indicates pixel data “1” obtained by adding 1 to the immediately preceding pixel data “0”. Next, reference numeral “1010” is a PixelDiff254 command, which indicates pixel data “255” obtained by adding 254 to the immediately preceding pixel data “1”. Next, the code “01110”
Is a Repeat2 command, which indicates that the immediately preceding pixel data “255” is repeated by 2 bytes. Next, reference numeral “110” is a PixelDiff1 command, which indicates pixel data “0” obtained by adding 1 to the immediately preceding pixel data “255”. Note that the addition at this time is calculated using 256 as a modulus, and the lower 8 bits are valid. Therefore, in this case, the value becomes 0 instead of 256. Next, the code “110” is Pix
This is an elDiff1 command, and indicates pixel data “1” obtained by adding 1 to the immediately preceding pixel data “0”. Next, a code “01110” is a Repeat 2 command, which indicates that the immediately preceding pixel data “1” is repeated by 2 bytes.
Next, the code “10110100100” is an EOL command, from the position immediately above the immediately preceding line to the end of the line (end of line), in this case, 2-byte data “128, 12”
8 ".

As a result, when a color component of one pixel is represented by 8 bits, 39 bits are required instead of 8 × 12 pixels = 96 bytes = 768 bits.

Next, the encoding procedure of the printer driver 4 will be described in detail with reference to the flowchart shown in FIG.

The printer driver 4 generates RGB image data in accordance with the instruction of the application 3,
The GB image data is converted into CMYK image data. RG
The conversion itself from B to YMCK is publicly known, and a description thereof will be omitted.

Next, for each block of image data, FIG.
Is called.

First, in step S1, initialization is performed for each block. Specifically, 0 is stored in the variable Y and the final pixel data. Here, the variable Y here holds the line number of the target pixel, and the “final pixel data” holds the pixel data immediately before the target pixel. Next, 0 is stored in a variable X in step S2. The variable X holds the column number of the pixel of interest.

Next, in step S3, it is determined whether the variable Y is 0. If the variable Y is not 0, there is a possibility that the immediately preceding line is copied, so it is determined in step S4 whether the target pixel is the same as the pixel data immediately above. If the target pixel is the same as the pixel data immediately above, the data of the immediately preceding line can be copied, and the number of pixels to be copied is determined in step S5. Specifically, the number of pixels in which the pixel on the right of the target pixel is continuously the same as the pixel immediately above it is determined.
However, if it reaches the right end of the line, it shall be terminated there. Next, in step S6, it is determined whether or not copying is performed up to the end of the line (right end = end of line). Specifically, when the sum of the variable X and the number of pixels to be copied obtained in step S5 matches the number of pixels of one line, it can be determined that copying is to the right end of the line. If it is not the copying up to the end of the line, it is determined in step S7 whether the number of pixels to be copied obtained in step S5 is larger than 63. If the number of pixels to be copied determined in step S5 is greater than 63, an AddCount command is output in step S8 according to the number of pixels to be copied determined in step S5. In either case, the process proceeds to step S9, outputs a Copy command according to the number of pixels to be copied obtained in step S5, and proceeds to step S17.

If it is determined in step S6 that copying is to be performed up to the end of the line, an EOL command is output in step S10, and the flow advances to step S17.

On the other hand, if the variable Y is 0 in step S3 and if it is determined in step S4 that the variable is not the same as the pixel immediately above, the process proceeds to step S11.
It is determined whether the target pixel is the same as the last pixel data. If the target pixel is the same as the last pixel data, the last pixel can be repeated, and the number of pixels to be repeated is determined in step S12. Specifically, the number of pixels in which the pixel on the right side of the target pixel is continuously the same as the final pixel data is obtained. However, if it reaches the right end of the line, it shall be terminated there. Next, in Step S13, Step S
It is determined whether or not the number of repeated pixels obtained in step 12 is greater than 63. If the number of pixels to be repeated determined in step S12 is larger than 63, in step S14, step S1
AddCount according to the number of repeating pixels obtained in step 2
Output a command. In any case, the process proceeds to step S15, outputs a Repeat command according to the number of pixels to be repeated determined in step S12, and proceeds to step S17.

If it is determined in step S11 that the pixel of interest is not the same as the final pixel data, the flow proceeds to step S16 in accordance with the value obtained by subtracting the final pixel data from the pixel data of interest.
A xelDiff command is output, and the process proceeds to step S17.

When the process proceeds to step S17, the data of the last pixel among the processed pixels is stored in the "final pixel data", and then updated by adding the number of processed pixels to the variable X. I do. Then, in step S18, it is determined whether the processing of one line has been completed, specifically, whether the variable X has reached the number of pixels of one line. If the processing for one line has not been completed, the process returns to step S3, and the processing for the current line is continued. When the processing of one line is completed, the processing is updated by adding 1 to the variable Y in step S19, and whether the processing of the block is completed in step S20, specifically, when the variable Y is It is determined whether the number of lines has been reached. If the processing of the block has not been completed, the process returns to step S2, and the processing of the next line is continued.
When the processing of the block is completed, an EOB command is output in step S21, and the block is aligned on a byte boundary in step S22. Specifically, if the number of output bits is not an integral multiple of 8, the bit “0” is output until the number of bits reaches the integral multiple of 8, and the process returns to the next process.

The above processing is performed for each block. After the process for one color component is completed for all pages, the process may be performed for the next color component.
The target color component may be changed every time the block processing is performed.

Next, the details of the decoding circuit 13 in the printer 6 in the embodiment will be described.

FIG. 6 is a block diagram showing details of the decoding circuit 13.

In the figure, an input buffer 21 is a FI
The code data read from the FO memory 12 is stored.
The input buffer 21 is capable of storing at least 4 bytes of data.
If there is data in the O memory 12, the FIFO memory 12
Read data from and store it. When the number of processed bits held in the bit counter 23 becomes eight or more, the input buffer 21 discards unnecessary processed data.

The selector 22 is, for example, 23 sets of 8-input selectors, and the command decode circuit 24 processes the code data stored in the input buffer 21 by selecting the code data according to the number of processed bits indicated by the bit counter 23. Command start position necessary for this. This is necessary because the input buffer 21 holds data in byte units, whereas the command is variable-length data in bit units and thus has eight start positions.

The bit counter 23 is provided in the input buffer 21
And stores the number of processed bits in the code data stored in. The bit counter 23 also updates the value stored in the bit counter by adding the number of bits of the command output from the command decode circuit 24. When the input buffer discards the processed data, the bit counter 23 subtracts the number of discarded bits. When the command decode circuit 23 decodes the EOB command, the bit counter 23 receives the EOB signal from the command decode circuit 23 and performs a byte boundary alignment process. Specifically, the lower three bits of the bit counter
If the bits are all 0, nothing is done; otherwise, 8 is added and the lower 3 bits are cleared.

The command decode circuit 24 is composed of, for example, a read-only memory or a wired logic, decodes the code data stored in the input buffer 21, which has been aligned by the selector 22, and according to the decoded command, a counter 26. , Copy output circuit 27, repeat output circuit 28, data output circuit 2
9, and outputs the above-described or later-described various signals to the bit counter 23 and the subtraction circuit 34.

The counter 26 holds the number of pixels processed by the Copy command or the Repeat command, and is decremented each time one byte is copied or repeated. In this embodiment, since one color component of one pixel is one byte, the number of pixels and the number of bytes of one color component match. The counter 26 can independently set the upper 6 bits and the lower 6 bits. When the command decode circuit 23 decodes the AddCount command, the command decode circuit 23 outputs the added value of the number of processed pixels in the upper position of the counter 26. I do. When the command decode circuit 23 decodes the Copy command or the Repeat command, the number of pixels to be processed, which is output from the command decode circuit 23, is stored in the lower part of the counter 26. When the command decode circuit 23 decodes the EOL command, the subtraction circuit 34
Are stored in the upper and lower bits of the counter 26.

The copy output circuit 27 controls copying, and
The command decode circuit 23 outputs a copy command or E
When the OL command is decoded, a copy signal is received from the command decode circuit 23, and the copy process is performed the number of times specified by the number of processing pixels stored in the counter 26. Specifically, pixel data immediately above the target pixel, that is, data stored in the line buffer 33 at the position indicated by the address counter 31, is output as decoded data.

The repeat output circuit 28 controls the repetition. When the command decode circuit 23 decodes the Repeat command, the repeat output circuit 28 receives a repeat signal from the command decode circuit 23 and is designated by the number of processing pixels stored in the counter 26. It repeats the process for the number of times. Specifically, pixel data immediately before the target pixel, that is, data stored in the data register 30 is output as decoded data.

The data output circuit 29 controls the pixel difference data, and the command decode circuit 23 controls the PixelDi
When the ff command is decoded, a pixel difference signal is received from the command decode circuit 23, and the pixel data immediately before the pixel of interest, that is, the sum of the data stored in the data register 30 and the received pixel difference data is used as decoded data. Output.

The data register 30 stores the copy output circuit 2
7. Repeat output circuit 28 or data output circuit 29
Each time the decrypted data is output from, the output decrypted data is stored. As a result, the immediately preceding pixel data is stored in the data register 30. The data register 30 is set to 0 when the power is turned on, and receives the EOB signal from the command decode circuit 23 and stores 0 when the command decode circuit 23 decodes the EOB command. As a result, when each block of the code data starts, 0 is stored in the data register 30.

The line buffer 33 holds at least one line of decoded data. The decoded data is output from the copy output circuit 27, the repeat output circuit 28, or the data output circuit 29 to the current address held by the address counter 32. Each time the data is output, the output decoded data is stored. As a result, the line buffer 33 stores the decoded data of the immediately preceding line.

The address counter 32 holds the current address of the line buffer 33, and
7. Repeat output circuit 28 or data output circuit 29
The count is incremented each time the decoded data is output from. The result is that when the number of pixels of one line held by the line length register 33 has been reached, the count returns to zero. The line length register 33 holds the number of pixels of one line, which is output by the control circuit 15 in advance.

The subtraction circuit 34 is a command decoding circuit 2
3 decodes the EOL command, receives the EOL signal from the command decode circuit 23, calculates the difference between the line length register 33 and the address counter 32, and outputs the difference to the counter 26. The output buffer 35 stores the output decoded data every time the decoded data is output from the copy output circuit 27, the repeat output circuit 28, or the data output circuit 29. The output buffer 35 also outputs the stored decoded data when the printer engine 14 requests output of image data.

When the command decode circuit 24 decodes the EOL command, the difference between the line length register 33 and the address counter 32 calculated by the subtraction circuit 34, that is, the number of pixels from the target pixel to the end of the line is stored in the counter 26. The copy output circuit 27 includes an address counter 2
3, the data in the line buffer 33, that is, the pixel data immediately above, is read and stored in the output buffer 35 and the data register 30. The address counter 32 counts up, and the counter 26 counts down.
In this way, the output of the restored data is performed until the counter 26 reaches 0.

When the command decode circuit 24 decodes the copy command, the number of pixels indicated by the copy command is stored in the lower order of the counter 26. Counter 26
When the AddCount command does not precede, 0 is stored, and when the AddCount command precedes, the added value of the number of pixels indicated by the AddCount command is stored. The copy output circuit 27 reads the data of the line buffer 33 indicated by the address counter 23, that is, the pixel data immediately above, and stores the read data in the output buffer 35 and the data register 30. The address counter 32 counts up, and the counter 26 counts down. In this way,
Until the counter 26 reaches 0, output of restored data is performed.

The command decoding circuit 24
When the t command is decoded, the number of pixels indicated by the Repeat command is stored below the counter 26. When the AddCount command does not precede, the value of the counter 26 is 0.
The added value of the number of pixels indicated by the unt command is stored. The repeat output circuit 28 reads the immediately preceding data stored in the data register 30 and stores the data in the output buffer 35 and the data register 30. The address counter 32 counts up, and the counter 26 counts down. In this way, the output of the restored data is performed until the counter 26 reaches 0.

When the command decode circuit 24
When the Diff command is decoded, the data output circuit 2
9 adds the difference value between the immediately preceding pixel data indicated by the PixelDiff command and the immediately preceding data stored in the data register 30 and stores the result in the output buffer 35 and the data register 30. The address counter 32 is counted up.

<Second Embodiment> In the above-described first embodiment, decoding is performed using the hardware decoding circuit 13. However, the second embodiment is different in that the decoding is performed by software. . The reference numerals in the second embodiment are the same as those in the first embodiment.

FIG. 7 is a block diagram showing a configuration of the printer 6 according to the second embodiment. In the figure, a parallel port 11 receives a printer command from the computer 1. Since it is sufficient that data from the computer 1 can be received, not only the parallel port but also various interfaces (for example, USB, Ethernet (registered trademark), etc.)
May be adopted. A memory (RAM) 16 stores encoded data received by the parallel port 11 and stores image data decoded by the control circuit 15. The printer engine 14 is a laser beam printer engine, and performs printing in accordance with image data stored in the memory 16 according to an instruction from the control circuit 15.
The image data is output in plane order for each color of cyan, magenta, yellow, and black. Each color component constituting a pixel is 8
Each bit can represent 256 gradations. Reference numeral 15 denotes a control circuit, for example, one chip C
It is configured by a PU, controls the parallel port 11, the memory 12, and the printer engine 14, and decodes the encoded data stored in the memory 16 according to a decoding procedure described later.

FIG. 8 is an explanatory diagram of a data structure used when decoding a code. By examining the code string one bit at a time from the beginning, it is possible to determine which code it is.
A table having a tree structure shown in FIG. 8 is prepared in advance. This table can be stored in, for example, a read-only memory built in the control circuit 15. Each node constituting the tree structure has a child node 0 when the data bit is 0,
And two child nodes of child node 1 when the data bit is 1. However, the node corresponding to the end of the code has no child node.

First, the code string is read by one bit, and from the root node Root, if the read bit is 0, the child node is moved to child node 0, and if the read bit is 1, the child node is moved to child node 1; Is read out. This continues until the end of the code is reached. If the end of the code has been reached, the command corresponding to the code can be determined by, for example, referring to a number for identifying the command stored in the node. For example, if the code string is “000”, the tree structure is traced from the root to “000”.
Is reached at the time point when the node corresponding to the Copy1 command is read, the processing of the Copy1 command may be performed.

Next, the decoding procedure executed by the control circuit 15 will be described in detail with reference to the flowchart shown in FIG. When the control circuit 15 finishes receiving the encoded data of one block, it calls the decoding procedure shown in FIG.

First, an initialization process is performed in step S31. Specifically, an address counter, a data counter,
And the final data register are both set to 0. Next, in step S32, an index (pointer) indicating the current node is set to a root node. Next, one bit is read from the code string in step S33, and the bit read in step S34 is determined.

If the read bit is 0, step S
Proceed to 35 to set the index to child node 0. If the read bit is 1, the process proceeds to step S36, and the index is set to the child node 1. In any case, the process proceeds to step S37 to determine whether the node indicated by the index corresponds to the end of the command. If the node indicated by the index does not correspond to the end of the command, the process returns to step S33 to continue reading the code string. When the end of the command is reached in this way, the process proceeds from step S37 to step S38, and the type of the decoded command is determined.

If the decoded command is an EOL command, the number of pixels to be copied is calculated in step S39. Specifically, the value of the address counter is subtracted from the number of pixels in one line, and the result is set in the data counter. Next, in step S40, copying is performed from the immediately preceding line. Specifically, the number of pixels indicated by the data counter is copied and output from the position indicated by the address counter in the line buffer (which is previously secured in the memory 16), and 0 is stored in the data counter.
Is set, and the process proceeds to step S45.

If the decrypted command is a Copy command, copying is performed from the immediately preceding line in step S41. Specifically, the number of pixels to be copied indicated by the Copy command is added to the data counter, the number of pixels indicated by the data counter is copied and output from the position of the line buffer indicated by the address counter, and 0 is set to the data counter. Then, the process proceeds to step S45.

If the decoded command is a Repeat command, the immediately preceding data is repeatedly output in step S42. Specifically, the data counter has Re
The number of pixels to be copied indicated by the "peat" command is added, the value of the final data register is output by the number of pixels indicated by the data counter, and at the same time, the value is stored in the corresponding position of the line buffer. Step S
Proceed to 45.

If the decoded command is a PixelDiff command, it is added to the final data and output in step S44. Specifically, the difference value indicated by the PixelDiff command is added to the value of the last data register and output, and the process proceeds to step S45.

In step S45, the last output data is stored in the final data register, and the address counter is counted up according to the number of output pixels.
Here, when the address counter reaches the number of pixels of one line, 0 is stored. Next, returning to step S32, decoding of the next code is continued.

If the decoded command is an EOB command in step S38, the process returns.

In the above embodiment, a color image has been described as an example. However, it is needless to say that the present invention can be applied to monochrome (single color) printing. Also, an example in which one pixel or a color component of one pixel has eight bits has been described. However, the present invention is not limited to this, and may be expressed by four bits, for example.

Although an example in which the present invention is applied to a laser beam printer as a printer has been described, the printing method is not limited to this. For example, the present invention may be applied to a printer employing a type for discharging ink droplets or a thermal transfer type. Absent.

Further, in the first and second embodiments, the example in which the computer and the printer are directly connected has been described. However, since the computer and the printer can be connected via a network, the present invention can be realized. The connection form may be of any type.

As described in detail above, when losslessly compressing a multi-valued image, a high compression rate can be achieved, encoding and restoration can be performed at high speed, and a decompressor is constituted by hardware. In that case, it can be configured with small-scale hardware.

Further, the printer does not need to be equipped with an interpreter for interpreting a high-level page description language, so that the cost can be reduced and the amount of communication data can be reduced.

Further, the substance of the printer driver operating on the computer side is software, so that the present invention can also be realized by installing a program from outside the computer. The storage medium for supplying the program includes a medium such as a floppy disk or a CD. Naturally, if the program code for realizing the function of the printer driver after installation is stored, these storage mediums are also included in the present invention. included.

[0082]

As described above, according to the present invention, it is possible to losslessly code a multi-valued image at a high compression rate or to decode this code efficiently.

[Brief description of the drawings]

FIG. 1 is a system block configuration diagram in an embodiment.

FIG. 2 is a block diagram of a printer according to the embodiment.

FIG. 3 is a diagram showing a code table used in the embodiment.

FIG. 4 is a diagram illustrating a specific operation of encoding and decoding in the embodiment.

FIG. 5 is a flowchart illustrating an operation processing procedure of the printer driver according to the embodiment.

FIG. 6 is a block diagram of a decoding circuit on the printer side in the embodiment.

FIG. 7 is a block diagram of a printer according to a second embodiment.

FIG. 8 is a diagram illustrating a tree structure table used in a decoding process according to the second embodiment.

FIG. 9 is a flowchart illustrating a decryption processing procedure on the printer side according to the second embodiment.

[Explanation of symbols]

 1: Computer 2: Operating system 3: Application 4: Printer driver 5: Port driver 6: Printer 11: Parallel port 12: FIFO memory 13: Decoding circuit 14: Printer engine 15: Control circuit

 ────────────────────────────────────────────────── ─── Continued on front page F term (reference) 2C087 AC07 AC08 BA02 BA03 BA07 BA12 BD13 BD14 BD40 5B021 AA01 BB02 BB12 CC05 5C078 AA04 BA22 BA32 DA01 DA02 DB13 5J064 AA02 BA01 BB01 BC01 BC05 BD07

Claims (20)

[Claims] 1. An encoding device for encoding multivalued image data to be output, comprising: a continuous pixel encoding means for generating a code corresponding to the number of consecutive values of the immediately preceding pixel; A difference value encoding means for generating a code corresponding to a difference value for the preceding line; a previous line reference encoding means for generating a code indicating how many consecutive data are used from the same position in the scanning direction in the immediately preceding line; An encoding apparatus comprising: continuous pixel encoding means; the difference value encoding means; and output means for outputting a code generated by adaptively using the previous line reference encoding means. 2. The number of continuous pixels in the continuous pixel encoding means and the preceding line reference encoding means,
2. The coding apparatus according to claim 1, further comprising a pixel number correction coding unit that generates a code for performing a correction of an increment of a predetermined number of integral multiples. 3. The encoding apparatus according to claim 1, further comprising means for generating a code indicating that data up to the end of the immediately preceding line is used. 4. The code length generated by said difference value coding means is such that a code length is shorter in upper and lower limits within a possible range of a difference value. An encoding device according to any one of the preceding claims. 5. An encoding method for encoding multivalued image data to be output, comprising: a continuous pixel encoding step of generating a code according to the number of consecutive values of the immediately preceding pixel; A difference value encoding step of generating a code corresponding to a difference value for; a previous line reference encoding step of generating a code indicating how many consecutive data are used from the same position in the scanning direction in the immediately preceding line; A coding method comprising: a continuous pixel coding step; a difference value coding step; and an output step of outputting a code generated by adaptively using the previous line reference coding step. 6. The number of continuous pixels in the continuous pixel encoding step and the preceding line reference encoding step,
6. The encoding method according to claim 5, further comprising a pixel number correction encoding step of generating a code for correcting an increase by a predetermined integer multiple. 7. The encoding method according to claim 5, further comprising a step of generating a code indicating that data up to the end of the immediately preceding line is to be used. 8. The code length generated in the difference value encoding step is such that a code length is shorter in upper and lower limits within a range of a difference value. Item 7. The encoding method according to any one of the above items. 9. A program that functions as a device that encodes a multi-valued image by being read and executed by a computer, comprising: a continuous pixel encoding step of generating a code according to the number of consecutive values of the immediately preceding pixel. And a program code of a difference value encoding step for generating a code corresponding to a difference value with respect to the immediately preceding pixel, and a code indicating how many consecutive data are used from the same position in the scanning direction in the immediately preceding line. A program code of a preceding line reference encoding step to be generated; and an output step of outputting a code generated by adaptively using the continuous pixel encoding step, the difference value encoding step, and the preceding line reference encoding step. And a program code comprising: 10. A storage medium storing the program according to claim 9. 11. A decoding device for decoding a code from the encoding device according to claim 1 to generate a multi-valued image, comprising: a memory for storing decoded multi-valued data for a previous line; And a continuous pixel decoding means for generating a plurality of multi-valued pixel groups by successively generating the value of the immediately preceding pixel, and a difference value decoding means for decoding the multi-valued pixel by adding the difference value to the immediately preceding pixel according to the sign A preceding line reference decoding means for continuously generating a plurality of multi-valued pixels from the same position in the scanning direction in the immediately preceding line stored in the memory according to the code, the continuous pixel decoding means, and the difference value decoding Means for generating multi-valued pixel data by adaptively using the preceding line reference decoding means and outputting the same as multi-valued image data. 12. Further, according to an arrangement of bits of a given code string, a binary code for determining which of the continuous pixel decoding means, the difference value decoding means, and the preceding line reference decoding means should perform decoding. The decoding apparatus according to claim 11, further comprising a tree structure determination table. 13. A printing device capable of communicating with a computer, comprising a decoding device according to claim 11, decoding a code received from a host computer and printing it on a recording medium. A printing device, characterized by: 14. A decoding method for decoding into a multi-valued image based on data encoded by the encoding method according to claim 5, wherein a plurality of values of the immediately preceding pixel are continuously obtained according to the code. A continuous pixel decoding step of generating a multi-valued pixel group of; a difference value decoding step of decoding a multi-valued pixel by adding a difference value to the immediately preceding pixel according to the sign; and storing data of the previous line according to the sign. A preceding line reference decoding step of continuously generating a plurality of multi-valued pixels from the same position in the scanning direction in the immediately preceding line stored in the predetermined memory, the continuous pixel decoding step, the difference value decoding step, An output step of adaptively using the preceding line reference decoding step to generate multi-valued pixel data and outputting the same as multi-valued image data. 15. A binary code for determining which of the continuous pixel decoding step, the difference value decoding step, and the preceding line reference decoding step to decode in accordance with the arrangement of bits of a given code string. 15. The decoding method according to claim 14, wherein it is determined which one of the decoding steps is to be performed by referring to the tree structure determination table. 16. A printer driver which is installed in a computer and generates encoded print data for a printing device capable of communicating with the computer, wherein the printer driver generates a code corresponding to the number of consecutive pixels immediately before. The program code of the consecutive pixel encoding process that occurs, the program code of the difference value encoding process that generates a code corresponding to the difference value with respect to the immediately preceding pixel, and the data that is continuous from the same position in the scanning direction in the previous line are A program code of a previous line reference encoding step for generating a code indicating how many codes to use, and a code generated by adaptively using the continuous pixel encoding step, the difference value encoding step, and the previous line reference encoding step Characterized by comprising a program code of an output step of outputting the code obtained as data for the printing apparatus. Iba. 17. A pixel number correction encoding for generating a code for correcting an increase of a predetermined number by an integral multiple of a continuous number of pixels in the continuous pixel encoding step and the preceding line reference encoding step. 17. The printer driver according to claim 16, comprising a program code of a process. 18. The printer driver according to claim 16, further comprising a program code for generating a code indicating that data up to the end of the immediately preceding line is used. 19. The code length generated in the difference value encoding step is such that a code length is shorter in upper and lower limits within a range that the difference value can take.
Item 19. The printer driver according to any one of items 18 to 18. 20. A storage medium storing the printer driver program according to claim 16. Description: