JP2000289261A - Image processing apparatus - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce a time period from a time when image data is received to a time when output data is generated by a method wherein fragmentation in a memory which is used as a working area for generating the output data from image data is suppressed so that the memory is effectively used and overhead due to memory releasing is avoided. SOLUTION: In the case where memory means 16a-16c to be working areas for generating output data from image data are used, pieces of data to be stored thereto are classified into plural data groups corresponding to effective time periods thereof and each of the classified data groups is removed by a different timing. As a result, assigning of working areas in memory means 16a-16c is executed by a unit of the data group.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an image processing apparatus used in, for example, a printer or a multifunction peripheral having a print function, and more particularly to an image processing apparatus for generating output data in a format suitable for image output from image data. The present invention relates to a processing device.

[0002]

2. Description of the Related Art Conventionally, in an image processing apparatus used in a printer or the like, when a client connected to the printer or the like receives an image data output request (hereinafter referred to as "job"), the job is processed. In this case, output data in a format suitable for image output is generated from the image data requested to be output. For example, a page description language (hereinafter referred to as “PDL”) is sent from a client device as image data.
Is transmitted, the image processing apparatus receives and analyzes the code data, develops the code data into bitmap data or the like, and sets it as output data.

[0003] In general, such output data is generated.
CPU (Central Processing Uni) of the image processing device
t) is the RAM (Random Acc
This is performed by executing a predetermined program while using a memory such as essMemory) as a work area (work area). At this time, the assignment of the work area in the memory is generally changed on a job-by-job basis. For example, Japanese Patent Application Laid-Open No. 9-16374 discloses that the capacity secured in the memory is changed for each job to be processed based on a memory setting value input from an operation unit or the like. That is, in the conventional image processing apparatus, an area having a necessary capacity is secured for each job, and the job is processed using the secured area.

[0004]

By the way, in the above-mentioned conventional image processing apparatus, the work area is allocated in units of jobs, and the area reserved for processing a certain job is processed in the next job. Sometimes released. Therefore, the fragmentation (fragmentation) in the memory that occurs with the processing of a certain job does not lower the memory use efficiency during the subsequent job processing. However, for example, when a certain job requests output of image data for a plurality of pages of a visible image, fragmentation generated by generation of output data for a certain page may cause an increase in memory usage efficiency in subsequent page processing. May be reduced. In order to avoid this, it is conceivable to increase the capacity of the memory itself, but in this case, the cost of the apparatus is increased.

In the above-described conventional image processing apparatus,
When the area allocated in memory is no longer used,
It is necessary to open each secured area one by one. Therefore, when many temporary buffers are used for job processing, the overhead of releasing each area reserved for each temporary buffer cannot be ignored.

Therefore, the present invention suppresses the fragmentation of the memory to effectively use the memory,
An object of the present invention is to provide an image processing apparatus capable of shortening a time from receiving image data to generating output data by avoiding overhead due to memory release.

[0007]

SUMMARY OF THE INVENTION The present invention is directed to an image processing apparatus devised to achieve the above object, which receives image data and generates output data in a format suitable for image output from the image data. Processing means, a memory means used as a work area when the processing means generates output data, and a classification for classifying data stored in the memory means into a plurality of data groups according to their useful periods. Means, and control means for deleting each data group classified by the classification means from within the memory means at different timings.

According to the image processing apparatus having the above configuration, the data stored in the memory means is classified into a plurality of data groups by the classification means. At this time, the classification into each data group is performed according to the useful period of the data in the memory means. Thereafter, each data group is deleted from the memory means at a different timing by the control means, for example, when a useful period has elapsed. That is, in this image processing apparatus, the work area is allocated in the memory unit in units of data groups, so that fragmentation in the memory unit can be suppressed. Moreover, since the data groups in the memory means are deleted at different timings, the overhead due to releasing the memory can be avoided.

[0009]

DESCRIPTION OF THE PREFERRED EMBODIMENTS An image processing apparatus according to the present invention will be described below with reference to the drawings. FIG. 1 is an explanatory diagram showing an outline of a memory state in an example of an image processing apparatus according to the present invention, FIG. 2 is a block diagram showing a schematic configuration of the image processing apparatus, and FIG. FIG. 3 is a block diagram illustrating a configuration.

First, a schematic configuration of the image processing apparatus according to the present embodiment will be described with reference to FIG. As shown in the example of the figure, the image processing apparatus (Im
age Processing System; hereinafter abbreviated as “IPS”) 10
Is an image output terminal (hereinafter referred to as "I") which outputs an image on recording paper by a well-known electrophotographic technique.
OT) 20 together with, for example, a printer or a multifunction peripheral having a print function.

A client 30 is connected to the IPS 10 via a communication line or a network such as a LAN (local area network). The client 30 includes a personal computer, a workstation, and the like, and includes the IPS 10 and the IOT.
A job requesting image output is issued to the printer 20 and image data necessary for processing the job is transmitted. However, the client 30 transmits, for example, code data described in PDL as image data. Note that a plurality of clients 30 may be connected via a network.

The IPS 10 used while connected to the IOT 20 and the client 30 includes an input buffer 11 and a hard disk drive (Hard Disk Drive).
e; hereinafter referred to as “HDD”) 12, a CPU 13, a program ROM (Read Only Memory) 14, a font R
An OM 15, a memory 16, a printer interface (hereinafter, the interface is abbreviated as "I / F") 17,
A panel 18 and a bus 19 for connecting these to each other are provided.

The input buffer 11 is for receiving the code data transmitted from the client 30. When the input buffer 11 receives code data for a plurality of jobs, the HDD 12 spools the code data or stores the code data for all pages included in one job for electronic matching. Things.

The CPU 13 performs necessary processing for causing the IOT 20 to output an image of the code data received by the input buffer 11. More specifically, as will be described in detail later, the code data received from the client 30 is analyzed, and processing necessary to convert the code data into bitmap output data suitable for image output in the IOT 20 is performed. It has become.

The memory 16 is composed of, for example, a RAM, and is used as a work area when the CPU 13 executes the above-described processing. The program ROM 14 stores control programs necessary for the CPU 13 to execute the above-described processing. The font ROM 15 stores fonts necessary for the CPU 13 to execute the above-described processing.

The printer I / F 17 is for transmitting the output data generated by the CPU 13 to the IOT 20. The panel 18 is operated by the user to input necessary information, and displays the status of the IPS 10 to the user.

Next, a processing operation in the IPS 10 configured as described above, particularly, a flow of a processing operation performed by the CPU 13 will be described with reference to FIG. Note that here, the so-called binding type, which divides the code data for one page of the visible image described in PDL into a plurality of bands and develops them into bitmap output data for each band, The processing operation described above will be described as an example.

In the IPS 10, a code data input unit 101, a code interpretation unit 102, a character processing unit 103, a graphic processing unit 104, an intermediate data generation unit 105, an image processing unit 106, an image compression unit 107, and an image decompression unit 10
8. Each of the band generation unit 109 and the band compression unit 110 generates output data in band units by performing the processing described below. Note that these units 101 to 110 are provided by the CPU 13 in the program ROM 14.
It is realized by executing a control program in the inside.

The code data transmitted from the client 30 is input to the code data input unit 101 after passing through the input buffer 11 or the HDD 12, and the code interpretation unit 102 analyzes the type of the code.

As a result of the analysis by the code interpreting unit 102, if the code type is interpreted as a character, the character processing unit 103 performs a process for drawing a character. At this time, based on the font stored in the font ROM 15, the character processing unit 103 uses a partial area (hereinafter referred to as a “temporary area”) in the memory 16 as a work area, Perform processing to expand to.
For this expansion processing, character information expanded in a bitmap shape by an outline is cached in the memory. The area where the character information is cached is called a font cache.

In addition, as to what is interpreted as a figure,
The graphic processing unit 104 performs processing for drawing graphics.
Also at this time, the graphic processing unit 104 uses the temporary area in the memory 16 as a work area.

After the character drawing by the character processing unit 103 and the graphic drawing by the graphic processing unit 104, the intermediate data generation unit 105 generates intermediate data in the memory 16 based on the respective processing results. Intermediate data generator 1
05 generates this intermediate data in a partial area in the memory 16 (hereinafter referred to as “intermediate data memory”).

The image interpreted by the code interpreting unit 102 as an image equivalent to a photograph or the like is subjected to necessary processing for image drawing by the image processing unit 106 and then compressed by the image compressing unit 107. You. Also at this time, the image processing unit 106 and the image compression unit 1
07 uses a temporary area in the memory 16 as a work area.

After the respective processes corresponding to the differences between the characters, figures, and images are performed in this manner, the memory 1
On 6, the intermediate data is generated in the intermediate data memory. Note that the image compressed by the image compression unit 107 is also stored in the same intermediate data memory. Here, the process up to the generation of the intermediate data is referred to as decomposition.

After the completion of the decomposing, the IPS 10 generates output data divided in band units. Specifically, when the intermediate data is generated in the intermediate data memory, the band generation unit 109 generates the raster data in a predetermined band unit. At this time, the band generation unit 109 generates raster data by combining the intermediate data in the intermediate data memory with the image. However, it is assumed that the image to be synthesized has been expanded by the image expansion unit 108.

When the band generator 109 generates raster data in band units, the band compressor 110 compresses the raster data to improve the transfer efficiency to the IOT 20. As a result, the raster data after compression is generated on the memory 16 as output data to be transmitted to the IOT 20. In addition,
This output data is stored in a partial area (hereinafter, referred to as a “compressed band area”) in the memory 16 in band units.
Here, rendering up to generation of output data in band units is referred to as rendering.

After the rendering is completed, the IPS 10 outputs the output data in the compression band area.
The data is transmitted to the IOT 20 via the printer I / F 17. In response to this, the IOT 20 decompresses the output data and outputs it on a recording sheet as a visible image.

Next, the IPS 1 that performs such a processing operation
0, that is, the state in the memory 16 when the IPS 10 of the present embodiment performs the above-described processing operation.
This will be described with reference to FIG.

In the IPS 10, data stored in the memory 16 is classified into a plurality of data groups according to a useful period (life time). This classification is performed by the CPU 13 executing the control program in the program ROM 14 based on the useful period of each data in the memory 16 which is known in advance. The data group classified in this way includes a valid data group within a page, a valid data group within a job, and a valid data group between jobs.

The valid data group within a page includes data that is useful only while generating output data for one page of a visible image. For example, character data and graphic data in the temporary area (including path data and clip area data required when generating intermediate data), intermediate data and compressed images in the intermediate data memory, and output in the compressed band area Data corresponds to this. These are all stored in the page processing area 16a in the memory 16. That is, the temporary area, the intermediate data memory, and the compression band area are respectively stored in the page processing area 1
6a.

The in-job valid data group includes data that is useful until one job requesting generation of output data is completed. For example, data that differs depending on the application of the client 30 that issues a job, specifically, pattern data for specifying an output pattern of output data, form data for specifying the format thereof, and the like correspond to this. These are all stored in the in-job shared area 16b in the memory 16. It is assumed that these data are transmitted together with the code data from the client 30, for example.

The inter-job valid data group includes data useful not only for one job but also for a plurality of jobs. For example, character information in a font cache corresponds to this. These are stored in the inter-job shared area 16c in the memory 16. That is, the font cache is secured in the inter-job sharing area 16c.

In the IPS 10, the data groups classified as described above are deleted from the memory 16 at different timings. This deletion is also performed by the CPU 13 executing the control program in the program ROM 14 according to the useful period of each data group and the processing status of the job.

Here, taking as an example a case of processing a job for outputting an image of code data for a plurality of pages, the state in the memory 16 at that time is shown as being decomposed, at the end of decomposition, and during rendering and compression. , After the rendering is completed, after the data output is completed, and after the job is completed.

When processing the above job, first,
Decompose the code data for the first page. At this time, in the memory 16, as shown in FIG. 1A, the inter-job shared area 16c is used as a font cache, and the intra-job shared area 16b is used as an area for storing a valid job data group. Can be Further, a temporary area and an intermediate data memory are secured in the page processing area 16a, and intermediate data is generated in the intermediate data memory while using the temporary area as a work area.

When the decomposing of one band is completed, the intermediate data for the band is stored in the intermediate data memory in the page processing area 16a as shown in FIG. 1B. At this time, since the decomposing of the band has already been completed, the temporary area used as the work area at the time of generating the intermediate data is released, and no longer exists in the page processing area 16a.

The rendering and compression of the intermediate data in the intermediate data memory is subsequently performed. Thus, in the memory 16, as shown in FIG. 1C, a compressed band area is secured in the page processing area 16a, and the intermediate data is compressed in the compressed band area to output one band. Is stored as application data.

Thereafter, when rendering for one band is completed, as shown in FIG. 1D, output data for the band is stored in the compressed band area of the page processing area 16a. It will be. At this time,
Since the rendering for the band is completed and all the intermediate data in the intermediate data memory is output data, the intermediate data memory does not exist in the page processing area 16a.

When output data for one band is generated in the compression band area in this manner, the CPU 13
Converts the output data in the compression band area into an IOT20
1A to 1D, and output data for the next band is generated in the compression band area of the page processing area 16a. The CPU 13 repeats this until all bands on the first page are completed.

When decomposing and rendering have been completed for all bands on the first page, CP
U13 is a page processing area 16a in the memory 16 since the useful period of the in-page valid data group has elapsed.
, Ie, all data belonging to the in-page valid data group are deleted from the memory 16. Thus, in the memory 16, as shown in FIG. 1E, only the font cache of the inter-job shared area 16c and the data memory of the intra-job shared area 16b exist, and the page processing area 16a is entirely free space. Becomes

Thereafter, the CPU 13 returns to FIG. 1 (a) to FIG.
The processing shown in (e) is repeated. This process is repeated until all the pages of the job are completed.

When the processing for the job is completed in this way, the CPU 13 here determines that the useful period for the effective data group within the job has elapsed,
6, the data stored in the in-job shared area 16b, that is, all data belonging to the in-job valid data group are deleted from the memory 16. At this time, the CPU 13
Is the data stored in the page processing area 16a,
That is, all the data belonging to the in-page valid data group are similarly deleted from the memory 16.

That is, the CPU 13 collectively deletes the data in the page processing area 16a and the data in the in-job shared area 16b. This is because the useful period of the valid data group within the page does not exceed the useful period of the valid data group within the job. Thereby, in the memory 16, as shown in FIG.
Only the font cache of the inter-job shared area 16c exists, and the intra-job shared area 16b and the page processing area 16a are all free areas.

In the IPS 10, if there is a job to be processed next, the job is returned to FIG.
The processing shown in (a) to (f) is repeated, and if there is no job to be processed, the process waits for the next job.

The data in the in-job shared area 16b is stored in the IPS 10 when the operation of the apparatus is stopped.
When all of the job processes by the
What is necessary is just to delete from inside. However, also in this case, together with the data in the in-job shared area 16b, the page processing area 16a and the in-job shared area 16b
It is assumed that batch deletion is performed for the data in.

In the IPS 10, if an error such as paper jam or running out of toner occurs in the IOT 20, or if an error occurs in the IPS 10 itself, an
The CPU 13 recognizes the fact by an error notification or the like from the OT 20 and performs an error process. This error processing includes deleting data from the memory 16.

However, the CPU 1 in the IPS 10
In No. 3, when data is deleted from the memory 16 due to the occurrence of an error, a data group having a useful period shorter than the data group to be deleted is also deleted from the memory 16. I have. For example, when the inside of the page processing area 16a is cleared by the error processing, only the valid data group within the page is deleted, but when the common area 16b within the job is cleared, it is more useful than the valid data group within the job. The in-page valid data group having a short period is also deleted. Therefore, even when data is deleted from the memory 16 due to the occurrence of an error, the overhead of releasing the memory can be reduced.

As described above, in the present embodiment, the IP
In step S10, the data stored in the memory 16 is classified into a plurality of data groups according to the useful period, and each data group has a different timing when the useful period has elapsed. Thus, the data is deleted from the memory 16. That is, this I
In the PS 10, the work area is allocated in the memory 16 in units of data groups, so that fragmentation that may occur in the memory 16 is suppressed,
6 can be effectively used. In addition, since each data group in the memory 16 is deleted at a different timing, the overhead due to memory release can be avoided. Therefore, if the output data is generated by using the IPS 10, the output data is generated after receiving the code data from the client 30 without increasing the device cost due to the increase in the capacity of the memory 16 itself. The time between the two can be reduced as compared with the conventional case.

In particular, in the IPS 10 according to the present embodiment, the data stored in the memory 16 is converted into a valid data group within a page, a valid data group within a job, and a valid data group between jobs. In addition to the classification, the in-page effective data group is deleted from the memory 16 every time the generation of the output data for one page of the visible image is completed. for that reason,
Data belonging to the valid data group within the page classified as valid only within the page is cleared after each page processing, and data belonging to the valid data group within the job classified as valid between jobs is cleared at the end of each job processing Is done. Therefore,
In the IPS 10, even when a certain job requests output of image data for a plurality of pages of visible images, fragmentation caused by generation of output data for a certain page causes memory usage efficiency in subsequent page processing to be performed. Is not reduced. In other words, even if there are a plurality of pages of code data to be processed by a certain job, fragmentation occurring between these pages can be suppressed, so that the effective use of the memory 16 is ensured.

In the IPS 10 of the present embodiment, when data is deleted from the memory 16 due to the occurrence of an error, the IPS 10 has a more useful period than the data group to be deleted. Is also deleted from the memory 16 for a short data group.
Therefore, in the IPS 10, even when data is deleted from the memory 16 due to the occurrence of an error, the overhead of releasing the memory can be reduced.

In the present embodiment, the IPS 10 corresponding to a so-called binding type for generating output data for each band has been described as an example. However, the present invention is not limited to this. For example, the same can be applied to a case where output data is generated for each page.

[0052]

As described above, the image processing apparatus according to the present invention classifies the data stored in the memory means into a plurality of data groups according to the useful period, and sets each data group at a different timing. For example, when the useful period has elapsed, the data is deleted from the memory means. In other words, in this image processing apparatus, the work area is allocated in the memory unit on a data group basis, so that fragmentation in the memory unit can be suppressed and the memory unit can be effectively used.
Moreover, since each data group in the memory means is deleted at a different timing, the overhead due to memory release can be avoided. Therefore, by using this image processing apparatus, the time from receiving the image data to generating the output data can be shortened as compared with the related art.

[Brief description of the drawings]

FIGS. 1A and 1B are explanatory diagrams illustrating an outline of a memory state in an example of an image processing apparatus according to the present invention, in which FIG. 1A illustrates a state during decomposition, FIG. FIG. 8D is a diagram showing that rendering and compression is being performed, FIG. 9D is a diagram showing after rendering is completed, FIG. 9E is a diagram showing after data output is completed, and FIG.

FIG. 2 is a block diagram illustrating a schematic configuration of an example of an image processing apparatus according to the present invention.

FIG. 3 is a block diagram illustrating a functional configuration of an example of an image processing apparatus according to the present invention.

[Explanation of symbols]

10 image processing apparatus (IPS), 13 CPU, 14 ...
Program ROM, 16: Memory, 16a: Page processing area, 16b: In-job shared area, 16c: Inter-job shared area, 101: Code data input section, 102: Code interpretation section, 103: Character processing section, 104: Graphic Processing unit,
105: intermediate data generation unit, 106: image processing unit,
107: Image compression unit, 108: Image decompression unit, 1
09: band generation unit, 110: band compression unit

──────────────────────────────────────────────────続 き Continued on the front page (51) Int.Cl. ⁷ Identification symbol FI Theme coat ゛ (Reference) H04N 1/21 G06F 15/64 450F 5C073 9A001 F term (Reference) 2C087 AB05 BC02 BC04 BC05 BD01 5B021 AA01 AA19 DD14 DD16 5B047 AA30 EA07 EB01 EB15 5B060 AA05 AA14 AC13 AC18 DA08 5B080 CA08 5C073 AA04 AB07 BA01 BB02 BC04 BD03 9A001 BB03 DZ08 EE02 HH23 HH34 JJ35 KK42

Claims (4)

[Claims] 1. Processing means for receiving image data and generating output data in a format suitable for image output from the image data, and memory means used as a work area when the processing means generates output data Classifying means for classifying data stored in the memory means into a plurality of data groups according to their useful periods; and deleting each data group classified by the classifying means from the memory means at different timings. An image processing apparatus comprising: 2. A group of data classified by the classifying unit is requested to generate a group of valid data in a page that is useful only while generating output data of one page of a visible image and a generation of output data. 2. The image processing apparatus according to claim 1, wherein there are a group of valid data within a job that is useful until one job is completed, and a group of valid data between jobs that are useful across a plurality of jobs. 3. The method according to claim 2, wherein the control unit deletes the effective data group in the page from the memory unit each time generation of output data for one page of the visible image is completed. Item 3. The image processing device according to Item 2. 4. When the control unit deletes data from the memory unit due to the occurrence of an error, the control unit also deletes a data group having a shorter useful period than the data group to be deleted from the memory unit. 4. The image processing apparatus according to claim 1, wherein the image processing apparatus performs deletion.