JP4789197B2 - Code processing apparatus, code processing method, program, and information recording medium - Google Patents

Description

  The present invention relates to processing of a compression code of an image, and in particular, a code that is composed of partial codes arranged in accordance with a progression order and is allowed to change the progression order in the arrangement of partial codes. The present invention relates to JPEG2000 code processing. The present invention can be suitably applied to a JPIP server or the like.

  As a code that is composed of partial codes arranged in accordance with the progression order and is allowed to change the progression order in the partial code arrangement, for example, there is a JPEG2000 code. In the JPEG2000 code, a packet that is a partial code can be selectively accessed and decoded or transmitted. The present invention is suitable for the purpose of such code processing.

  Here, the encoding process and code structure of JPEG2000 will be described to the extent necessary for understanding the present invention.

  JPEG2000 encoding processing is generally performed according to the flow shown in the block diagram of FIG. The image is divided into rectangular tiles (number of divisions ≧ 1). Each tile is color-converted into components such as luminance and color difference (block 1). In the case of data represented by a positive number such as RBG data, a DC level shift that reduces half of the dynamic range is also performed. The transformed component (referred to as a tile component) is divided into subbands by applying wavelet transformation (block 2). The signal is divided into four subbands abbreviated as LL, HL, LH, and HH by one wavelet transform (decomposition). When the wavelet transform is repeated recursively for the LL subband, one LL subband and a plurality of HL, LH, and HH subbands are finally generated.

  FIG. 3 shows subbands when wavelet transform (decomposition) is performed three times. A prefix number (for example, “3” of “3LL”) of each subband name in FIG. 3 indicates a decomposition level (the number of wavelet transforms performed). For the purpose of later explanation, the relationship between the decomposition level and the resolution level is shown in FIG.

  When an irreversible wavelet transform called 9 × 7 transform is used, the wavelet coefficients are subjected to linear quantization (including normalization) for each subband (block 3), and then entropy coded ( Block 4). In this entropy coding, each subband is divided into rectangles called precincts. The precinct is a subband divided into rectangles, and three precincts corresponding to the three subbands HL, LH, and HH are treated as one unit. However, one precinct obtained by dividing the LL subband is handled as one unit. The precinct roughly represents a position in the image. The precinct can be the same size as the subband. A code block is obtained by further dividing the precinct into rectangles.

  FIG. 2 shows the relationship among tiles, subbands, precincts, and code blocks. Therefore, the physical size order is image ≧ tile> subband ≧ precinct ≧ code block.

  After the above division, coefficient entropy coding (bit-plane coding) is performed for each code block and in order of bit-plane.

  Next, necessary entropy codes are collected to generate a packet (block 5). A packet is a header (packet header) in which all code blocks included in a precinct collect a part of the code of a bit plane (for example, the code from the MSB to the third bit plane of all code blocks). It is a thing attached. Since the “part” may be “empty” (from), the content of the packet may be “empty” in terms of code. The packet header includes information regarding codes included in the packet. Each packet can be handled independently. In other words, a packet is a unit of code.

  When packets of all precincts (= all code blocks = all subbands) are collected, a part of the code of the entire image area (for example, wavelet coefficients of the entire image area of the bit planes from the MSB to the third frame) This is called a layer. Since the layer is roughly a part of the code of the bit plane of the entire image, the image quality increases as the number of layers to be decoded increases. That is, a layer is a unit of image quality. When all layers are collected, it becomes the code of all bit planes of the entire image.

  An example of layers when the number of decomposition levels = 2 and the precinct size = subband size is shown in the upper part of FIG. Packets included in several layers are shown in a lower frame in FIG.

  The final JPEG2000 code (code stream) is formed by arranging packets and adding necessary tags and tag information according to the packet and layer delimiters generated as described above (block 6). .

As can be understood from the above description, the component to which the packet belongs (symbol C),
-Which resolution level (symbol R) belongs to
-Which precinct ("location", symbol P) belongs to
-Which layer (symbol L) belongs to
(In the present application, these attributes are referred to as “progression attributes”). There is a packet header at the beginning of the packet, followed by an MQ code (packet data), but the attribute itself is not described in the packet header.

  The packet arrangement means the order in which attributes packets (packet header and packet data) are arranged hierarchically. This arrangement order is called a progression order, and five patterns shown in FIG. 5 are defined.

  Here, the manner in which the encoder arranges the packets according to the progression order and the manner in which the decoder interprets the attributes of the packets in accordance with the progression order are shown below.

For example, in the case of LRCP progression order, the following for loop
for (layer) {
for (resolution) {
for (component) {
for (Precinct) {
Encoding: Place packet
When decoding: Interpret packet attributes}
}
}
}
Thus, the packet is arranged (when encoded) or interpreted (when decoded).

In the packet header of each packet,
Whether the packet is empty,
Which code block is included in the packet,
The number of zero bit planes for each code block included in the packet,
-The number of coding passes (number of bit planes) of each code block code included in the packet,
The code length of each code block included in the packet,
Is described. However, the layer number and resolution level are not described in the packet header at all. In order to determine which resolution level of which layer the packet is at the time of decoding, the for loop as described above is constructed from the progression order described in the COD marker segment (see FIG. 13) in the main header. Then, by determining the packet length by obtaining the packet length from the sum of the code lengths of the code blocks included in the packet, it is only necessary to determine at which position in the for loop each packet is handled. This means that as long as the code length in the packet header is read, the next packet can be detected without decoding the packet data (entropy code), that is, any packet can be accessed.

  In the present application, the outermost (outermost shell) of the for loop as described above is referred to as “progression order outermost shell”.

  FIG. 6 is a conceptual diagram of a layer progressive code in which an attribute located at the outermost shell of the progression order is a layer (L), such as a code of the LRCP progression order. However, the number of tile parts (described later) is 1.

  In FIG. 7, the image size = 100 × 100 pixels, no tile division (1 tile), 2 layers (0, 1), the number of resolution levels = 3 (0 to 2), 3 components (0 to 2), pre- An example of the arrangement of 36 packets in the case of a synch size = 32 × 32 and an LRCP progression order is shown. However, the number of tile parts (described later) is 1.

  FIG. 8 is a conceptual diagram of the resolution progressive code in which the resolution level (R) is located at the outermost shell of the progression order, such as the code of the RLCP progression order. However, the number of tile parts is 1.

  In FIG. 9, the image size = 100 × 100 pixels, no tile division (1 tile), 2 layers (0, 1), the number of resolution levels = 3 (0-2), 3 components (0-2), pre- An example of the arrangement of 36 packets in the case of a synch size = 32 × 32 and an RLCP progression order is shown. However, the number of tile parts (described later) is 1.

  Now, the codes constituting each tile can be divided into a plurality of parts at packet breaks, and the divided parts are called tile parts. As mentioned above, FIGS. 7 and 9 show the case where the number of tile parts = 1.

  In addition to the packet, each tile part has a header that starts with an SOT (start of tile-part) marker segment and ends with an SOD (start of data) marker. This header is called a tile part header (FIGS. 6 and 8). , FIG. 16).

  FIG. 11 shows the configuration of the SOT marker segment. A marker segment (SOT marker in this example) and parameters related to the marker is called a marker segment. The contents of the parameters of the SOT marker segment are shown in FIG. As understood from FIG. 12, the length of the tile part can be known by reading the contents of the parameter Psot in the SOT marker segment. Therefore, if the SOT marker segment is read, the length of the tile part can be known without decoding the packet header.

  Now, as explained above, since arbitrary partial codes can be accessed in JPEG2000, a protocol for transmitting / receiving only partial codes required on the client side from JPEG2000 codes stored in the server is currently in the process of standardization. This protocol is called JPIP (JPEG2000 Interactive Protocol).

  Protocols for partially accessing such hierarchical codes can be found in the past from FlashPix, which is a multi-resolution representation of an image, and IIP (Internet Imaging Protocol), which is a protocol for accessing it. (For example, refer to Patent Document 1). IIP standards are provided on the web site http://www.i3a.org/i_iip.html. Further, as a prior art document related to JPIP, for example, there is Patent Document 2 relating to a JPIP cache model.

JP-A-11-205786 JP 2003-23630 A

As described above, there are five progression orders in JPEG2000, but at the time of encoding, a plurality of these progression orders can be mixed in one code. For example, 36 image sizes = 100 × 100 pixels, 2 layers, number of resolution levels = 3 (0 to 2), 3 components (0 to 2), and precinct size = 32 × 32 (corresponding to FIG. 7) For packets
for (layer = 0) {
for (resolution level = 0,1,2) {
for (component = 0,1,2) {
for (all precincts) {
Place packet}
}
}
}
As described above, the number of times the for loop is turned is limited to arrange the 18 packets in the first half in the LRCP order.
for (component = 0,1,2) {
for (all precincts) {
for (resolution level = 0,1,2) {
for (layer = 0,1) {
Place only packets that have not been placed yet}
}
}
}
Can be arranged in CPRL order by the for loop. The packet arrangement in this example is shown in FIG.

  In this way, changing or re-defining a progression order relative to the default progression order specified in the main header is called a progression order change (POC). A POC marker segment is inserted into the tile part header of each tile part.

  FIG. 14 shows the structure of the POC marker segment. FIG. 15 shows the contents of the parameters of the POC marker segment. The progression order after the i-th progression order change designation is described in Ppoc (i), and the parameters RSpoc (i), CSpoc (i), REpoc (i), CEpoc (i), and LYpoc (i) The number of times the for loop is turned is designated by “first” and “last” of the loop variable. In other words, for the resolution level, the for loop of the progression order specified by Ppoc is rotated for the resolution level of “first” or more and less than “last”. However, for the layer, the “first” layer number = 0 is always set.

  Further, the specification of the progression order change can be performed any number of times more than once. In the example of FIG. 10, the first progression order change (re-definition) applied from the first packet is performed for the default progression order, and the “first” and “last” of the LRCP for loop are changed. It is specified. Next, the “first” and “last” of the for loop of CPRL is designated by the second progression order change (re-definition) applied from the intermediate packet. Further, as shown in FIG. 14, a plurality of progression order changes can be designated in one POC marker segment.

  Now, since the packet arrangement of the code with the designation of progression order change (POC) becomes complicated, it is difficult to select a desired packet in the code with the packet arrangement as it is. For example, when it is desired to decode only all packets (packets surrounded by a thick line frame) from the packet sequence in FIG. 10 to resolution level 1, it is complicated to determine at which position in the code these desired packets appear. Become.

  In view of this, a method usually adopted when selecting and decoding a part of a packet of a code having a designation of progression order change is first to provide pointer information for accessing each packet in the code stored in the memory ( For example, the top position and length of the packet are obtained and recorded in an array in the order of a specific progression order (for example, default progression order), and then the for loop of the specific progression order is turned. Thus, the method may be a method of obtaining the start position and length of a desired packet from the above array and accessing the desired packet in the code based on this.

  As an example, considering the case of selecting and decoding only all packets up to resolution level 1 in the packet array code shown in FIG. The following steps will be taken for The process is performed for each tile.

  [Step 1] All packets related to the tile are read into the memory A.

[Step 2] Structure P having the packet start position and packet length as elements
struct P {
Beginning position of packet;
Packet length;
}
And the total number of packets of the tile is calculated, and an array B of structures P corresponding to the total number is prepared. Then, a for loop corresponding to the default progression order is configured, and all the elements (structure P) of the array B are initialized by turning all the for loops.

[Step 3] A for loop corresponding to the first progression order change designation is formed, and this for loop is performed to obtain pointer information for the packet in the memory A and store it in the array B. That is,
for (layer = 0) {
for (resolution level = 0,1,2) {
for (component = 0,1,2) {
for (all precincts) {
Interpret the packet attributes and determine the start position and length of the packet on memory A
(Packet length is determined by decoding packet header or PLT marker
This can be determined by interpreting the segment)
Store in array B in a sorted form according to the order of the order}
}
}
}
Note that storing the start position of the packet and the packet length in the array B in a form sorted according to the default progression order means that each element of the array B has an attribute according to the default progression order and is interpreted by the above for loop. This means that the start position and the packet length of the packet are stored in the element of the array B corresponding to the attribute of the packet that has been assigned (having the same attribute).

[Step 4] A for loop defined by the second progression order change is formed, and this for loop is turned to process from the packet next to the packet in the memory A last processed in the step 3, that is, ,
for (component = 0,1,2) {
for (all precincts) {
for (resolution level = 0,1,2) {
for (layer = 0,1) {
Interpret packet attributes
If the start position of the packet with the attribute is not already stored in the array B (condition A), the start position and the packet length of the packet on the memory A are set to the default.
Save to array B according to progression order}
}
}
}
Thus, the pointer information (start position and length) of all packets related to one tile is stored on the array B in a form that excludes the influence of the progression order change, that is, in the form sorted in the order of the default progression order. Recorded.

[Step 5] Therefore, it is possible to construct a default progression order for loop and selectively decode a desired packet. That is,
for (all layers) {
for (resolution level = 0,1) {
for (all components) {
for (Precinct) {
The head of the packet read from the element of the array B corresponding to the packet attribute
Based on the position and length, the packet in memory A is read and entropy restored.
Issue}
}
}
}
With this processing, only packets up to resolution level 1 can be selected and decoded for each tile.

  In step 4, the condition A “if the start position of the packet with the attribute is not already stored in the array B” is set by specifying the “first” and “last” loop variables of the for loop. This is because the for loops of step 3 and step 4 are not necessarily exclusive and may have overlapping ranges (however, this overlap does not mean that packets are arranged in duplicate).

  The method described above is general purpose. However, always applying this method is to decode the packet header in order to know the packet length, even for many packets that are not selected (packets other than those surrounded by a thick line in the example of FIG. 10), or The PLT marker segment (see FIGS. 17-1 and 17-2) inserted in the first tile part header must be interpreted, and there is a problem that processing is wasteful and unsuitable for speeding up. Decoding only a partial code of the code is intended to speed up the original process, and therefore wasteful processing should be eliminated as much as possible.

  In order to achieve high speed, in addition to reducing useless decoding of packet headers, the JPEG2000 code itself should be read as little as possible. That is, in Step 1 of the above method, “read all the packets related to the tile into the memory A”, but since this is not always necessary, only the necessary number of packets are processed according to the progress of the process. It can also be read into the memory A.

  In view of the above points, the present invention performs processing for obtaining pointer information for accessing a necessary partial code from a JPEG 2000 code or a code consisting of a set of partial codes that are allowed to be changed in the middle of the progression order. To improve efficiency and speed.

The invention described in claim 1
A code processing device that handles codes that are composed of partial codes arranged in accordance with a progression order and that allow change of the progression order in the arrangement of partial codes,
Processing for obtaining pointer information for accessing each partial code of the code stored in the first storage means, and storing the pointer information in the second storage means in a form sorted according to one progression order. Processing means to perform,
First determination means for determining whether or not there is a change in progression order in the array of partial codes of the code;
A second determination means for determining whether or not the partial code designated by the user of the code is continuously arranged from the first partial code;
It is determined by the first determination means that there is no change in progression order, and the second determination means determines that the designated partial code is continuously arranged from the first partial code of the code. In this case, the processing means performs the processing only on the designated partial code of the code.

The invention according to claim 2
A code processing device that handles codes that are composed of partial codes arranged in accordance with a progression order and that allow change of the progression order in the arrangement of partial codes,
Processing for obtaining pointer information for accessing each partial code of the code stored in the first storage means, and storing the pointer information in the second storage means in a form sorted according to one progression order. Processing means to perform,
First determination means for determining whether or not a progression order in the code is changed;
Second determination means for determining whether or not the partial code specified by the user of the code is continuously arranged from the first partial code;
A third determination unit for determining whether or not the progression order is changed in the specified partial code array;
When it is determined by the first determination means that there is a change in the progression order in the code, the designated partial code is continuously arranged from the first partial code of the code. And when the second determination means determines that there is no change in the progression order in the array of the specified partial codes, the processing means only performs the specified partial codes. The code processing device is characterized by performing the above-described processing.

The invention described in claim 3
A code processing apparatus that handles JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing means,
First determination means for determining whether or not a progression order change is designated for each tile of the code;
A second determination unit configured to determine whether or not packets designated by the user are continuously arranged from the top packet for each tile of the code;
For the tile of the code that has been determined by the first determination means that there is no progression order change designation, it is determined by the second determination means that the designated packets are continuously arranged from the top packet. In this case, the processing means performs the processing only on the designated packet.

The invention according to claim 4
A code processing device according to the invention of claim 3,
For the tile of the code that has been determined by the first determination means that there is no progression order change designation, the second determination means uses the fore in which the attribute of the outermost shell of the default progression order corresponds to the designated packet. The code processing device is characterized in that when the attribute of the outermost shell of the loop is matched, it is determined that the designated packet is continuously arranged from the head packet.

  Note that the “match” of the attribute includes “substantial match”. For example, if the default progression order of a tile is LRCP and the number of layers is 1, even if the substantial progression order is RCP, the attribute of the substantial outermost shell can be regarded as R. For example, if all packets of a certain resolution level or lower are designated as the desired packet, the attribute of the outermost shell of the for loop corresponding to the desired packet is R, which is a substantial maximum of the progression order. It matches the attribute R of the outer shell. Such a case is a typical example of “substantial coincidence”. Similar “substantial matching” is also included in the attribute “matching” in the inventions of claims 6, 10, and 12.

The invention according to claim 5
A code processing apparatus that handles JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing means,
First determination means for determining whether or not a progression order change is designated for each tile of the code;
Second determination means for determining whether or not packets designated by the user are continuously arranged from the top packet for each tile of the code;
Third determination means for determining whether or not there is a change in the progression order in the specified packet arrangement for each tile of the code,
For the tile determined to have a progression order change designation by the first determination means, the second determination means determines that the specified packet is continuously arranged from the top packet, and When the third determination unit determines that there is no change in the progression order in the specified packet arrangement, the processing unit performs the process only on the specified packet. Is a code processing device.

The invention described in claim 6
A code processing device according to the invention of claim 5,
For the tile determined to have a progression order change designation by the first determination means, the second determination means specifies the attribute of the outermost shell of the progression order corresponding to the first progression order change designation. The code processing device is characterized in that when the attribute of the outermost shell of the for loop corresponding to the received packet matches, it is determined that the designated packet is continuously arranged from the top packet.

The invention described in claim 7
A code processing device according to the invention of claim 5,
For the tile for which the second determining means determines that the specified packet is continuously arranged from the first tile, the third determining means is configured to specify a for loop corresponding to the first progression order change specification. When the range of the loop variable of the for loop corresponding to the specified packet is completely included in the range of the loop variable, it is determined that there is no change in the progression order in the array of the specified packet The code processing device is characterized by the above.

The invention described in claim 8
A code processing device according to claim 3 or 5,
In the processing by the processing means for only the designated packet with respect to the tile of the code, reading the packet of the tile into the first storage means is performed in accordance with the progress of the processing. This is a characteristic code processing device.

The invention according to claim 9
A code processing method for handling JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing steps,
A first determination step for determining whether a progression order change is specified for each tile of the code;
A second determination step for determining whether or not the packet designated by the user is continuously arranged from the top packet for each tile of the code;
For the tile of the code determined to have no designation of progression order change in the first determination step, it is determined in the second determination step that the specified packet is continuously arranged from the top packet. In this case, the code processing method is characterized in that the processing is performed only on the designated packet in the processing step.

The invention according to claim 10 is:
A code processing method according to the invention of claim 9,
For the tile of the code that is determined to have no designation of a progression order change in the first determination step, the second determination step has an attribute of an outermost shell of a default progression order corresponding to the specified packet. The code processing method is characterized in that when the attribute of the outermost shell of the for loop coincides, it is determined that the designated packet is continuously arranged from the top packet.

The invention according to claim 11
A code processing method for handling JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing steps,
A first determination step of determining whether or not a progression order change is specified for each tile of the code;
A second determination step of determining whether or not the packet designated by the user is continuously arranged from the top packet for each tile of the code;
A third determination step for determining whether or not there is a change in the progression order in the specified packet arrangement for each tile of the code;
For tiles determined to have a progression order change designation in the first determination step, it is determined in the second determination step that the specified packet is continuously arranged from the top packet, and When it is determined in the third determination step that there is no change in progression order in the specified packet arrangement, the processing is performed only on the specified packet in the processing step. Is a code processing method.

The invention according to claim 12
A code processing method according to the invention of claim 11,
For the tile determined to have a progression order change designation in the first determination step, the second determination step has the attribute of the outermost shell of the progression order corresponding to the first progression order change designation specified The code processing method is characterized in that when the attribute of the outermost shell of the for loop corresponding to the packet matches, it is determined that the designated packet is continuously arranged from the top packet.

The invention according to claim 13
A code processing method according to the invention of claim 11,
For tiles for which it is determined in the second determination step that the specified packets are continuously arranged from the top packet, the third determination step includes the step of the for loop corresponding to the first progression order change specification. When the range of the loop variable of the for loop corresponding to the specified packet is completely included in the range of the loop variable, it is determined that there is no change in the progression order in the array of the specified packet This is a code processing method.

The invention according to claim 14
A code processing method according to the invention of claim 9 or 11,
In the processing by the processing step for only the designated packet with respect to the tile of the code, reading of the packet of the tile into the first storage unit is performed in accordance with the progress of the processing. This is a characteristic code processing method.

  A fifteenth aspect of the invention is a program for causing a computer to execute each step in the code processing method according to any one of the ninth to fourteenth aspects, the first storage means in the code processing method and It is a program that uses the main memory of the computer as second storage means.

  A sixteenth aspect of the invention is a computer-readable information recording medium on which a program according to the fifteenth aspect of the invention is recorded.

ADVANTAGE OF THE INVENTION According to this invention, the process which acquires the pointer information for accessing the partial code | symbol designated by the user in a code | symbol can be performed efficiently and at high speed. That is,
(1) According to the first aspect of the present invention, when there is no change of the progression order in the code and the partial code specified by the user is continuously arranged from the first partial code, the specified partial code The process of acquiring the pointer information for can be executed efficiently and at high speed.
(2) According to the invention described in claim 2, even if there is a change of the progression order in the code, the partial code designated by the user is continuously arranged from the first partial code and is designated. When there is no change in the progression order in the partial code array, it is possible to efficiently and rapidly execute the process of acquiring pointer information for the designated partial code.
(3) According to the invention described in claims 3, 4, 0, and 10, for the tiles for which there is no JPEG2000 code progression order change designation, packets designated by the user are continuously arranged from the top packet. In addition, it is possible to efficiently and quickly execute the process of acquiring the pointer information for the designated packet.
(4) According to the invention described in claims 5-7 and 11-13, the partial codes designated by the user are continuously arranged from the top packet for tiles for which a JPEG2000 code progression order change is designated. In addition, when there is no change of the progression order in the designated packet array, the processing for obtaining the pointer information for the designated packet can be executed efficiently and at high speed.
(5) According to the inventions of claims 8 and 14, an increase in processing time due to useless packet reading can be suppressed.
(6) The code processing method according to any one of claims 9 to 14 is carried out by loading the program according to the invention according to claim 15 or the program recorded on the information recording medium according to the invention according to claim 16 into a computer. Can do. In other words, the computer can be caused to function as the code processing device according to the invention of claims 3-8.

  Embodiments of the present invention will be described below.

  The present invention can be implemented, for example, in a system as shown in FIG. In FIG. 18, reference numerals 100 and 101 denote personal computers (PCs), which can communicate with each other via a network (LAN, intranet, Internet, etc.) 102.

  The PC 100 has a general configuration in which a CPU 110, a main memory (RAM) 111, a hard disk device 112, a display device 113, an input device 114 such as a keyboard and a mouse, a network interface 115, and the like are connected to a bus 116. The PC 101 may have the same configuration.

  The present invention may take a form implemented on a single PC 100 or 101, or a form implemented on a client / server system using, for example, the PC 101 as a client and the PC 100 as a server. It is also possible to construct a client / server system by running client software and server software on a single PC 100 or 101, and the present invention may be implemented on such a system. It should be noted that each example described later can be implemented by dedicated hardware, and such an embodiment is naturally included in the present invention.

  19 to 22, FIG. 24, and FIG. 25 are flowcharts for explaining the first embodiment of the present invention. The procedures shown in these flowcharts are executed by software on the PC 100 (or PC 101) in FIG. A program for this purpose is stored in the hard disk device 112, loaded into the main memory (RAM) 111, and executed by the CPU 110. The processing target is a JPEG 2000 code, which is stored in the hard disk device 112. In addition, as a memory A described later, a partial area of the main memory 111 is used. Further, an array of structures P to be described later is placed on the main memory 111.

  Refer to FIG. First, a code to be processed is specified by the user, and a (desired) packet to be selected is specified by specifying a resolution level, a layer number, a component number, or the like (step 100).

This designation may be performed using the input device 114 of the PC 100 or may be performed from the client-side PC 101. The former corresponds to a case where the PC 100 decodes only packets up to a specified resolution level and displays an image having a lower resolution than the original image on the display device 113. In the latter case, for example, only packets up to a specified resolution level are transmitted from the server-side PC 100 to the client-side PC 101, and the client-side PC 101 decodes the packets and displays an image having a lower resolution than the original image. Applicable.
Next, the PC 100 performs a process of determining a default progression order of a code designated by the user (step 101). In this process, a default progression order is determined for each tile.

  Next, the PC 100 performs a POC detection process for checking whether or not a POC (Progression Order Change) is designated in the designated code (step 102).

  Then, it is determined whether or not POC has been detected for each tile (step 103), normal packet selection processing is executed for the tiles for which POC has been detected (step 104), and the first for tiles for which no POC has been detected. A high-speed packet selection process is executed (step 105).

  As already described in connection with the POC marker segment, when the POC marker segment is inserted in the main header or tile part header, at least two or more progression order changes are designated, that is, the packet This means that the progression order is changed at least once in the middle of the array.

  The default progression order determination process in step 101 will be described with reference to the flowchart shown in FIG.

In the JPEG2000 code, the default progression order is described in the parameter Sgcod of the COD marker segment (FIG. 13) in the main header and, if necessary, the tile part header (FIG. 16) of the first tile part. It is also described in the COD marker segment. Further, as described above, the default progression order is changed by the POC marker segment (FIG. 14) in the main header, and is changed by the POC marker segment in the tile part header as necessary. The priority of designation by each marker segment is designated by the COD marker segment of the main header (applied to all tiles) <designated by the COD marker segment of the tile part header (applied only to the tile) <main header Designation by POC marker segment (applicable to all tiles) <designation by POC marker segment in tile part header (applicable only to the tile)
The higher the priority, the later specified.

  Refer to FIG. First, the main header of the code designated by the hard disk device 112 is read into the main memory 111 (step 110).

  With reference to the main header, the progression order (D) specified in the COD marker segment in the main header is provisionally determined as the default progression order for all tiles (step 111). The next step 112 and subsequent steps are executed for each tile.

  First, the tile part header of the first tile part of the tile is read into the main memory 111 (step 112), and it is checked whether the COD marker segment is included in the tile part header (step 113). If the COD marker segment is not included (step 113, NO), the progression order (D) provisionally determined in step 111 is determined as the default progression order of the tile (step 114), and the COD marker segment is included. If so (step 113, YES), the progression order specified in the COD marker segment is determined as the default progression order for the tile (step 115).

  Next, the POC detection process in step 102 (FIG. 19) will be described with reference to the flowchart shown in FIG.

  In step 101 (FIG. 19), the main header read into the main memory 111 is referred to (step 120), and the presence / absence of the POC marker segment is checked (step 121). If a POC marker segment is included in the main header (step 121, YES), it is determined that all tiles have a POC (Progression Order Change) designation (step 122).

  If the POC marker segment is not included in the main header (step 121, NO), POC detection is performed for each tile. That is, the tile part header of the first tile part of the tile is read into the main memory 111 (step 123), and the presence / absence of the POC marker segment in the tile part header is checked (step 124). If the POC marker segment is included (step 124, YES), it is determined that the tile has a POC designation (step 125), and if the POC marker segment is not included (step 124, NO), the POC designation is determined for the tile. It is determined that there is not (step 126).

  Next, normal packet selection processing in step 104 (FIG. 19) will be described with reference to the flowcharts shown in FIGS. 22-1 and 22-2. This process is executed for each tile.

  First, all tile parts of the tile are read into the main memory 111, and only the packets are stored in the memory A in the order in which they are read (step 130). The tile part length required at this time is detected by referring to Psot (FIGS. 11 and 12) of the SOT marker segment in the tile part header.

  Next, a default progression order for the tile determined in step 101 (FIG. 19) is acquired (step 131).

  Next, the number of packets of the tile is calculated (step 132). An array B composed of structures P for the calculated number of packets is prepared on the main memory 111, and a fore loop of a default progression order of the tile is formed. By rotating this for loop, all elements of the array B ( The structure P) is initialized (step 133). As shown in FIG. 23, the structure P is a structure having a packet head position and a packet length as elements.

  The POC marker segment (FIGS. 14 and 15) in the tile part header of the first tile part of the tile is referred to, and the contents of the parameters for specifying the first progression order change, that is, the progression order and the layer, resolution, and component ” The first number (start position) and the last number (end position) are acquired (step 134). However, the first number (start position) of the layer is always 0 (see FIG. 15).

  Next, a for loop for attribute interpretation according to the parameters of the first progression order change designation is constructed and processing is started (step 135), and the start position and packet length of the packet to which the first progression order change designation is applied are set. A process of obtaining the data and storing it in the array B in a form sorted according to the default progression order of the tile is executed (step 136 to step 139).

The processing of step 134 to step 139 will be specifically described using the example shown in FIG. In the example of FIG. 10, the progression order in the first progression order change designation is LRCP.
for (layer = 0) {
for (resolution level = 0,1,2) {
for (component = 0,1,2) {
for (all precincts) {
Interpret the attributes of the packet, find the beginning position and length of the packet on the memory A,
This is sorted into array B according to the default progression order.
Store }
}
}
}
For loop processing like this is executed.

  First, the loop variables are initially layer number (L) = 0, resolution level (R) = 0, component number (C) = 0, precinct number (P) = 0 (in this example, resolution levels 0 and 1). The number of precincts = 1), and the storage position and length of the first packet in the memory A are elements of the array B corresponding to the attributes (L = 0, R = 0, C = 0, P = 0) (Step 137). Note that the length of the packet can be obtained by decoding the packet header, but when the PLT marker segment is included in the tile part header, it can be found by interpreting it (in this case, Decoding bucket headers is not necessary).

  The target position of the memory A moves to the head position of the second packet in the memory A (step 138), and the loop variable is updated (step 139). Here, since the number of precincts is 1, the component number (C) is updated to 1. Therefore, the second packet is interpreted as an attribute (L = 0, R = 0, C = 1, P = 0), and the start position of the packet and its length are stored in the element of the array B corresponding to this attribute. (Step 137). The position of interest moves to the start position of the third packet in the memory A (step 138), and the component number (C) of the loop variable is updated to 2 (step 139). Therefore, the head position and the length of the third packet are stored in the element of the array B corresponding to the attribute (L = 0, R = 0, C = 2, P = 0) (step 137). The attention position moves to the head position of the fourth packet in the memory A (step 138), and the loop variable is updated with the resolution level (R) set to 1 and the component number (C) set to 0 (step 139). Is stored in an element of the array B corresponding to the attribute (L = 0, R = 1, C = 0, P = 0) (step 137).

  When the same processing is repeated and the position of interest moves to the head position of the seventh and subsequent packets in the memory A, the loop variable is updated with the resolution level (R) of 2 and the component number (C) of 0. Since the number of precincts is 4 at the resolution level = 2, the precinct number (P) of the loop variable is updated in order of 0, 1, 2, 3 after this packet, and the component number (C) becomes 1 when this update is completed. Updated to Thereafter, the same processing is repeated until the 18th packet in the memory A, the target position moves to the head position of the 19th packet in the memory A, and the loop variables are L = 1, R = 0, C = 0, P When updated to = 0, it is determined that the processing of the for loop has been completed (step 136, Yes), and the processing proceeds to the processing illustrated in FIG.

  Refer to FIG. The POC marker segment in the tile part header of the next tile part of the tile is referred to, and the content of the parameter for specifying the next progression order change is acquired (step 141). Next, a for loop for attribute interpretation according to the parameter of the progression order change designation is constructed and processing is started (step 142), and the start position and the packet length of the packet to which the progression order change designation is applied are arranged in array B. Then, a process of storing the tiles in a sorted form according to the default progression order of the tile is executed (step 143 to step 147).

  The processing contents will be described again using the example shown in FIG. In the example of FIG. 10, the second progression order change is performed with the 19th packet, but the target position has already moved to the start position of the 19th packet in the memory A.

In this example, the progression order specified in the second progression order change is CPRL,
for (component = 0,1,2) {
for (all precincts) {
for (resolution level = 0,1,2) {
for (layer = 0,1) {
Interpret the packet attributes in memory A,
If the start position of the packet of that attribute is not already stored in array B,
Obtain the start position and packet length of the packet in memory A, and use this as the default.
Stored in array B according to the progression order
}
}
}
For loop processing like this is executed.

  Initially, since the loop variable is set to C = 0, P = 0, R = 0, L = 0, the attributes of the 19th packet in the memory A are (R = 0, L = 0, C = 0, P = 0), but the start position of the first packet has already been stored in the element of the array B corresponding to this attribute (step 144, YES). Therefore, the loop variable L is updated to 1 without moving the target position from the head position of the 19th packet in the memory A (step 147). This attribute (R = 0, L = 1, C = 0, P = 0) is a correct attribute of the packet, and the start position of the packet is not stored in the element of the array B corresponding to this attribute (step 144, NO), the head position and length of the 19th packet are stored in the element of the array B (step 145).

  Next, the target position is moved to the head position of the 20th packet in the memory A (step 147), and the loop variable is updated to L = 0 and R = 1 (step 147). At this time, the attribute (R = 1, Since the start position of the third packet is already stored in the element of the array B corresponding to L = 0, C = 0, P = 0) (step 144, YES), the loop is performed without moving the target position. The variable is updated to L = 1 (step 147). The attributes (R = 1, L = 1, C = 0, P = 0) at this time are correct attributes of the 20th packet, and the start position of the packet is not stored in the element of the array B corresponding to this attribute. Therefore (step 144, NO), the head position and length of the 20th packet are stored in the element of this array B (step 145), and the target position is moved to the head position of the 21st packet in the memory A.

  By repeating such processing, the leading positions and lengths of the 21st to 36th packets are sorted in the order of the default progression order of the tile (with the effect of changing the progression order removed). ) Stored in array B.

  When it is determined in step 143 that the processing of the for loop has been completed, the process returns to step 140. In this example, since the last progression order change designation processing for the tile has been completed, the packet selection processing for the tile is completed.

  As will be understood from the above description, the packet selection process is performed by using pointer information (packet head position and packet length) for accessing a desired packet in the memory A in a form that eliminates the influence of the progression order change. This is a process for obtaining on the array B. If such pointer information is obtained, a desired packet in the memory A is accessed by referring to the pointer information on the array B by turning a for loop such as [Step 5]. The packet can be decoded or transmitted to the client side, but the process is not shown in the above flowchart. The same applies to other packet selection processing described later.

  The pointer information stored in the array B can be selected depending on the application. That is, if it is desired to access the packet data in order to decode the packet data (the MQ code itself excluding the packet header from the packet), the “head position of the packet data” may be obtained instead of the “head position of the packet”. If you want to handle the entire packet including the packet header (for example, when you want to send a packet using JPIP), you can find the "head position of the packet header" as described above. In order to access the packet, instead of “packet length”, “the length of only the packet data” may be obtained, and if the entire packet including the packet header is to be handled (for example, in JPIP) If you want to send a packet), the above "packet length" (packet header Meta may seek length). This also applies to other packet selection process described later.

  Next, the first high-speed packet selection process in step 105 (FIG. 19) will be described with reference to the flowcharts shown in FIGS. This process is executed for each tile.

Refer to FIG. First, all tile parts of the tile are read into the main memory 111, and only the packets are stored in the memory A in the order of reading (step 150). The tile part length required at this time is detected by referring to Psot (FIGS. 11 and 12) of the SOT marker segment in the tile part header.

  Next, a default progression order for the tile determined in step 101 (FIG. 19) is acquired (step 151).

  Next, it is determined whether or not desired packets according to the user designation (for example, resolution level designation) are continuously arranged from the top packet (step 152). This determination process will be described with reference to the flowchart shown in FIG.

  Refer to FIG. The default progression order of the tile determined in step 101 and its parameters (layer, resolution, component start / end positions) are acquired (step 170), and specified by the user (for example, resolution level, number of layers, number of components) (Step 171), it is determined whether or not the attribute of the outermost shell of the default progression order substantially matches the attribute of the outermost shell of the for loop corresponding to the desired packet specified by the user (step 172). ). If it is determined that they substantially match, the determination result is set to YES (step 173), and if it is determined that they do not substantially match, the determination result is set to NO (step 174).

  For example, if the default progression order is RLCP or RPCL whose outermost shell attribute is a resolution level (R) and all packets up to a certain resolution level are specified by the user as desired packets, the desired Are continuously located in the outermost shell of the progression order (desired packets are continuously arranged from the top packet), the determination result is YES.

  Note that “the attribute“ substantially matches ”” is as follows. If the default progression order is LRCP but the number of layers is 1, the resolution of the progression order is substantially R because its outermost shell attribute is substantially R (substantially RCP). If all packets up to the level are designated by the user as desired packets, the desired packets are located substantially continuously in the outermost shell of the progression order (the desired packets are continuously arranged from the first packet). The determination result is YES.

  On the other hand, when the default progression order is LRCP and the number of layers is 2 or more, when a packet up to resolution level 1 is designated as a desired packet by the user, it is apparent from, for example, the packet arrangement sequence shown in FIG. Thus, since the desired packet is not continuously arranged from the top packet (arranged in a jump), the determination result is NO.

  FIG. 24 will be referred to again. When the determination result in step 152 is NO, the normal packet selection process similar to step 104 is executed (step 153). However, since there is no progression order change, the processing procedure is simpler. If the processing procedure is described with reference to FIG. 22-1, steps 130 to 133 are the same, but step 134 is omitted. In step 135, a for loop for attribute interpretation according to the default progression order parameters of the tile is formed (this is the same as the for loop configured in step 133), and processing is started. The process from step 136 to step 139 is the same. However, if it is determined in step 136 that the process of the for loop has ended, the packet selection process for the tile ends.

  FIG. 24 will be referred to again. When the determination result at step 152 is YES, the processing from step 154 is executed, and this processing is the substantial high-speed packet selection processing.

  First, the number of desired packets is calculated according to the user designation (resolution level designation or the like) (step 154). An array B of structures P for the calculated number of packets is prepared on the main memory 111, and all elements (structures P) of the array B are initialized (step 155).

  Next, a for loop for interpreting the packet attribute of the default progression order is constructed, the initial value and the final value of the loop variable are set by the user designation, the for loop processing is started (step 156), and the memory A The packet attributes are interpreted in order from the first packet in the middle, and the packet head position and the packet length are stored in the elements of the array B corresponding to the attributes (steps 157 to 160). When the process is completed up to the last packet of the desired packet, it is determined that the for loop process is finished (step 157), and the packet selection process for the tile is finished. As described above, in a tile without a progression order change designation, when a desired packet is continuously arranged from the top packet, only the desired packet is obtained and stored in the array B for the desired packet. Wasteful processing such as decoding of the packet header of other packets is eliminated, and efficient high-speed processing is achieved.

  As can be understood from the above description, this embodiment corresponds to an embodiment of a code processing device according to claims 1, 3, and 4. The function of the first determination means of the code processing device corresponds to steps 102 and 103 in FIG. 19, the function of the second determination means corresponds to step 172 in FIG. 25, and is designated by the processing means. The process for only the packet corresponds to step 156-160 in FIG. The first storage means corresponds to the memory A assigned to the main memory, and the second storage means corresponds to the array B placed in the main memory.

  Further, the description of the processing contents in this embodiment is also an explanation of the processing procedure of the code processing method according to claims 9 and 10. That is, this embodiment corresponds to an embodiment of the code processing method according to claims 9 and 10. The first determination step of the code processing method corresponds to steps 102 and 103 in FIG. 19, the second determination step corresponds to step 172 in FIG. 25, and only the designated packet in the processing step is targeted. The processing corresponds to step 156-160 in FIG. The first storage means corresponds to the memory A, and the second storage means corresponds to the array B.

  The processing shown in FIGS. 19 to 25 is executed by a program in the PC 100 (or 101), and it is obvious that such a program corresponds to an embodiment of the program according to claim 15.

  A second embodiment of the present invention will be described with reference to the flowcharts shown in FIGS. 26 to 29, FIG. 20, and FIG. The procedures shown in these flowcharts are executed by software on the PC 100 (or PC 101) in FIG. A program for this purpose is stored in the hard disk device 112, loaded into the main memory (RAM) 111, and executed by the CPU 110. The processing target is a JPEG 2000 code, which is stored in the hard disk device 112. In addition, as a memory A described later, a partial area of the main memory 111 is used. Further, an array of structures P to be described later is placed on the main memory 111.

  Refer to FIG. First, a code to be processed is specified by the user, and a (desired) packet to be selected is specified by specifying a resolution level, a layer number, a component number, or the like (step 200).

This designation may be performed using the input device 114 of the PC 100 or may be performed from the client-side PC 101. The former corresponds to a case where the PC 100 decodes only packets up to a specified resolution level and displays an image having a lower resolution than the original image on the display device 113. In the latter case, for example, only packets up to a specified resolution level are transmitted from the server-side PC 100 to the client-side PC 101, and the client-side PC 101 decodes the packets and displays an image having a lower resolution than the original image. Applicable.
Next, in the PC 100, a process of determining a default progression order of a code designated by the user is performed (step 201). In this process, a default progression order is determined for each tile. The processing procedure is as described with reference to the flowchart of FIG.

  Next, POC detection processing is performed in the PC 100 (step 202). The contents of this POC detection process will be described later with reference to FIG.

  Then, for each tile, a packet selection process according to the result of the POC detection process is executed. That is, if it is determined that there is no progression order change designation for the tile to be processed (step 203, NO), the first high-speed packet selection process is executed (step 204). If it is determined that there is a progression order change designation (step 203, YES), a second high-speed packet selection process is executed (step 205). Since the first high-speed packet selection process is as described with reference to the flowchart of FIG. 24, the description thereof will not be repeated. The second high-speed packet selection process will be described later.

  Next, the POC detection process in step 202 will be described with reference to the flowchart shown in FIG. The POC marker segment is searched with reference to the main header read into the main memory 111 (step 211). If a POC marker segment is found (step 211, YES), it is determined that there is a progression order change designation (step 212), and the parameters (E) of the progression order change applied to all tiles are acquired from the POC marker segment. (Step 213).

  Up to this point, the processing is related to the entire code, that is, all the tiles. However, the following processing is processing executed for each tile to be processed.

  If a POC marker segment is found in the main header (step 211, YES), the tile part header of the first tile part of the tile to be processed is read into the main memory after step 213, and the POC marker segment is searched (step 214). . If no POC marker segment is found in the tile part header (step 215, NO), the parameter (E) is set as the parameter of the progression order change applied to the tile (step 217). If a POC marker segment is found in the first tile part header (step 215, YES), the parameter of the progression order change (POC) applied to the tile is acquired from the POC marker segment (step 216).

  On the other hand, when the POC marker segment is not found in the main header (step 211, NO), the tile part header of the first tile part is read for the tile to be processed, and the POC marker segment is searched (step 218). ). If no POC marker segment is found (step 219, NO), it is determined that there is no designation of a progression order change for the tile (step 220). If a POC marker segment is found (step 219, YES), it is determined that there is a progression order change designation for the tile (step 221), and parameters of the progression order change applied to the tile from the POC marker segment in the tile part header. Is acquired (step 223).

  In this way, in this POC detection process, the presence / absence of a progression order change designation is determined, and when it is determined that there is a progression order change designation, the parameter is acquired.

  Next, the second high-speed packet selection process in step 205 (FIG. 26) will be described with reference to the flowcharts shown in FIGS. As described above, this process is executed for a tile that is determined to have a progression order change designation.

  Refer to FIG. First, all tile parts of the tile are read into the main memory 111, and only the packets are stored in the memory A in the order of reading (step 230). The tile part length required at this time is detected by referring to Psot (FIGS. 11 and 12) of the SOT marker segment in the tile part header.

  Next, the parameter of the first progression order change designation (already obtained in the POC detection process) of the tile is acquired (step 231), and the desired packet according to the user designation (for example, resolution level designation) is the first packet. Whether or not there is no change in the progression order in the desired packet arrangement is determined (step 152). This determination process will be described with reference to the flowchart shown in FIG.

  Refer to FIG. Parameters for specifying the first progression order change of the tile (progression order, layer, resolution, component start / end positions) are read (step 250), and then specified by the user (for example, the resolution level, number of layers, number of components) ) Is read (step 251), and whether or not the attribute of the outermost shell of the progression order corresponding to the first progression order change designation substantially matches the attribute of the outermost shell of the for loop corresponding to the user designation. Is determined (step 252). The contents of this determination are the same as those described in relation to step 172 in FIG. 25 (however, in step 152 and step 172, attention is paid to the default progression order of tiles).

  If it is determined in step 252 that they do not substantially match (step 252, NO), the final determination result is NO (step 253).

  If it is determined in step 252 that they substantially match (step 252, YES), that is, if a desired packet is continuously arranged from the first packet, the for loop corresponding to the parameter of the first progression order change designation It is determined whether or not the range of the loop variable of the for loop corresponding to the user designation is completely included in the range of the loop variable (step 254). That is, it is checked whether or not the progression order is changed again in the desired packet arrangement. If this inclusion relation is established (step 256, YES), the final determination result is YES (step 256). If the inclusion relationship is not established (step 256, NO), the final determination result is NO (step 255).

  Refer to FIG. 28 again. When the determination result at step 232 is NO, the normal packet selection process similar to step 104 is executed (step 153).

  On the other hand, if the determination result at step 232 is YES, the processing from step 234 onward is executed, and this processing is a high-speed packet selection processing without waste.

  First, the number of desired packets is calculated according to the user designation (resolution level designation or the like) (step 234). An array B of structures P for the calculated number of packets is prepared on the main memory 111, and all elements (structures P) of the array B are initialized (step 235).

  Next, a for loop for interpreting packet attributes corresponding to the progression order designated by the first progression order change of the tile is constructed, and initial values and final values of loop variables are set by the user designation (step 236). The loop is rotated to interpret the packet attributes in order from the first packet in the memory A, and the process of storing the packet head position and the packet length in the element of the array B corresponding to the attribute is executed (steps 237 to 240). When the process is completed up to the last packet of the desired packet (step 237, YES), the packet selection process for the tile is finished. As described above, the packet selection processing for storing the pointer information (packet head position and packet length) for only the desired packet in the array B does not involve useless processing such as decoding of the packet header of the packet other than the desired packet. Therefore, it can be executed efficiently and at high speed.

  As can be understood from the above description, this embodiment corresponds to an embodiment of a code processing device according to claims 2, 5, 6 and 7. The function of the first determination means of the code processing apparatus corresponds to steps 202 and 203 in FIG. 26, the function of the second determination means corresponds to step 252 in FIG. 29, and the function of the third determination means is 29 corresponds to step 254 in FIG. 29, and the process for only the packet designated by the processing means corresponds to step 236-240 in FIG. The first storage means corresponds to the memory A assigned to the main memory, and the second storage means corresponds to the array B placed in the main memory.

  Further, the description of the processing contents in this embodiment is also an explanation of the processing procedure of the code processing method according to claims 11, 12, and 13. That is, this embodiment corresponds to an embodiment of the code processing method according to claims 11, 12, and 13. The first determination step capability of the code processing method corresponds to steps 202 and 203 in FIG. 26, the second determination step corresponds to step 252 in FIG. 29, and the third determination step corresponds to step 254 in FIG. Further, the processing corresponding to only the packet designated by the processing step corresponds to step 236-240 in FIG.

  In addition, the first high-speed packet selection process of step 204 in the present embodiment is the same process as step 105 in the first embodiment. Therefore, this embodiment is also an embodiment of the code processing device according to claims 1, 3 and 4 and the code processing method according to claims 9 and 10.

  The processing shown in FIGS. 26 to 29 is executed by a program in the PC 100 (or 101). It is also clear that such a program corresponds to an embodiment of the program according to claim 15.

  A third embodiment of the present invention will be described. In the third embodiment, the contents of the second high-speed packet selection process (FIG. 28) in the second embodiment are partially changed as shown in the flowchart of FIG. Other than this, the second embodiment is the same as the second embodiment.

  The difference between FIG. 30 and FIG. 28 is that only the first tile part of the tile is read in step 230A and only the packet is stored in the memory A. The step 300 added after step 237 has the target position in the memory A. When the determination result is YES, the next one tile part is read in step 301, and only that packet is added and stored following the last packet in the memory A. And continue processing.

  That is, in the third embodiment, only the first tile part packet is stored in the memory A first. If the determination result in step 232 is YES, packet selection is advanced while additionally reading necessary tile parts one by one in accordance with the progress of packet selection. If the pointer information for all desired packets is stored in the array B (step 237, YES), the subsequent tile parts are not read.

  In this way, in the packet selection process for only the desired packet designated by the user, when the reading of the tile packet into the memory A is performed in units of tile parts according to the progress of the process, Compared with the case where the packets of all tile parts of the tile are read into the memory A, the packet selection processing time can be reduced by the time required for the unnecessary packet reading processing. The division reading unit is not limited to tile part units.

  As can be understood from the above description, this embodiment corresponds to an embodiment of the code processing device according to claim 8 and the code processing method according to claim 14. A program for this embodiment corresponds to an embodiment of the program according to claim 15.

  Embodiment 4 of the present invention will be described. In the fourth embodiment, in the first high-speed packet selection process in the first or second embodiment, as in the third embodiment, the tile packet is read into the memory A in accordance with the progress of the process. This is done by dividing into tile parts. This will be described with reference to FIG.

  In step 150, only the packet of the first tile part of the tile is read into the memory A. Next to step 157, a determination step similar to step 300 (FIG. 30) is added. When it is determined YES in this determination step, step 301 (FIG. 30) is used to additionally read the packet of the next tile part into memory A. Similar steps are added.

  The effect of such packet division reading is as described in the third embodiment. The division reading unit is not limited to tile part units.

  Other than this, the second embodiment is the same as the second or third embodiment, and a description thereof is omitted.

  It is obvious that this embodiment corresponds to an embodiment of the code processing device according to claim 8 and the code processing method according to claim 14. A program for this embodiment corresponds to an embodiment of the program according to claim 15.

  The embodiment that handles JPEG2000 codes has been described above. However, even for codes other than JPEG2000, in the same way as JPEG2000 codes, a device that handles codes that are composed of partial codes arranged in accordance with a progression order and that allow the change of the progression order in the arrangement of partial codes. In contrast, it is clear that the present invention can be applied.

It is a block diagram for demonstrating the encoding algorithm of JPEG2000. It is explanatory drawing of a tile, a precinct, and a code block. It is a figure which shows the example of a subband division | segmentation. It is a figure which shows the example of a layer division | segmentation. It is a figure which shows five kinds of progression orders. It is a figure which shows the outline | summary of a layer progressive code. It is a figure which shows the packet arrangement | sequence example of LRCP. It is a figure which shows the outline | summary of a resolution progressive code | symbol. It is a figure which shows the packet sequence example of RLCP. It is a figure which shows the structure of a SOT marker segment. It is a figure which shows the structure of a SOT marker segment. It is a figure which shows the content of the parameter of a SOT marker segment. It is a figure which shows the structure of a COD marker segment. It is a figure which shows the structure of a POC marker segment. It is a figure which shows the content of the parameter of a POC marker segment. It is a block diagram of the tile part header of the first tile part. It is a figure which shows the structure of a PLT marker segment. It is a figure which shows the content of the parameter of a PLT marker segment. It is a block diagram which shows the system configuration example which concerns on embodiment of this invention. 3 is a flowchart for explaining an overall processing flow of the first embodiment; 20 is a flowchart of default progression order determination processing in FIG. 19. It is a flowchart of the POC detection process in FIG. 20 is a flowchart of normal packet selection processing in FIG. It is a flowchart following FIG. It is explanatory drawing of the structure. 20 is a flowchart of first high-speed packet selection processing in FIG. 19. It is a flowchart of the continuity determination process in FIG. 12 is a flowchart for explaining the overall processing flow of the second and third embodiments. It is a flowchart of the default progression order determination process in FIG. It is a flowchart of the 2nd high-speed packet selection process in FIG. It is a flowchart of the continuity determination process in FIG. 10 is a flowchart of second high-speed packet selection processing in Embodiment 3.

Explanation of symbols

100 Personal computer (server)
101 Personal computer (client)
102 network 110 CPU
111 RAM
112 Hard Disk Device 113 Display Device 114 Input Device 115 Network Interface

Claims (16)

A code processing device that handles codes that are composed of partial codes arranged in accordance with a progression order and that allow change of the progression order in the arrangement of partial codes,
Processing for obtaining pointer information for accessing each partial code of the code stored in the first storage means, and storing the pointer information in the second storage means in a form sorted according to one progression order. Processing means to perform,
First determination means for determining whether or not there is a change in progression order in the array of partial codes of the code;
A second determination means for determining whether or not the partial code designated by the user of the code is continuously arranged from the first partial code;
It is determined by the first determination means that there is no change in progression order, and the second determination means determines that the designated partial code is continuously arranged from the first partial code of the code. In such a case, the processing means performs the processing only on the designated partial code of the code. A code processing device that handles codes that are composed of partial codes arranged in accordance with a progression order and that allow change of the progression order in the arrangement of partial codes,
Processing for obtaining pointer information for accessing each partial code of the code stored in the first storage means, and storing the pointer information in the second storage means in a form sorted according to one progression order. Processing means to perform,
First determination means for determining whether or not a progression order in the code is changed;
Second determination means for determining whether or not the partial code specified by the user of the code is continuously arranged from the first partial code;
A third determination unit for determining whether or not the progression order is changed in the specified partial code array;
When it is determined by the first determination means that there is a change in the progression order in the code, the designated partial code is continuously arranged from the first partial code of the code. And when the second determination means determines that there is no change in the progression order in the array of the specified partial codes, the processing means only performs the specified partial codes. The code processing apparatus is characterized in that the process is performed on a target. A code processing apparatus that handles JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing means,
First determination means for determining whether or not a progression order change is designated for each tile of the code;
A second determination unit configured to determine whether or not packets designated by the user are continuously arranged from the top packet for each tile of the code;
For the tile of the code that has been determined by the first determination means that there is no progression order change designation, it is determined by the second determination means that the designated packets are continuously arranged from the top packet. In such a case, the processing means performs the processing only on the designated packet.   For the tile of the code that has been determined by the first determination means that there is no progression order change designation, the second determination means uses the fore in which the attribute of the outermost shell of the default progression order corresponds to the designated packet. 4. The code processing device according to claim 3, wherein when the attribute of the outermost shell of the loop is matched, it is determined that the designated packet is continuously arranged from the head packet. A code processing apparatus that handles JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing means,
First determination means for determining whether or not a progression order change is designated for each tile of the code;
Second determination means for determining whether or not packets designated by the user are continuously arranged from the top packet for each tile of the code;
Third determination means for determining whether or not there is a change in the progression order in the specified packet arrangement for each tile of the code,
For the tile determined to have a progression order change designation by the first determination means, the second determination means determines that the specified packet is continuously arranged from the top packet, and When the third determination unit determines that there is no change in the progression order in the specified packet arrangement, the processing unit performs the process only on the specified packet. A code processing device.   For the tile determined to have a progression order change designation by the first determination means, the second determination means specifies the attribute of the outermost shell of the progression order corresponding to the first progression order change designation. 6. The coding process according to claim 5, wherein when the attribute of the outermost shell of the for loop corresponding to the received packet matches, it is determined that the designated packet is continuously arranged from the top packet. apparatus.   For the tile for which the second determining means determines that the specified packet is continuously arranged from the first tile, the third determining means is configured to specify a for loop corresponding to the first progression order change specification. When the range of the loop variable of the for loop corresponding to the specified packet is completely included in the range of the loop variable, it is determined that there is no change in the progression order in the array of the specified packet The code processing apparatus according to claim 5, wherein   In the processing by the processing means for only the designated packet with respect to the tile of the code, reading the packet of the tile into the first storage means is performed in accordance with the progress of the processing. 6. The code processing device according to claim 3, wherein the code processing device is characterized. A code processing method for handling JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing steps,
A first determination step for determining whether a progression order change is specified for each tile of the code;
A second determination step for determining whether or not the packet designated by the user is continuously arranged from the top packet for each tile of the code;
For the tile of the code determined to have no designation of progression order change in the first determination step, it is determined in the second determination step that the specified packet is continuously arranged from the top packet. In this case, the code processing method is characterized in that the processing is performed only on the designated packet in the processing step.   For the tile of the code that is determined to have no designation of a progression order change in the first determination step, the second determination step has an attribute of an outermost shell of a default progression order corresponding to the specified packet. The code processing method according to claim 9, wherein when the attribute of the outermost shell of the for loop matches, the designated packet is determined to be continuously arranged from the top packet. A code processing method for handling JPEG2000 codes,
Pointer information for accessing each packet of the code stored in the first storage means is obtained, and processing for storing the pointer information in the second storage means in a form sorted according to one progression order is performed. Processing steps,
A first determination step of determining whether or not a progression order change is specified for each tile of the code;
A second determination step of determining whether or not the packet designated by the user is continuously arranged from the top packet for each tile of the code;
A third determination step for determining whether or not there is a change in the progression order in the specified packet arrangement for each tile of the code;
For tiles determined to have a progression order change designation in the first determination step, it is determined in the second determination step that the specified packet is continuously arranged from the top packet, and When it is determined in the third determination step that there is no change in progression order in the specified packet arrangement, the processing is performed only on the specified packet in the processing step. A code processing method.   For the tile determined to have a progression order change designation in the first determination step, the second determination step has the attribute of the outermost shell of the progression order corresponding to the first progression order change designation specified 12. The code processing method according to claim 11, wherein when the attribute of the outermost shell of the for loop corresponding to the packet matches, it is determined that the designated packet is continuously arranged from the top packet. .   For tiles for which it is determined in the second determination step that the specified packets are continuously arranged from the top packet, the third determination step includes the step of the for loop corresponding to the first progression order change specification. When the range of the loop variable of the for loop corresponding to the specified packet is completely included in the range of the loop variable, it is determined that there is no change in the progression order in the array of the specified packet The code processing method according to claim 11, wherein:   In the processing by the processing step for only the designated packet with respect to the tile of the code, reading of the packet of the tile into the first storage unit is performed in accordance with the progress of the processing. 12. The code processing method according to claim 9 or 11, which is characterized.   A program for causing a computer to execute each step in the code processing method according to any one of claims 9 to 14, wherein the main memory of the computer is used as the first storage means and the second storage means in the code processing method. A program that uses.   A computer-readable information recording medium on which the program according to claim 15 is recorded.

Images