JP2010074444A - Image compression apparatus and method, image decoding apparatus and method, and computer program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide an image compression apparatus and method for highly efficiently compressing the image data short in run length, in which the same pixel values in the raster order of images are continuous number, and to provide a computer program and an information recording medium. <P>SOLUTION: The image compression apparatus includes: a difference acquisition means for acquiring a difference between the pixel value of the pixel and a pixel value having a pixel index corresponding to each different pixel value for each pixel configuring the image; a pixel index means for selecting the pixel index corresponding to one pixel value on the basis of the difference for each pixel configuring the image; a run length acquisition means for acquiring the run length which is the number of the continuation of the pixels whose pixel index is the same in the raster order of the image; and an encoding means for encoding the selected pixel index, the difference and the run length. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to an image compression apparatus, an image compression method, an image decoding apparatus, an image decoding method, and a computer program.

  Conventionally, when image processing is performed in an image forming apparatus or the like, image data may be compressed when the image data is stored in a memory. As a result, a device configuration that does not require a large capacity memory can be obtained.

  For example, JBIG (Joint Bi-level Image Expert Group, ISO / IEC 11544), which is an international standard of a two-dimensional compression method for compressing binary images at a high compression rate, is well known. JBIG uses a QM_coder, which is an arithmetic encoder, as an entropy code. However, the QM_coder needs to be equipped with a context memory, a line memory for generating a context, and the like, and has a problem that the hardware cost is high and a high-speed process is difficult.

In addition, there is a lossless encoding mode of JPEG (Joint Photographic Expert Group, ISO / IEC 11172) that performs lossless encoding of multi-valued images. The JPEG lossless encoding mode is a method in which Huffman code or arithmetic code is combined with predictive encoding. More specifically, this method creates prediction error statistics with seven prediction formulas, selects one of the best prediction formulas, and compresses with the prediction encoding scheme. However, there is a problem that a high compression rate cannot be expected.
Incidentally, when compressing image data, there is a method of compressing image data by obtaining the number of consecutive identical pixel values in the raster order of the image data.

  For example, Japanese Patent Application Laid-Open No. 2003-198379 (Patent Document 1) describes an encoding method using the Move to Front method (hereinafter referred to as “MTF method”). In the encoding by the MTF method, it is considered that the previously appearing character has the highest probability of appearing this time among the already described characters. That is, like the block sort method, this is an encoding method that generates a long sequence (hereinafter referred to as “run”) in which the same characters are repeated. The MTF method is desired to have a particularly high effect on highly redundant data obtained by the block sort method such that “the same byte data is located close to each other”.

  Further, for example, Japanese Patent No. 3842914 (Patent Document 2) discloses a method of encoding a run length and the number of repetitions of the run length in a plurality of pixel units. Further, for example, in Japanese Patent Laid-Open No. 2005-27081 (Patent Document 3), by using the continuous number of target pixels and the continuous number of reference pixels, a part of the prediction process is omitted, and a process addition in the encoding process is added. Techniques such as an encoding device to be reduced are disclosed. Note that the “continuous number” of pixels in Patent Document 3 corresponds to “run length”.

JP 2003-198379 A Japanese Patent No. 3842914 JP 2005-27081 A

  However, the inventions disclosed in Patent Documents 1 and 2 are binary image compression methods and are not suitable for compressing multi-valued images such as RGB. In the invention disclosed in Patent Document 3, it is easy to predict the run length for a document image having a high correlation between lines. However, in a photographic image having a low correlation between lines, the color component It is difficult to predict each run length. In addition, since a photographic image generally has a short run length, it is desirable to compress the information amount of the pixel value itself rather than compression by the run length. However, the invention disclosed in Patent Document 3 considers such a case. Absent.

  The present invention has been invented in order to solve these problems in view of the above points. Image data having a short run length, which is the number of consecutive identical pixel values in the raster order of an image, is reduced. An object of the present invention is to provide an image compression apparatus, an image compression method, an image decoding apparatus, an image decoding method, a computer program, and an information recording medium that are efficiently compressed.

  In order to achieve the above object, the image compression apparatus of the present invention employs the following configuration.

The image compression device according to the present invention includes, for each pixel constituting the image, a difference acquisition unit that acquires a difference between a pixel value of the pixel and a pixel value having a pixel index associated with each different pixel value; A pixel index means for selecting a pixel index corresponding to one pixel value based on the difference for each pixel constituting the image, and a number of consecutive pixels having the same pixel index in the raster order of the image. It may be configured to include a run length acquisition unit that acquires a certain run length, and an encoding unit that encodes the selected pixel index, the difference, and the run length.
Accordingly, it is possible to provide an image compression apparatus that compresses image data with a short run length, which is the number of consecutive identical pixel values in the raster order of an image, with high efficiency.

  In order to solve the above problems, the present invention provides an image compression method in the image compression apparatus, a computer program for causing a computer to execute the image compression method, or an information recording medium on which the computer program is recorded. Also good.

  According to the image compression device, the image compression method, the image decoding device, the image decoding method, the computer program, and the information recording medium of the present invention, the run length that is the number of consecutive identical pixel values in the raster order of the image is short. It is possible to provide an image compression apparatus, an image compression method, an image decoding apparatus, an image decoding method, a computer program, and an information recording medium that compress image data with high efficiency.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings. In the following embodiments, “compression” of image data is also referred to as “encoding”, and “decompression” of compressed or encoded image data is also referred to as “decoding”. Further, the image data processed in the following embodiment has a “page” corresponding to one image, and a “band” that is a portion composed of a predetermined number of main scanning lines in the page.

Embodiment of the present invention
FIG. 1 is a diagram illustrating a configuration example of a mechanism unit of an image forming apparatus in which an image processing apparatus according to an embodiment of the present invention is mounted. In FIG. 1, a color printer 1 is shown as an image forming apparatus. The color printer 1 is a four-drum tandem engine type image forming apparatus that forms four-color (Y, M, C, K) images by independent image forming systems and synthesizes these four-color images.

(Block of electrical / control unit in color printer 1)
FIG. 2 is a block diagram illustrating a device configuration of the electrical / control unit in the color printer 1. 2 includes a printer ASIC 110, a printer engine 120, a main memory 130, and a CPU 190, and is connected to a personal computer (hereinafter referred to as “PC”) 900 via a network.

  The CPU 190 performs overall control of the color printer 1. The printer engine 120 forms an image on a medium and outputs it. The main memory 130 stores a drawing command output by the CPU 190, a program executed by the CPU 190, various data such as band data that is image data for each band of image data, compressed data for each page, and the like.

  The printer ASIC 110 performs predetermined processing on the input image data and outputs it to the printer engine 120. The printer ASIC 110 includes, for example, a CPU interface (hereinafter referred to as “I / F”) 112, a main memory arbiter 113, a main memory controller 114, an encoding unit 115, a decoding unit 116, an image processing unit 117, an engine controller 118, and And a communication processing unit 119.

  The CPU I / F 112 is connected to the main memory controller 114 via the main memory arbiter 113, and performs interface processing between the CPU 190 and the main memory controller 114. The main memory arbiter 113 manages the access order to the main memory 130 from the encoding unit 115, the decoding unit 116, the communication processing unit 119, and the CPU 190. The main memory controller 114 controls writing and reading of data to the main memory 130.

  The encoding unit 115 encodes, for example, band data among the image data stored in the main memory 130. The encoding unit 115 stores the encoded band data in a page memory area in which the encoded page of the main memory 130 is stored.

  The decoding unit 116 receives and decodes the code data encoded by the encoding unit 115. The decoding unit 116 outputs the decoded image data to the image processing unit 117. The decoding unit 116 performs the decoding process in synchronization with the processing speed of the printer engine 120.

  The image processing unit 117 performs predetermined image processing on the image data decoded by the decoding unit 116 and outputs the processed image data to the engine controller 118. The engine controller 118 controls the printer engine 120.

  The communication processing unit 119 is a communication controller, and receives image data from a PC 900 connected via a network. The image data has, for example, a PDL (page description language) format. The communication processing unit 119 outputs the received image data to the main memory 130.

(Outline of processing in the color printer 1)
FIG. 3 is a diagram showing an outline of processing in the color printer 1. In FIG. 3, input image data is analyzed, subjected to image processing, and then output to the printer engine 120. 3 includes PDL storage step S201, PDL analysis step S202, RGBA drawing processing step S203, RGBA band image storage step S204, RGBA encoding step S205, RGBA encoding step S205, RGBA page code storage step S206, RGBA decoding. Step S207 and image processing step S210 are included, and the processing of each step is executed in the order described above.

  In PDL storage step S <b> 201, the PDL output from the communication processing unit 119 is stored in the main memory 130. In the PDL analysis step S202, the CPU 190 reads the PDL from the main memory 130, analyzes the PDL, and outputs a drawing command to the RGBA drawing processing step S203.

  In RGBA drawing processing step S203, the CPU 190 draws a band image by the drawing command input from the PDL analysis step S202. In the RGBA band image storage step S204, the band image drawn in the RGBA drawing processing step S203 is stored in the main memory 130.

  In the RGBA encoding step S205, the encoding unit 115 reads and encodes the image stored in the RGBA band image storage step S204 from the area for storing the band image in the main memory 130, and generates code data. In the RGBA page code storage step S206, the code data generated in the RGBA encoding step S205 is stored in the main memory 130. The area where the code data is stored is, for example, an area where the page code of the main memory 130 is stored.

  In the RGBA decoding step S207, the decoding unit 116 reads the code data stored in the RGBA page code storage step S206 from the main memory 130 and decodes it. In the RGBA decoding step S207, the decoded image data is further output to the image processing step S210.

  The image processing step S210 includes an RGB → CMY color conversion processing step S211, a UCR processing step S212, and a gradation processing step S213, and the processing of each step is executed in the order described above. Each step of the image processing step S210 is executed by the image processing unit 117.

  In the RGB → CMY color conversion processing step S211, the color space of the image data in the RGB color space decoded in the RGBA decoding step S207 is converted into the CMY color space. In the UCR processing step S212, an under color removal process is performed on the pixel value of each pixel of the image data converted into the CMY color space. In the gradation processing step S213, gradation correction processing is performed on the image data that has undergone the undercolor removal processing.

  The image data subjected to the processing in each step in the image processing step S210 is output to the printer engine 120, and becomes an image formed on the medium in the printer engine 120.

(Storage area in main memory 130)
FIG. 4 is a diagram for explaining a storage area in the main memory 130. The main memory 130 of FIG. 4 has a program area 131, a PDL storage memory area 132, an RGBA band memory storage area 133, a page code storage area 134, and another area 135.

  In the program area 131, a computer program executed by the CPU 190 is expanded and stored. The PDL storage memory area 132 stores PDL data transmitted from the PC 900.

  The RGBA band memory storage area 133 stores RGBA band data. The RGBA band data is image data expressed in the RGBA color space, and is data for each band. The page code storage area 134 stores a plurality of pages of code data for each page. The code data for each page consists of code data in band units. The other area 135 stores, for example, various data that are not stored in the respective areas such as a drawing command.

(Relationship between storage areas in main memory 130 and electrical / control blocks of color printer 1)
FIG. 5 is a diagram for explaining the relationship between each storage area in the main memory 130 and the electrical / control blocks of the color printer 1.

  The PC 900 generates a PDL and transfers the PDL to the color printer 1 via the network. The communication processing unit 119 stores the PDL data received from the PC 900 in the PDL storage memory area 132 included in the main memory 130.

  The CPU 190 reads the PDL data stored in the PDL storage memory area 132 and generates a drawing command. The generated drawing command is stored in a drawing command area (not shown) on the main memory. The CPU 190 further generates band data according to the drawing command stored in the drawing command area. The generated band data is stored in the RGBA band memory storage area 133.

  The encoding unit 115 performs encoding for each band data stored in the RGBA band memory storage area 133 to generate code data. The generated code data is stored in the page code storage area 134.

The decoding unit 116 decodes the code data stored in the page code storage area 134 and transfers the decoded image data to the image processing unit 117. The image processing unit 117 performs image processing such as color space conversion, undercolor removal, and gradation processing on the decoded image data in the RGBA color space. The image processing unit 117 causes the engine controller 118 to transfer the image data subjected to the image processing.
The engine controller 118 transfers the received image data to the printer engine 120.

(Functional configuration of encoding unit 115)
FIG. 6 is a block diagram illustrating a functional configuration of the encoding unit 115. 6 reads and encodes the band data stored in the RGBA band memory storage area 133 of the main memory 130, and outputs the code data to the page code storage area 134 of the main memory 130. To do.

  The encoding unit 115 includes an image reading unit 501, a run length generation processing unit 502, a repetition processing unit 503, a dictionary conversion unit 504, a difference generation processing unit 505, a code format generation processing unit 506, and a code writing unit 507.

  The image reading unit 501 reads band data in the RGBA color space from the RGBA band memory storage area 133. Band data is read for each scan line. FIG. 7 is a diagram for explaining that band data is read for each scan line. In FIG. 7, the band data has a band width (M + 1) and a band height (N + 1). That is, the band data includes (M + 1) pixels in the main scanning direction and (N + 1) lines in the sub-scanning direction. The image reading unit 501 reads pixels from the pixel 0 of the line 0 to M in order. The process of reading (M + 1) pixels for each line is repeated up to line N.

  The run length processing unit 502 converts the band data composed of the RGBA color space read by the image reading unit 501 into data of run lengths of RGB values in the reading order of FIG. More specifically, a run length that is the number of consecutive pixels having the same RGB value in the reading order of FIG. 7 is acquired.

  FIG. 8 is a diagram for explaining the details of the run length generation process. FIG. 8 shows an example of processing for counting the number of consecutive pixels having the same RGB value in one line. More specifically, when the pixel values from pixel 0 to pixel 2 are the same, the run length is set to 3, and the RGB values are acquired in association with each other. Similarly, if the pixel values from pixel 3 to pixel 5 are the same, the run length is set to 3.

  Returning to FIG. 6, the iterative processing unit 503 performs iterative processing on the run-length data generated by the run-length generation processing unit 502. FIG. 9 is a diagram illustrating the repetition process. In FIG. 9, the number of repetitions of the same run length in one line is counted. More specifically, when pixel 0 and pixel 1 have the same pixel value, and pixel 2 and pixel 3 have the same pixel value different from pixel 0, the run length corresponding to pixel 0 and pixel 1 Is 2, and the run length corresponding to the pixel 2 and the pixel 3 is 2.

  In order to simplify the following description, the run-length data corresponding to the pixel 0 and the pixel 1 is (A), and the run-length data corresponding to the pixel 2 and the pixel 3 is (B). The run length data (A) has the same pixel value as that of the pixel 0 and information of the run length 2. The run length data (B) has the same pixel value and run length 2 information as the pixel 2.

Next, the pixel values of the pixel 4, the pixel 5, the pixel 8, the pixel 9, the pixel 12, and the pixel 13 are the same as the pixel 0, and the pixel values of the pixel 6, the pixel 7, the pixel 10, and the pixel 11 are the same. However, the run length data (A) and the run length data (B) are alternately and continuously connected by being the same as the pixel 2. That is, the continuous number of run-length data in which run-length data (A) and run-length data (B) are alternately connected starting from the pixel 4 is 5. This 5 is the number of repetitions.
The repetition processing unit 503 outputs the generated number of repetitions and the corresponding run length data to the dictionary conversion unit 504.

  The dictionary conversion unit 504 converts the run-length data output from the repetition processing unit 503 into a pixel index based on a dictionary. This process may be performed by a FIFO method. FIG. 10 is a diagram illustrating an example of processing performed by the dictionary conversion unit 504. In FIG. 10, when the same value as the input one RGBA value a is stored in the RGBA dictionary, the index value 3 associated with the RGBA dictionary is output.

  On the other hand, in the dictionary conversion unit 504, when the pixel value corresponding to the input pixel value is not stored in the RGBA dictionary, processing by the difference generation processing unit 505 is performed. FIG. 11 is a diagram illustrating an example of processing by the difference generation processing unit 505, and is an example in the case where pixel values corresponding to input pixel values are not stored in the RGBA dictionary. In FIG. 11, if the same value as the RGBA value b at the input position is not stored in the RGBA dictionary, the difference from each pixel value stored in the RGBA dictionary is calculated. Of each difference, an index value corresponding to the pixel value having the smallest value is output as an index value for the RGBA value b, and further, a difference corresponding to the index is output.

  Returning to FIG. 6, the code format generation processing unit 506 outputs the index value output from the dictionary conversion unit 504, the index value and difference output from the difference generation processing unit 505, and the run length output from the repetition processing unit 503. Code data is generated based on the repetition number.

  FIG. 12 is a diagram for explaining the format of code data. The code format of FIG. 12 includes a bit length and a value for each information of the control code c, the data body, run-length data d, repetition e, color value f, index g, and difference h. The range is shown.

  The control code c includes each code of a pixel header, a pixel difference header, an index header, an index difference header, and a code end. The pixel header is a header for the code rule of the pixel header, the run length, and the color value. The index header is a header for an index header, a run length, and an index code rule. The pixel difference header is a header for the code rule of the pixel difference header, the run length, and the difference value. The index difference header is a header for the code rule of the index header, the run length, the index, and the difference value. The code end represents the end of the code.

  The run-length data d is a code for the run length when pixels having the same RGBA pixel value continue. The run length data d is expressed as a set of run length and pixel value. In the run-length data d, a short 4-bit L1 code expresses run lengths from 1 to 8. The 8-bit L2 code expresses run lengths of 9-40. L3 is a code that becomes longer in steps, and expresses run lengths from 41 to 1048576.

The repetition e is a code of the number of repetitions when two run-length data are alternately continued. The repetition e is expressed as a combination of a plurality of run-length codes and repetitions. A short 4-bit N1 code represents repetition 1, and an N2 code represents repetition 2. N3 is a code that becomes longer in steps, and can represent a repetition of 3 to 1048576.
The color value f is RGB value data in the run-length data.

The index g is an index value held in the dictionary, and a short 4-bit I1 code represents 1 to 8 of the index value. Further, the 8-bit I2 code can express index values of 9 to 136.
The difference value h is a difference between the contents of the dictionary shown in FIG. 11 and the run-length RGBA value. The difference value h may be a difference from the previous run-length RGBA.

  FIG. 13 is a diagram illustrating an example of the configuration of code data. FIG. 13A is a diagram showing an overall configuration of code data. In FIG. 13A, the code has an internal code and a code end. The code end is a code representing the end of the code.

  FIG. 13B is a diagram illustrating an example of the configuration of the internal code. In FIG. 13B, the respective symbols are connected. In FIG. 13B, the number enclosed in parentheses is a number indicating the priority of encoding. More specifically, in (1), if there is a repetition, the repetition value is encoded, and if not, the process proceeds to (2). In (2), if there is a run-length RGBA value in the dictionary, Index encoding is performed. Otherwise, the process proceeds to (3).

  In (3), if the pixel difference from the previous run-length RGBA is smaller than the difference upper limit value, encoding is performed using the pixel difference; otherwise, the process proceeds to (4). In (4), if the difference between the dictionary and the run-length RGBA is smaller than the difference upper limit value, encoding is performed using the Index difference, and if not, the process proceeds to (5). In (5), run-length RGBA is encoded. After all the images are encoded, the code end is encoded in (6).

  When a pixel value that is not included in the RGBA dictionary is input under a predetermined condition, the code format generation unit 506 generates an index value corresponding to the pixel value, and registers the index value in the dictionary. May be updated. FIG. 14 is a diagram illustrating that when the input RGBA pixel value j is not included in the RGBA dictionary, the pixel value j is registered in the RGBA dictionary. In the figure, the pixel value j is registered at the location marked with the symbol k, and the RGBA dictionary is updated.

  Returning to FIG. 6, the code writing unit 507 stores the code data generated by the code format generation unit 506 in the page code storage area 134 of the main memory 130.

(Functional configuration of encoding unit 115)
FIG. 15 is a block diagram illustrating a functional configuration of the decoding unit 116. The decoding unit 116 reads code data stored in the page code storage area 134 of the main memory 130 and outputs image data obtained by decoding to the main memory 130.

  The decoding unit 116 includes a code reading unit 601, a code format analysis unit 602, a difference processing unit 603, a dictionary conversion unit 604, an iterative processing unit 605, a run length decoding processing unit 606, and an image writing unit 607.

  The code reading unit 601 reads code data from the page code storage area 134. The code format analysis unit 602 analyzes the code data read by the code reading unit 601, acquires values such as run length, repetition, color value, index, and difference, and outputs them to the difference processing unit 603. To do.

  The difference processing unit 603 adds the difference value acquired by the code format analysis unit 602 and the color value in the previous run, and obtains the RGB value in the run. The difference processing unit 603 also obtains an RGB value from the index.

  FIG. 16 is a diagram for explaining the decoding process by the difference processing unit 603, and is an example of decoding by an index. In FIG. 16, RGBA values corresponding to the index values held in the RGBA dictionary are output for the indexes acquired by the code format analysis unit 602. In FIG. 16, the output RGBA value and the difference acquired by the code format analysis unit 602 are added, and the RGBA value corresponding to the run is output.

  The dictionary conversion unit 604 performs dictionary conversion processing. When the RGBA value is obtained by the difference processing unit 603, the dictionary conversion unit 604 adds the value to the RGBA dictionary. The dictionary conversion unit 604 also obtains an RGBA value corresponding to the index when the run-length data obtained by the code format analysis unit 602 does not include a difference. FIG. 17 is a diagram for explaining processing for obtaining RGBA values corresponding to indexes. In FIG. 17, RGBA values associated with the code index, which is an index acquired from the code data, by the RGBA dictionary are output. The RGBA value is output to the repetition processing unit 605.

  The iterative processing unit 605 generates run-length data from the repetition value and the run length acquired by the code format analysis unit 602, and transfers the run-length data to the run-length decoding processing unit 606.

  FIG. 18 is a diagram for explaining repetitive decoding processing in the repetitive processing unit 605. FIG. 18 shows code data having a repetition value of 5 following the run length data of the pixel value v1 of the run length 2 and the pixel value v2 of the run length 2. By decoding the portion of the repeated value 5, a total of five image data in which the run of the pixel value v1 having the run length 2 and the run of the pixel value v2 having the run length 2 are alternately obtained.

Returning to FIG. 15, the run-length decoding processing unit 606 determines a pixel value for each pixel based on the RGBA value obtained by the dictionary conversion unit 604, and draws an image. FIG. 19 is a diagram illustrating a decoding process performed by the run-length decoding processing unit 606. In FIG. 19, the pixel value v4 of run length 3 is repeated twice, followed by the pixel value v5 of run length 4, the pixel value v6 of run length 4, and the like. The run-length decoding processing unit 606 decodes the code data to determine a pixel value for each pixel of the line m. The decoded image data is transferred to the image writing unit 607.
Note that the iterative processing unit 605 and the run-length decoding processing unit 606 may be configured as one processing unit.

  The image writing unit 607 stores the image data decoded by the run length decoding processing unit 606 in the main memory 130. The image data is stored in the RGBA band memory storage area 133, for example.

(Data input / output in each unit of the encoding unit 115)
FIG. 20 is a diagram for explaining input / output of data in each unit included in the encoding unit 115. 20 includes an image reading unit 501, a run length generation processing unit 502, a repetition processing unit 503, a dictionary conversion unit 504, a difference generation processing unit 505, a code format generation processing unit 506, a code writing unit 507, and a difference. An upper limit storage unit 508, a memory arbiter interface (hereinafter referred to as “memory arbiter I / F”) 509, an image address generation unit 511, and a code address generation unit 517 are included. 20, each unit having the same function and configuration as the encoding unit 115 in FIG. 6 is assigned the same reference numeral, and the description thereof is omitted here.

  The memory arbiter I / F 509 is an interface for inputting / outputting data to / from the main memory arbiter 113. The memory arbiter I / F 509 designates an address with respect to the main memory 130 and reads and writes data. The memory arbiter I / F 509 outputs an R / W signal indicating whether to perform read or write processing on the main memory.

  The image address generation unit 511 generates an image data address in the main memory 130. The image address generation unit 511 generates an address of band data when the image reading unit 501 reads out the band data stored in the RGBA band memory storage area 133 of the main memory 130. The generated address is output to the image reading unit 501. In FIG. 20, the address on the main memory is expressed as “memory address”.

  The image reading unit 501 receives an address from the image address generation unit 511 and outputs the address to the memory arbiter I / F 509. The image reading unit 501 acquires image data that is band data via the memory arbiter I / F 509. The image reading unit 501 outputs the acquired image data to the run length generation processing unit 502. The image data is image data in the RGBA color space, and is represented as RGBA data in the drawing.

  The run length generation processing unit 502 receives RGBA data from the image reading unit 501 and outputs a run length value and RGBA data to the repetition processing unit 503. The repetition processing unit 503 receives the run length value and the RGBA data from the run length generation processing unit 502, and outputs the repetition value, the run length value, and the RGBA data to the dictionary conversion unit 504. The run length generation processing unit 502 and the iterative processing unit 503 may be configured as one processing unit.

  The dictionary conversion unit 504 receives the repetition value, the run length value, and the RGBA data from the repetition processing unit 503, and inputs the dictionary data, the index, the repetition value, the run length value to the difference processing unit 505. And RGBA data is output.

  The difference processing unit 505 receives dictionary data, an index, a repetition value, a run length value, and RGBA data from the dictionary conversion unit 504. The difference processing unit 505 outputs difference data, an index, a repetition value, a run length value, and RGBA data to the code format generation unit 506.

  The difference upper limit storage unit 508 holds the upper limit value of the difference between the input pixel value and the pixel value held in the RGBA dictionary. That is, when the difference value between the input pixel value and the pixel value held in the RGBA dictionary is equal to or larger than the value held in the difference upper limit storage unit 508, the input pixel value is Newly registered. The difference upper limit storage unit 508 outputs the upper limit value of the difference to the code format generation unit 506.

  The code format generation unit 506 receives the difference data, the index, the repetition value, the run length value, and the RGBA data from the difference processing unit 505, and receives the upper limit value of the difference from the difference upper limit storage unit 508. The The code format generation unit 506 outputs code data to the code writing unit 507.

  The code address generation unit 517 generates an address of code data in the main memory 130. The code address generation unit 517 generates an address of code data when the code writing unit 507 causes the code data to be written in the page code storage area 134 of the main memory 130. The code address generation unit 517 outputs the generated address to the code writing unit 507.

  The code writing unit 507 receives code data from the code format generation unit 506, and receives an address when the code data is stored in the main memory 130 from the code address generation unit 517. The code writing unit 507 outputs an address and code data to the main memory 130 via the memory arbiter I / F 509.

(Encoding process flow)
FIG. 21 to FIG. 23 are flowcharts for explaining an example of the encoding process in the encoding unit 115. FIG. 21 is an example of processing in the run length generation processing unit 502 and the repetition processing unit 503. In step S101, a line initial value flag indicating the start of processing is initialized to 1. Progressing to step S102 following step S101, the repeat value is set to zero.

  Progressing to step S103 following step S102, the image reading unit 501 acquires the value of the first pixel of the first line of the RGBA data read from the main memory 130, and sets it as the value of the variable RGBADATA. Note that in the second and subsequent steps S103, the value of the pixel next to the pixel whose value was acquired in the previous step S103 in the RGBA data read from the main memory 130 is set as the value of the variable RGBADATA.

  Following step S103, the process proceeds to step S104. If the line initial value flag is 1, a determination is made to proceed to step S105. If the line initial value flag is not 1, the process proceeds to step S107. The

  In step S105 subsequent to step S104, a value twice as large as the value of RGBADATA acquired in step S103 is substituted for the value of variable ORG. An operation that is level-shifted to a positive number when calculating the difference value between adjacent pixels in the process of obtaining the run length by using a value that is twice the RGBADATA value as the value of the variable ORG. Processing can be performed. Progressing to step S106 following step S105, the initial value flag of the line is set to 0. After step S106, the process returns to step S103 to repeat the process.

  On the other hand, in step S107 following step S104, it is determined whether or not the value of the variable ORG is twice the value of RGBADATA acquired in step S103. If it is not double, the process proceeds to step S108, and if it is double, the process proceeds to step S109.

  In step S108 following step S107, the run length value is incremented by one. On the other hand, in step S109 subsequent to step S107, it is determined whether or not the run length value in the previous run is equal to the run length value in the current run, and further, RGBADATA in the second run is determined. A determination is made whether the value and the RGBADATA value in the current run are equal. In the above two determinations, if both are “equal”, the process proceeds to step S110, and if not, the process proceeds to the process of FIG.

  In step S110 following step S109, the repeat value is incremented by one. Progressing to step S111 following step S110, the value of the variable ORG is set to twice the value of RGBADATA in the current run.

  Proceeding to step S112 following step S111, the run length in the previous run is set as the run length in the previous run, and the RGBADATA value in the previous run is further changed in the previous run. The value is RGBADATA. Progressing to step S113 following step S112, the run length in the previous run is the run length of the current run, and the RGBADATA value in the previous run is the RGBADATA value in the current run. . After the process of step S113, the process returns to step S103 to repeat the process.

  FIG. 22 is a diagram illustrating processing in the dictionary conversion unit 504, the difference processing unit 505, and the code format generation unit 506. Step S114 in FIG. 22 is performed subsequent to step S109 when it is determined that “both are equal” in the process of step S109 in FIG.

  In step S114, it is determined whether the repetition value is greater than zero. If it is greater than 0, the process proceeds to step S115, and if not, the process proceeds to step S116. In step S115 following step S114, the repeated value is encoded in accordance with the code format shown in FIGS. In the following description of FIGS. 22 and 23, the code formats are all shown in FIGS.

  In step S116 following step S114 or step S115, it is determined whether or not the RGBADATA value is included in the dictionary. If it is included in the dictionary, the process proceeds to step S117. If it is not included in the dictionary, the process proceeds to step S121.

  In step S117 subsequent to step S116, an index value corresponding to the RGBADATA value included in the dictionary is acquired. Progressing to step S118 following step S117, the index header is encoded according to the code format. Progressing to step S119 following step S118, the run length is encoded according to the code format. Progressing to step S120 following step S119, the value of the index is encoded according to the code format.

  On the other hand, in step S121 following step S116, a pixel difference value that is the difference between the RGBADATA value in the previous run and the RGBADATA value in the current run is acquired. Progressing to step S122 following step S121, it is determined whether or not the pixel difference value acquired in step S121 is smaller than a predetermined value. This determination may be a determination as to whether or not the value is equal to or greater than a predetermined value. If it is smaller than the predetermined value, the process proceeds to step S123. If it is not smaller than the predetermined value, the process proceeds to step S126.

  In step S123 following step S122, the pixel difference header is encoded according to the code format. Progressing to step S124 following step S123, the run length is encoded according to the code format. Progressing to step S125 following step S124, the pixel difference value is encoded according to the code format.

  On the other hand, in step S126 following step S122, a difference value that minimizes the difference between the plurality of pixel values held in the dictionary and the RGBADATA value is acquired. Progressing to step S127 following step S126, it is determined whether or not the minimum difference value acquired in step S126 is smaller than a predetermined upper limit value. If it is smaller, the process proceeds to step S128. If it is not smaller, the process proceeds to step S131.

  In step S128 following step S127, the dictionary difference header is encoded according to the code format. Progressing to step S129 following step S128, the run length is encoded according to the code format. Progressing to step S130 following step S129, the pixel difference value is encoded according to the code format.

On the other hand, in step S131 following step S127, the pixel header is encoded according to the code format. Progressing to step S132 following step S131, the run length is encoded according to the code format. Progressing to step S133 following step S132, the pixel difference value is encoded according to the code format. Progressing to step S134 following step S133, the current RGBADATA value is added to the pixel value of the dictionary.
After the processing of step S120, step S125, step S130, and step S134, the process proceeds to the processing of FIG.

  In FIG. 23, the process of updating the run length value and the like is performed before proceeding to the next run. The process of step S135 in FIG. 23 is performed subsequent to step S120, step S125, step S130, and step S134 in FIG. In step S135, the run length value of the previous run is updated to the run length value of the previous run, and the RGBADATA value of the previous run is the RGBADATA value of the previous run. Updated to

  Proceeding to step S136 following step S135, the run length value of the previous run is updated to the run length value of the current run, and the RGBADATA value of the previous run is updated to RGBADATA of the current run. Is updated to the value of. Proceeding to step S137 following step S136, the value of variable ORG is set to twice the value of RGBADATA for the current run.

  Progressing to step S138 following step S137, it is determined whether or not the processing for all the pixels has been completed. If the process for all the pixels has been completed, the process proceeds to step S139. If the process has not been completed, the process returns to step S103 in FIG. 21 to repeat the process. In step S139 following step S138, the code end is encoded according to the code format.

(Example of hardware configuration of dictionary conversion unit 504 in encoding unit 115)
FIG. 24 is a diagram for explaining an example of the hardware configuration of the dictionary conversion unit 504 in the encoding unit 115. The dictionary conversion unit 504 in FIG. 24 includes registers 10a to 10f, comparators 11a to 11f, an index generation unit 13, an OR calculator 14, a register 15, a register 16, and a control unit 17.

  The registers 10a to 10f receive the RGBA value data of the run input from the repetition processing unit 503 and store it as dictionary data. The comparators 11 a to 11 f compare the dictionary data stored in the registers 10 a to 10 f with the RGBA value data in the run RGBA data from the repetitive processing unit 503, respectively. By providing a plurality of comparators, comparison processing can be performed in parallel.

  The result of the comparison is determined by the OR calculator 14 and further transferred to the index generation unit 13. As a result, for the input RGBA value data, an index is generated and an index is associated by determining whether the pixel value corresponding to the already generated index matches.

  FIG. 25 is a diagram illustrating processing for generating an index in the index generation unit 13. In FIG. 25, the comparison result is determined for each RGBA value held in the dictionary with respect to the input RGBA value. More specifically, in step S11, a match with the pixel value corresponding to the first index is determined. If they match, an index value of 0 is set for the input RGBA value. If they do not match, the process proceeds to step S12 and subsequent steps for determining whether or not the corresponding pixel values match for each index held in the dictionary, and for associating the indexes corresponding to the matching pixel values. Processing.

  By this processing, it is possible to perform association based on the priority order among the indexes registered in the dictionary. By the association process, the index value corresponding to the matching pixel value is output as the matching index value.

  Returning to FIG. 24, the OR calculator 14 determines whether there is a match between the input RGBA value and the RGBA value held in the dictionary based on the comparison results from the comparators 11a to 11f.

  The register 15 temporarily holds a repetition value input from the repetition processing unit 503. The register 16 temporarily holds the run length value input from the repetition processing unit 503. The control unit 17 controls the index generation unit 13 based on the determination result from the OR calculator 14.

(Example of hardware configuration of difference generation processing unit 505)
FIG. 26 is a diagram illustrating an example of a hardware configuration of the difference generation processing unit 505. The difference generation processing unit 505 includes a register 20, a subtracter 21, subtracters 22a to 22f, a minimum value selection unit 23, and registers 24 to 26.

  The register 20 stores the RGBA value in the previous run. The subtracter 21 obtains a difference between the RGBA value in the current run and the RGBA value in the previous run. The subtractors 22a to 22f obtain the difference between the RGBA value stored in the dictionary and the RGBA value of the current run. By having a plurality of subtractors, subtraction processing can be performed in parallel. Each difference as a result of the subtraction is output to the minimum value selection unit 23.

  The minimum value selection unit 23 compares the outputs from the subtractors 22a to 22f, selects the minimum difference value, and acquires an index corresponding to the pixel value based on the difference value from the dictionary.

  The registers 24 to 26 temporarily hold the value of a predetermined variable among the values output from the dictionary conversion unit 504. The register 24 temporarily holds an index value that matches the RGBA value. The register 25 temporarily holds a repeated value. The register 26 temporarily holds the run length value.

  FIG. 27 is a flowchart illustrating processing for acquiring an index from a difference. In step S31 of FIG. 27, the difference result 0 output from the subtractor 22a is compared with the difference result 1 output from the subtractor 22b. If the difference result 0 is greater than the difference result 1, the process proceeds to step S32. If not, the process proceeds to step S33.

  In step S32 following step S31, the difference result 1 is substituted for the dictionary difference data value that is a variable, and the value 1 is substituted for the difference index data value that is a variable. On the other hand, in step S33 following step S31, the difference result 0 is substituted for the dictionary difference data value, and the value 0 is substituted for the difference index data value.

  In step S34 following step S32 or step S33, the dictionary difference data value is compared with the difference result 2 output from the subtractor 22c. If the difference result 2 is smaller, the process proceeds to step S35, and if not, the process proceeds to step S36. In step S35, the dictionary difference data value and the difference index data value are respectively updated to values corresponding to the difference result 2. Following step S35, the process proceeds to step S36.

  In the following steps, the dictionary difference data value and the difference index data value are updated based on the comparison between the difference result output from each subtracter and the dictionary difference data value. After the processing based on the difference results output from all the subtracters is performed, the value of the dictionary difference data value is output as the minimum difference, and the difference index data value corresponding to the difference is output.

  Returning to FIG. 26, the register 24 temporarily holds the index value output from the dictionary conversion unit 504. The register 25 temporarily holds a repeated value output from the dictionary conversion unit 504. The register 26 temporarily holds the run length value output from the dictionary conversion unit 504.

(Data input / output in each unit of the decoding unit 116)
FIG. 28 is a diagram for explaining input / output of data in each unit of the decoding unit 116. 28 includes a code reading unit 601, a code format analysis unit 602, a difference processing unit 603, a dictionary conversion unit 604, an iterative processing unit 605, a run length decoding processing unit 606, an image processing unit I / F 609, and A code address generation unit 611 is included. In FIG. 28, each unit having the same function and configuration as the decoding unit 116 in FIG. 15 is assigned the same reference numeral, and description thereof is omitted here.

  The code address generation unit 611 generates an address when the code reading unit 601 reads code data from the main memory 130. The address generated by the code address generation unit 611 is output to the code reading unit 601.

  The code reading unit 601 receives an address for the main memory 130 from the code address generation unit 611. The code reading unit 601 outputs to the main memory arbiter 113 an input address and an R / W signal that designates either reading or writing processing for the main memory 130. The code reading unit 601 acquires code data from the page code storage area 134 of the main memory 130 via the main memory arbiter 113. The code reading unit 601 further outputs the acquired code data to the code format analysis unit 602.

  The code format analysis unit 602 receives code data from the code reading unit 601. The code format analysis unit 602 outputs the run length value, the RGBA color value, the index value, the repetition value, and the difference value to the difference processing unit 603.

  The difference processing unit 603 receives the run length value, color value, index value, repetition value, and difference value from the code format analysis unit 602. The difference processing unit 603 further receives dictionary data of difference values in the RGBA color space from the dictionary conversion unit 604. This data may be input every time the dictionary conversion unit 604 performs processing for one run and the dictionary is updated. The difference processing unit 603 outputs the run length value, the dictionary data of the difference value in the RGBA color space, the difference value in the RGBA color space, and the repetition value to the dictionary conversion unit 604.

  The dictionary conversion unit 604 receives the run length value, the difference value dictionary data, the difference value in the RGBA color space, and the repetition value from the difference processing unit 603. The dictionary conversion unit 604 outputs a run length value, a color value, and a repetition value to the repetition processing unit 605. The dictionary conversion unit 604 further outputs the updated difference value dictionary data to the difference processing unit 603. This dictionary data corresponds to pixel values in the RGBA color space and has, for example, N elements.

The iterative processing unit 605 receives the run length value, color value, and repetition value from the dictionary conversion unit 604, and outputs the run length value and color value to the run length decoding processing unit 606. . The run length decoding processing unit 606 receives the run length value and the color value from the repetition processing unit 605. The run length decoding processing unit 606 outputs image data composed of the RGBA color space to the image processing unit I / F 609.
The image processing unit I / F 609 receives the image data from the run length decoding processing unit 606 and outputs the image data to the image processing unit 117.

(Example of processing of decoding unit 116)
FIG. 29 to FIG. 31 are flowcharts showing examples of processing in the decoding unit 116. In FIG. 29, the run length value and the like are acquired based on the input code data. The processing in FIG. 29 is executed by the code reading unit 601 and the code format analysis unit 602.

  In step S301 in FIG. 29, the code format analysis unit 602 acquires a code header from the code data. Progressing to step S302 following step S301, the code format analysis unit 602 determines the type of the code header acquired in step S301. If the code header is one of an index header, a dictionary difference header, a pixel header, or a pixel difference header, the process proceeds to step S303, and if not, the process proceeds to step S309.

  In step S303 following step S302, the code format analysis unit 602 reads the run length data of the code data. Proceeding to step S304 following step S303, the run length of the previous run is replaced with the run length of the previous run. Proceeding to step S305 following step S304, the run length of the previous run is replaced with the run length of the current run.

  Proceeding to step S306 following step S305, the RGBADATA value of the previous run is replaced with the RGBADATA value of the previous run. Progressing to step S307 following step S306, the RGBADATA value of the previous run is replaced with the RGBADATA value of the current run.

  Progressing to step S308 following step S307, the run length value and RGBADATA value are acquired from the run length data read in step S303. After the process of step S308, the process proceeds to the process of FIG.

  On the other hand, in step S309 following step S302, it is determined whether the code is a repetitive code based on the code header read in step S301. If it is a repetitive code, the process proceeds to step S310. If not, the process ends. When the process is terminated, the code is a terminal code.

  In step S310 following step S309, the code format analysis unit 602 reads the run length data of the code data. Progressing to step S311 following step S310, a repeated value is acquired from the run-length data. After the process of step S311, the process proceeds to the process of FIG.

  FIG. 30 is a flowchart illustrating processing performed by the code format analysis unit 602, the difference processing unit 603, and the dictionary conversion unit 604. The process in FIG. 30 is performed following the process in step S308 in FIG.

  In step S312 of FIG. 30, it is determined whether or not the code header is an index header. If it is an index header, the process proceeds to step S313; otherwise, the process proceeds to step S315.

  In step S313 following step S312, the code format analysis unit 602 acquires an index value from the run length data of the code data. Progressing to step S314 following step S313, the RGB value corresponding to the index value acquired in step S313 is acquired from the dictionary, and the value is set as the value of the variable RGBADATA. Subsequent to the process of step S314, the process proceeds to the process of FIG.

  On the other hand, in step S315 following step S312, it is determined whether or not the code header is a dictionary difference header. If it is a dictionary difference header, the process proceeds to step S316; otherwise, the process proceeds to step S320.

  In step S316 following step S315, the code format analysis unit 602 reads and acquires the index value from the run-length data of the code data. Progressing to step S317 following step S316, the RGB value corresponding to the index value acquired in step S316 is acquired from the dictionary, and the value is set as the value of the variable DRGBADATA.

  Progressing to step S318 following step S317, the code format analysis unit 602 acquires a difference value in the run-length data. Progressing to step S319 following step S318, the value of the variable RGBADATA is updated with a value obtained by adding the value of the difference acquired in step S318 to the value of DRGBADATA. After the process of step S319, the process proceeds to the process of FIG.

  In step S320 following step S315, it is determined whether the code header is a pixel header. If it is a pixel header, the process proceeds to step S321; otherwise, the process proceeds to step S322.

  In step S321 following step S320, the code format analysis unit 602 acquires a color value in the run-length data and substitutes the value into a variable RGBADATA. On the other hand, in step S322 following step S320, the code format analysis unit 602 acquires a difference value from the run-length data. Progressing to step S323 following step S322, the value of the variable RGBADATA is updated with a value obtained by adding the value of the difference acquired in step S322 to the value of RGBADATA in the previous run.

  In step S324 following step S321 or step S323, the dictionary is updated based on the newly acquired color value. After the process of step S324, the process proceeds to the process of FIG.

  FIG. 31 is a flowchart illustrating an example of decoding processing in the run-length decoding processing unit 606. In step S325 in FIG. 31, the value of the variable LOOP is set as the run length value. Progressing to step S326 following step S325, among the pixel data stored in the line memory, the value of RGBADATA is read from line 0 and output to the image processing unit I / F 609.

  Progressing to step S327 following step S326, 1 is subtracted from the value of the variable LOOP. Progressing to step S328 following step S327, it is determined whether or not the value of the variable LOOP is zero. If the value of the variable LOOP is 0, the process returns to step S301 in FIG. 29 to acquire new run length data and repeat the process. On the other hand, when the value of the variable LOOP is not 0, the process returns to step S326 and the process of outputting the RGBA value is repeated.

  FIG. 32 is a flowchart illustrating an example of processing in the repetition processing unit 605. Step S51 in FIG. 32 is performed following the processing in step S311 in FIG. In step S51, the value of the run length of the previous run is set with respect to the value of the variable LOOP.

  Progressing to step S52 following step S51, the value of RGBADATA in the previous run is acquired. Progressing to step S53 following step S52, 1 is subtracted from the value of the variable LOOP. Progressing to step S54 following step S53, it is determined whether or not the value of the variable LOOP is zero. When it is 0, it progresses to step S55, and when it is not 0, it returns to step S52 and repeats a process.

  In step S55 following step S54, the repetition value acquired from the run-length data is updated with a value obtained by subtracting 1 from the repetition value. Progressing to step S56 following step S55, it is determined whether or not the repeated value is zero. If the repeat value is 0, the process by the repeat processing unit 605 is terminated, and the process returns to step S301 in FIG. 29 to acquire new run length data and repeat the process. On the other hand, if the repeated value is not 0, the process proceeds to step S57.

  In step S57 following step S56, the value of the variable LOOP is set to the run length value of the previous run. Progressing to step S58 following step S57, the RGBA value of the previous run-length data is written to line 0 in the line memory.

  Progressing to step S59 following step S58, the value of the variable LOOP is updated with a value obtained by subtracting 1 from the value of the variable LOOP. Progressing to step S60 following step S59, it is determined whether or not the value of the variable LOOP is zero. When it is 0, it progresses to step S61, and when it is not 0, it returns to step S58 and repeats a process.

  Progressing to step S61 following step S60, the repeated value is updated with a value obtained by subtracting 1 from the repeated value. Progressing to step S62 following step S61, it is determined whether or not the repeated value is zero. If it is 0, the process of the iterative processing unit 605 is terminated, and the process returns to step S301 in FIG. If it is not 0, the process returns to step S51 to continue the repeated decoding process.

(Example of hardware configuration of difference processing unit 603)
FIG. 33 is a diagram illustrating an example of a hardware configuration of the difference processing unit 603 included in the decoding unit 116. The difference processing unit 603 includes a register 30, an adder 31, adders 32a to 32f, a selection unit 33, and registers 34 to 36.

The register 30 stores the RGBA value in the previous run. The adder 31 calculates the RGBA value in the current run by adding the difference to the RGBA value in the previous run. The adders 32a to 32f obtain the RGBA value of the current run by adding the input difference data, the RGBA value stored in the dictionary, and the input difference value. By having a plurality of adders, subtraction processing can be performed in parallel. The subtracted result is output to the selector 33.
The selection unit 33 compares the outputs from the adders 32a to 32f and selects the value of the addition result corresponding to the difference index value.

  The registers 34 to 36 temporarily hold a value of a predetermined variable among values output from the code format analysis unit 602. The register 34 temporarily holds an index value that matches the RGBA value. The register 35 temporarily holds a repeated value. The register 36 temporarily holds the run length value.

(Example of hardware configuration of dictionary conversion unit 604 in decoding unit 116)
FIG. 34 is a diagram for explaining an example of the hardware configuration of the dictionary conversion unit 604 in the decoding unit 116. The dictionary conversion unit 604 in FIG. 34 includes registers 40a to 40f, multiplexers 41 and 43, a control unit 42, a register 45, and a register 46.

  The registers 40a to 40f receive the RGBA value data of one or more previous runs input from the difference processing unit 603 and store it as dictionary data. The multiplexer 41 selects and outputs the dictionary data stored in the registers 40a to 40f according to the index value in the current run input from the difference processing unit 603. The control unit 42 controls processing for selecting dictionary data.

  The multiplexer 43 adds the RGBA value based on the dictionary data output from the multiplexer 41 and the difference value acquired by the code format analysis unit 602, and outputs the RGBA value of the current run. The multiplexer 43 also adds the RGBA value obtained by the difference processing output from the difference processing unit 603 and the difference value acquired by the code format analysis unit 602 and outputs the RGBA value of the current run. Which process is performed is determined by the code header.

  The register 45 temporarily holds a repeated value input from the difference processing unit 603. The register 46 temporarily holds the run length value input from the difference processing unit 603.

(Realization by computer)
FIG. 35 is a diagram illustrating the configuration of a computer that implements the image processing apparatus according to the embodiment of the present invention. 35 includes a main processing unit 400, an input device 410, a display device 420, a scanner 430, a plotter 440, a NIC 460, a drive device 480, a hard disk device 490, an input I / F 419, a display I / F 429, a scanner I / F 439, A plotter I / F 449, a drive I / F 489, and an HDD I / F 499 are included.

  The main processing unit 400 implements each function by executing a computer program. The main processing unit 400 includes, for example, a CPU 401, a ROM 408, and a RAM 409. The CPU 401 controls each device included in the computer by executing a computer program. The ROM 408 stores, for example, computer programs and parameters, and these are provided to the CPU 401. The RAM 409 is provided as a work memory when the CPU 401 executes a computer program, for example.

  The input device 410 is configured as an input device such as a keyboard or a mouse, for example, and inputs instructions to the computer. The display device 420 displays the status of the computer. The scanner 430 optically reads an image and generates image data. The plotter 440 forms an image on a medium and outputs it.

  The NIC 460 realizes an interface function when connecting a computer and the outside via a network and controls the interface. The drive device 480 inserts a recording medium, reads information recorded on the recording medium, and records information on the recording medium. The HDD 490 is a storage unit that stores a large amount of data.

  The input I / F 419, display I / F 429, scanner I / F 439, plotter I / F 449, drive I / F 489, and HDD-I / F 499 are an input device 410, display device 420, scanner 430, plotter 440, respectively. This is an interface when the drive device 480 and the HDD 490 are connected to the main processing unit 400 via a bus.

(Effect in this Embodiment)
When compressing image data based on a run length, which is the number of consecutive identical pixel values in the raster order of an image, the image compression apparatus in the present embodiment has a small run length and a pixel value as in a photographic image. When the amount of information by itself is large, compression can be performed more efficiently.

  More specifically, for example, the difference between a graphics image and a photographic image will be considered below. In general, a graphic image has a high correlation between a pixel of interest and a pixel adjacent to the pixel of interest when predictive coding is performed. Therefore, it is possible to perform compression with high efficiency by encoding the difference from the pixel of interest. On the other hand, since the correlation between the target pixel and the adjacent pixel is low in the photographic image, the efficiency of predictive encoding based on the difference is reduced.

  In the present embodiment, an index corresponding to the pixel value is held in the dictionary, and a difference from the pixel value in the dictionary is encoded. If the difference value is greater than or equal to a predetermined value, an index corresponding to the pixel value is generated and newly registered in the dictionary. Thereby, the pixel value having the index held in the dictionary becomes a suitable dictionary without a plurality of pixel values being biased.

  In the present embodiment, among pixel values registered in the dictionary, the pixel value having the smallest difference from the pixel value of the pixel to be processed is selected, and the difference is encoded, thereby efficiently compressing the pixel value. can do.

  In this embodiment, the value of the pixel on one line is not used for the target pixel. Therefore, no line memory is required, and it is easy to incorporate the image processing apparatus according to the present embodiment in the ASIC.

(Other examples of embodiment)
In the present embodiment, image data in the RGBA color space has been described. However, multi-value data such as RGB, CMY, CMYK, or Lab can be similarly implemented. Further, the same can be applied to multi-values of one component, such as only C components in the CMY color space or multi-values of only R in the RGB color space.

  Further, in the present embodiment, it is realized by the FIFO (First_In_First_Out) method, but any method may be used as long as it uses a dictionary.

  Although the best mode for carrying out the invention has been described above, the present invention is not limited to the embodiment described in the best mode. Modifications can be made without departing from the spirit of the present invention.

1 is a diagram illustrating a configuration example of a mechanism unit of an image forming apparatus in which an image processing apparatus according to an embodiment of the present invention is mounted. 2 is a block diagram illustrating a device configuration of an electrical / control unit in the color printer 1. FIG. FIG. 3 is a diagram illustrating an outline of processing in the color printer. FIG. 3 is a diagram illustrating a storage area in the main memory 130. FIG. 3 is a diagram for explaining the relationship between each storage area in the main memory 130 and electrical / control blocks of the color printer 1. 3 is a block diagram illustrating a functional configuration of an encoding unit 115. FIG. It is a figure explaining reading band data for every scan line. It is a figure explaining the detail of a run length production | generation process. It is a figure explaining an iterative process. It is a figure which shows the example of the process by the dictionary conversion part. It is a figure which shows the example of the process by the dictionary conversion part 504 when the pixel value corresponding to the input pixel value is not stored in the RGBA dictionary. It is a figure explaining the format of code data. It is a figure explaining the format of code data. It is a figure explaining pixel value j being registered into a RGBA dictionary. It is a block diagram explaining the function structure of the decoding part. It is a figure explaining the decoding process by an index. It is a figure explaining the process which calculates | requires the RGBA value corresponding to an index. It is a figure explaining the decoding process of the repetition in the repetition process part 605. FIG. It is a figure explaining the decoding process by the run length decoding process part. It is a figure explaining the input / output of the data in each part which the encoding part 115 has. It is a figure explaining the example of the process in the run length production | generation process part 502 and the repetition process part 503. FIG. It is a figure explaining the process in the dictionary conversion part 504, the difference process part 505, and the code | symbol format generation part 506. It is a figure explaining the process which the value of a run length etc. updates. It is a figure explaining the example of the hardware constitutions of the dictionary conversion part. It is a figure explaining the process which produces | generates the index in the index production | generation part. It is a figure explaining the example of the hardware constitutions of the difference production | generation process part 505. It is a flowchart explaining the process which acquires an index from a difference. It is a figure explaining the input / output of the data in each part of the decoding part. It is a flowchart which shows the example of the process which acquires the value of the run length, etc. in the decoding part. FIG. 10 is a flowchart illustrating processing performed by a code format analysis unit 602, a difference processing unit 603, and a dictionary conversion unit 604. It is a flowchart explaining the example of the decoding process in the run length decoding process part. FIG. 10 is a flowchart for explaining an example of processing in an iterative processing unit 605. It is a figure which shows the example of the hardware constitutions of the difference process part 603 which the decoding part 116 has. It is a figure explaining the example of the hardware constitutions of the dictionary conversion part 604 in the decoding part 116. FIG. And FIG. 14 is a diagram illustrating a configuration of a computer.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 Color printer 10a Register 11a Comparator 13 Index generation part 14 Calculator 15 Register 16 Register 17 Control part 20 Register 21 Subtractor 22a, 22b, 22c Subtractor 23 Minimum value selection part 24 Register 25 Register 26 Register 30 Register 31 Adder 32a Adder 33 Selector 34 Register 35 Register 36 Register 40a Register 41 Multiplexer 42 Control Unit 43 Multiplexer 45 Register 46 Register 100 Electrical / Control Unit 110 Printer ASIC
113 Main memory arbiter 114 Main memory controller 115 Encoding unit 116 Decoding unit 117 Image processing unit 118 Engine controller 119 Communication processing unit 120 Printer engine 130 Main memory 131 Program area 132 PDL storage memory area 133 RGBA band memory storage area 134 Page code storage Area 135 Other area 400 Main processing unit 410 Input device 419 Input I / F
420 Display 429 Display I / F
430 Scanner 439 Scanner I / F
440 Plotter 449 Plotter I / F
480 Drive device 489 Drive I / F
490 Hard disk device 501 Image reading unit 502 Run length generation processing unit 503 Repeat processing unit 504 Dictionary conversion unit 505 Difference processing unit 506 Code format generation unit 507 Code writing unit 508 Difference upper limit storage unit 509 Memory arbiter I / F
511 Image address generation unit 517 Code address generation unit 601 Code reading unit 602 Code format analysis unit 603 Difference processing unit 604 Dictionary conversion unit 605 Repeat processing unit 606 Run length decoding processing unit 607 Image writing unit 609 Image processing unit I / F
611 Code address generator

Claims (15)

Difference obtaining means for obtaining a difference between a pixel value of the pixel and a pixel value having a pixel index associated with each different pixel value for each pixel constituting the image;
Pixel index means for selecting a pixel index corresponding to one pixel value based on the difference for each pixel constituting the image;
A run length acquisition means for acquiring a run length that is a number of consecutive pixels having the same pixel index in the raster order of the image;
Encoding means for encoding the selected pixel index, the difference, and the run length;
An image compression apparatus.   The image compression apparatus according to claim 1, wherein the pixel index unit selects a pixel index of a pixel value that minimizes the difference among pixel values for which the difference is acquired by the difference acquisition unit. Dictionary storage means for holding a dictionary in which the pixel index and the pixel value are associated with each other;
When the pixel index associated with the pixel value of the pixel is not held in the dictionary storage means,
Pixel index generation means for generating a pixel index corresponding to the pixel value of the pixel;
A dictionary update unit that updates the dictionary by causing the dictionary storage unit to store the generated pixel index and the pixel value of the pixel in association with each other;
The image compression apparatus according to claim 1 or 2, further comprising: Dictionary storage means for holding a dictionary in which the pixel index and the pixel value are associated with each other;
When the pixel index associated with the pixel value of the pixel is not held in the dictionary storage unit, and when the difference between the pixel value of the pixel and the pixel value at which the difference is minimum is equal to or greater than a predetermined upper limit value,
The image compression apparatus according to claim 1, wherein the encoding unit encodes a pixel value of the pixel.   The image compression apparatus according to claim 4, further comprising upper limit value holding means for holding the predetermined upper limit value. The first run having a predetermined run length having a first pixel index and the second run having the predetermined run length having a second pixel index are alternately continuous. Repetitive value acquisition means for acquiring a repetitive value based on the number of runs and the second number of runs,
6. The image compression apparatus according to claim 1, wherein the encoding unit further encodes the repeated value. Analyzing code data obtained by compressing image data by a run-length encoding method, the pixel index corresponding to a predetermined pixel value, a difference from the predetermined pixel value, and the pixel value in the raster order of the image data Code data analysis means for obtaining a run length that is a continuous number;
Dictionary processing means for obtaining a pixel value corresponding to the pixel index from a dictionary in which the pixel index and the pixel value are associated;
Difference processing means for obtaining a pixel value of a decoded pixel by a sum of the pixel value and the difference;
Run-length decoding means for performing run-length decoding based on the run length and the pixel value of the decoded pixel;
An image decoding apparatus.   The image decoding apparatus according to claim 7, further comprising a dictionary holding unit that holds the dictionary. When the code data includes a pixel value and a run length corresponding to the pixel value,
The image decoding device according to claim 7 or 8, wherein the run-length decoding means performs run-length decoding based on the run length and the pixel value. When the code data includes a first run having a predetermined run length having a first pixel index and a second run having the predetermined run length having a second pixel index alternately. Including a repeat value based on the number of the first run and the number of the second run,
The code data analysis means acquires the repetition value,
The image decoding apparatus according to claim 7, wherein the run-length decoding unit performs run-length decoding based on the repetition value. A difference acquisition step of acquiring a difference between a pixel value of the pixel and a pixel value having a pixel index associated with each different pixel value for each pixel constituting the image;
A pixel index step for selecting a pixel index corresponding to one pixel value based on the difference for each pixel constituting the image;
A run length acquisition step of acquiring a run length, which is the number of consecutive pixels having the same pixel index in the raster order of the image;
An encoding step for encoding the selected pixel index, the difference, and the run length;
An image compression method.   The image compression method according to claim 11, wherein in the pixel index step, a pixel index having a pixel value that minimizes the difference is selected from the pixel values from which the difference has been acquired in the difference acquisition step. Analyzing code data obtained by compressing image data by a run-length encoding method, the pixel index corresponding to a predetermined pixel value, a difference from the predetermined pixel value, and the pixel value in the raster order of the image data A code data analysis step for obtaining a run length which is a continuous number;
A dictionary processing step of obtaining a pixel value corresponding to the pixel index from a dictionary in which the pixel index and the pixel value are associated;
A difference processing step of obtaining a pixel value of a decoded pixel by a sum of the pixel value and the difference;
A run-length decoding step for performing run-length decoding based on the run length and the pixel value of the decoded pixel;
An image decoding method comprising:   A computer program for causing a computer to execute the image compression method according to claim 11.   A computer program for causing a computer to execute the image decoding method according to claim 13.

Images