JP2006345452A - Information processing device, its controlling method, computer program, and storage medium - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a technology to provide appropriate image data according to various applications executed on the client side. <P>SOLUTION: The information processing device comprises an accepting means which accepts the request for image data consisting of a plurality of layers, with the request including the specification of the number of layers; a judging means which judges whether the specified number of layers and the number of layers of the requested image data are the same or not; and a converting means which, when it is judged by the judging means that the number of layers are not the same, converts the image data into one consisting of the specified number of layers. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to a technique for transmitting and receiving hierarchical image data.

  In recent years, home digital cameras capable of capturing images of about 2 million to 5 million pixels have become widespread. Digital cameras for business use are in the 10 million pixel class. It is expected that digital cameras will continue to have higher definition.

  Also, an online album service that receives image data taken with a digital camera or the like via a network and publishes the image data on the network has become widespread. The album service is realized by a system including a server that publishes received image data and a client that accesses the server via a network and browses the published image data.

  In recent years, portable information processing terminals (portable information devices) such as PDA (Personal Digital Assistance) terminals have been used as client devices in such client / server systems.

  On the other hand, an upper-level application of the album service generally displays an interface with thumbnail images, accepts selection of an image to be enlarged from the displayed images, and displays the selected image larger than the thumbnail image. Has been adopted.

  However, in a configuration in which image data captured by a recent digital camera having a large number of pixels is downloaded from the server for every enlarged display, the image is displayed on the client terminal after the enlarged image is requested. By the long waiting time.

  In order to solve such a problem, it is composed of a plurality of layers (hierarchies) for each of a plurality of resolution levels, and further, the image data obtained by dividing and encoding the data of each resolution level into a plurality of tiles is stored in a server, A technique has been developed in which only partial data necessary for display is downloaded and displayed on the client. As such a technique, a configuration using JPEG2000 (Joint Photographic Experts Group 2000), JPIP (JPEG2000 image coding system-Part 9: Interactivity tools, APIs and protocols), or the like is known.

  JPEG2000 is an image encoding method standardized in 2001. According to this method, the image data is composed of a plurality of layers for each of a plurality of resolution levels, and is encoded so as to be further divided into tiles. Here, the layer is a group of encoded data grouped so that images can be viewed with a plurality of image quality. In the layer structure, the encoded data is arranged from the upper layer to the lower layer in the code order that contributes greatly to the amount of information transmitted to the viewer. The encoded data of a certain lower layer describes difference information with respect to the encoded data in an upper layer of that layer. For this reason, if the encoded data of the upper layer is decoded, an image capable of transmitting a certain amount of information can be provided. On the other hand, if the lower layer is decoded, a higher quality image can be provided. it can.

  JPIP is a protocol between a client and a server for accessing an image file encoded by the JPEG2000 system, acquiring and displaying image data in a desired unit such as a layer, a resolution level, or a tile. API (Application Interface), tools, etc. are standardized, and specifications are currently being formulated.

  As a configuration using JPEG2000, Patent Document 1 discloses a system that transmits / receives partial data of image data encoded by JPEG2000 using a server / client. In this configuration, the client determines which part of the codestream stored in the server is already stored in the client's buffer, and requests the server for the portion of compressed data that is not yet stored in the buffer. On the other hand, the server extracts the partial data of the requested compressed data and returns it to the client. The client acquires the image by integrating the received data and the data already stored in the buffer.

  Patent Document 2 discloses a technique for displaying JPEG2000 code data stored on the server side in a progressive manner on the client side. In this configuration, the client issues a request specifying the desired resolution level and sends it to the server. The server extracts subband code data of the resolution level designated by the client from the stored image file and transmits it to the client. The client restores the image data based on the decoded subband coefficient of the resolution level of the displayed image and the subband coefficient obtained by decoding the code data received from the server. And progressive display is realized.

  Patent Document 3 discloses a configuration in which a part of JPEG2000 image data is cached at a client and JPEG2000 encoded data is created from the cache data.

  In the configuration using JPEG2000 as described above, the image size (resolution level), layer, and partial area (tile) data desired by the user is stored on the server side in accordance with a request from the client. Extract from data and send / receive.

  In the above configuration, in order to efficiently transmit and receive JPEG 2000 image data between the server and the client, the client needs to cache (save) the received data. This is because in JPEG2000 encoded data, image data at a certain resolution level is expressed as a difference with respect to image data at a resolution level one level lower than the resolution. In addition, as described above, the encoded data of a certain lower layer is configured as a difference with respect to the encoded data in an upper layer of the layer.

In this way, when data that has already been received is cached on the client side to enlarge or improve image quality, the data sent and received between the client and server is the difference data from the received data. It becomes only. Thereby, the amount of communication data between the client and the server can be reduced.
JP 2003-23630 A Japanese Patent Laid-Open No. 2004-40673 JP 2003-179760 A

  However, in the above conventional configuration, it is necessary to design the client so as to correspond to the number of layers constituting the image data stored in the server. If the number of layers constituting the image data stored in the server is different from the number of layers assumed by the client, the designed usability may not be satisfied.

  For example, when a JPEG2000 image encoded to have five image quality is stored on the server side, a client that executes an application having a UI having three image quality options issues a request to the server. In some cases, it is necessary to map five image quality levels in three stages. Conversely, when a JPEG2000 image encoded to have two image quality is stored on the server side, a client that executes an application having a UI having three image quality options for this server When making a request, the client can select only two image quality instead of three.

  As described above, in the conventional configuration, there is a case where a service reflecting the intention of the client UI designer cannot be provided.

  The present invention has been made in view of the above problems, and provides a technique that makes it possible to provide appropriate image data according to various applications executed on a client.

According to the present invention,
An accepting means for accepting a request for image data composed of a plurality of layers, at least including a designation of the number of layers;
Determination means for determining whether or not the specified number of layers matches the number of layers of the requested image data;
An information processing apparatus is provided, comprising: conversion means for converting the image data into image data composed of the specified number of layers when the determination means determines that they do not match. The

  ADVANTAGE OF THE INVENTION According to this invention, the technique which makes it possible to provide suitable image data according to the various applications performed on a client can be provided.

  Embodiments according to the present invention will be described below in detail with reference to the accompanying drawings. However, the constituent elements described in this embodiment are merely examples, and are not intended to limit the scope of the present invention only to them.

[First Embodiment]
The server / client system of this embodiment performs communication by maintaining a session between the server / client. The server holds a plurality of JPEG2000 files that have already been generated, converts JPEG2000 data based on the number of layers (image quality, hierarchy) designated by the client, and converts the JPEG2000 data until the session is completed. The data is held, and the data is extracted from the converted JPEG2000 data and returned in response to a request from the client. Then, the server holds the information (file name, resolution, image quality, etc.) of the transmitted data until the maintenance of the session is canceled.

  The client acquires the number of layer (image quality) options provided by the service of the upper application that handles JPEG2000 images, and notifies the server of the number of options. Thereafter, based on the display request from the application, the server requests JPEG2000 image data, caches the returned data, and passes the display image to the application. In the configuration of the present embodiment, a JPEG2000 file is assumed as data to be communicated. However, any image data may be used as long as it is layered, that is, encoded as a plurality of layers. The configuration of the present embodiment can also be applied to.

(Hardware configuration of information processing device)
FIG. 1 is a block diagram showing a hardware configuration of a server and a client in the configuration of the present embodiment. Each of the server and the client is an information processing apparatus realized by, for example, a personal computer (PC), a workstation (WS), a mobile phone, a PHS, or a personal digital assistant (PDA).

  In FIG. 1, a CPU 101 controls the operation of the entire system and executes a program stored in the primary storage device 102. The primary storage device 102 is a memory such as a RAM or a ROM, and reads and stores programs stored in the secondary storage device 103.

  The secondary storage device 103 is, for example, a mass storage device such as a hard disk. Generally, the capacity of the primary storage device 102 is smaller than the capacity of the secondary storage device 103, and programs and data that cannot be stored in the primary storage device 102 are stored in the secondary storage device 103. Data that must be stored for a long time is also stored in the secondary storage device 103. In the present embodiment, the program is stored in the secondary storage device 103, read into the primary storage 102 when the program is executed, and the CPU 101 executes the execution process.

  Note that the primary storage device 102 and the secondary storage device 103 may each be configured by, for example, a predetermined medium and an external storage drive for realizing access to the medium. As such a medium, for example, a flexible disk (FD), a CD-ROM, a CD-R, a CD-RW, a PC card, a DVD, an IC memory card, an MO, a memory stick, and the like can be adopted.

  The input device 104 is a device that receives an instruction input from a user, and corresponds to, for example, a mouse or a keyboard. An interrupt signal is sent to a program or the like based on an instruction input. The output device 105 is a display device that outputs a response of the information processing apparatus, and can be configured by, for example, a monitor (display) or a printer.

  The I / F 106 is an interface, and the information processing apparatus exchanges data with an external device via the I / F 106. The system bus 107 plays a role in managing the flow of data in the information processing apparatus.

  In addition, it can also be comprised as an alternative of a hardware apparatus with the software which implement | achieves a function equivalent to the above each apparatus.

  In the present embodiment, for convenience of explanation, a configuration in which the information processing apparatus corresponding to the present embodiment is realized by one apparatus will be described. However, the information processing apparatus may be realized by a configuration in which resources are distributed to a plurality of apparatuses. For example, storage and calculation resources may be distributed in a plurality of devices. Alternatively, resources may be distributed for each component virtually realized on the information processing apparatus, and parallel processing may be performed.

(System configuration)
FIG. 2 is a schematic diagram showing an outline of a system in the configuration of the present embodiment. Reference numeral 201 denotes a client 1, and 202 denotes a client 2. Each has the hardware configuration described with reference to FIG. In this system, clients such as the client 1 (201) and the client 2 (202) can communicate with the server 204 via the network 203 regardless of wired or wireless. The server 204 includes a large-capacity storage device 205 that stores an image file composed of a plurality of layers for each resolution level. The large-capacity storage device 205 is realized by, for example, a hard disk. The hard disk 205 stores image data composed of a plurality of layers encoded by the JPEG2000 encoding method. The clients 201 and 202 sequentially receive layers from the JPEG2000 image data stored in the server 204, and browse and save them.

  In addition, the server maintains and manages information on data transmitted to the client while maintaining a session with the client.

(Configuration of JPEG2000 encoded data)
Next, an outline of general JPEG2000 encoded data will be described with reference to FIG. FIG. 3 is a schematic diagram of JPEG2000 encoded data.

  As shown in FIG. 3, JPEG2000 encoded data is composed of head Main Header data 301 and one or more tile data 302.

  In the main header data 301, information about the coding conditions of the entire image such as the number of resolution levels and the number of layers is described.

  The tile data 302 includes a tile header 302 and encoded data 306, respectively. The tile header 302 is header data describing a coding condition of a tile.

  The encoded data 306 following the tile header 302 is composed of one or more encoded unit data called Packets 303.

  FIG. 3 exemplifies a JPEG2000 file in which packet data is recorded in accordance with Layer-Resolution level-Component-Position progression (LRCP). As shown in FIG. 3, in the case of conforming to LRCP, the encoded data is configured in the order of Layer / Resolution / Component / Position. This way of arranging data is called Progression Order. Further, the “Position” (position, position) described here is Precinct in the JPEG2000 encoded data.

  When Progression Order is LRCP as shown in FIG. 3, data is stored in each layer in ascending order of Resolution (resolution) number. The layer number corresponds to the S / N ratio with respect to the original image of the image to be restored. The smaller the layer number, the worse the S / N ratio. The maximum resolution number, layer number, and component number in one JPEG2000 file are preset by the encoder and encoded according to the parameters, and the information is stored in the encoded data. Yes.

  FIG. 4 is a diagram showing the relationship between layers and bit planes. The layer is a group of quantized DWT (Discrete Wavelet Transform) coefficients (bit planes) from the MSB (Most Significant Bit) side, and layer 0 includes a plurality of MSBs. The bit plane closer to the LSB (Least Significant Bit, the least significant bit) is included as the layer number increases. In the case of FIG. 4, an example in which the image is divided into three layers is shown, and the coarsest image in layer 0 is slightly improved in image quality with the data of layers 0 and 1, and layer 2 including layers 0, 1, and LSB When all of these are decoded, a high-quality image can be obtained. The way to divide bit planes is not fixed and depends on the encoding conditions.

  The packet body 305 is obtained by arranging the grouped bit plane groups shown in FIG. 4 in coding units called code blocks. The packet header 304 stores encoded data indicating the data length and data position of each code block with respect to the data included in the packet body 305.

  By using such JPEG2000 encoded data, the client can receive only necessary data from the server based on the required image quality without acquiring all the image data stored in the server. As a unit of user's received data, a JPEG2000 packet or a tile unit which is an encoding unit larger than the packet can be adopted.

  In this embodiment, a packet unit is assumed as a data unit received by the client from the server. FIG. 5 is a diagram showing a correspondence relationship between requests (requests) and responses (responses) in units of packets. The client 501 requests data by designating the tile number, resolution level, layer, component, and precinct number of the image to the server 502. The server 502 analyzes the code stream of the image 503, extracts packet data corresponding to the specified tile number, resolution level and layer, component, and precinct number, and sends it back to the client 501 in response.

(Configuration of JPIP response data)
Next, the structure of response data when data is transmitted and received using JPIP as packet data transmission units will be described with reference to FIGS. 6 and 7. FIG.

  FIG. 6 is a schematic diagram of the structure of the precinct data-bin. In JPIP, as shown by 601 in FIG. 6, response data (Response Data) is created based on a block of JPEG2000 packet data called “precinct data-bin”. The precinct data-bin is a block of data in which the packets of all layers that make up the resolution level rn of the precinct number pn and the component number cn in the tile number tn are arranged in an ascending order. is there.

  FIG. 7 shows an example of JPIP Response Data created using the Packet (tn, rn, cn, pn, 1) extracted from the precinct data-bin shown in FIG. FIG. 7 is a diagram illustrating an example of JPIP Response Data. Here, Packet (tn, rn, cn, pn, qn) indicates a packet whose resolution level of the tile tn is rn, the component number is cn, the precinct number is pn, and the layer number is qn. JPIP Response Data is composed of a message header 701 and a message body 703. The message header and message body are collectively called a JPIP message. A JPIP message created from precinct data-bin is called a precinct data-bin message, and a JPIP message created from a main header is called a main header data-bin message.

  The message body 703 of the precinct data-bin message stores JPEG2000 encoded data cut out from the precinct data-bin 601. For example, when creating the JPIP Response Data by extracting the Packet (tn, rn, cn, pn, 1) 603 in FIG. 6, the Packet (tn, rn, cn, pn, 1) 603 is stored in the message body 703. .

  The message header 701 is composed of four parameters. That is, the first parameter stores an identifier indicating whether or not the data contained in the message body 703 is a precinct data-bin.

The second parameter stores a precinct data-bin ID (PrID). This is a parameter uniquely determined from the tile number tn, the resolution level number rn, the component number cn, and the precinct number pn by the following equation.
PrID (tn, rn, cn, pn) = tn + (cn + s x (number of components)) x number of tiles
s = pn + tn × (number of precincts per tile at resolution level rn)
+ (Total number of precincts of tile tn from resolution level 0 to (rn−1)).

  The third parameter is an offset value PrOffset 602 in the response data-precinct data-bin. That is, the data in the message body 703 is a value indicating the number of bytes from which data in the precinct data-bin 601 of PrID (tn, rn, cn, pn) is equal to the value 602 in FIG. .

  The fourth parameter of message header 701 is the byte length of Response Data (response data), that is, the byte length of message body 703. That is, the value of ResLen [byte] 704 is stored in ResLen 702.

(Example of image data)
In the present embodiment, it is assumed that the server has a JPEG2000 image, and the client accesses this image using JPIP. The following is an example of the encoding conditions for JPEG2000 images held by the server in this embodiment.

[Original JPEG2000 image data held by the server]
<File name: sample.jp2>
Maximum image size: 1600 × 1200 [pixel]
Tile size: 256 x 256 [pixel]
Number of tiles: 35 = (7 × 5)
Number of layers: 2
Number of resolution levels: 3
Image size for each resolution level:
Resolution level 2: 1600 × 1200 pixel] (tile size: 256 × 256 [pixel])
Resolution level 1: 800 x 600 [pixel] (tile size: 128 x 128 [pixel])
Resolution level 0: 400 x 300 [pixel] (tile size: 64 x 64 [pixel])
<File name: example.jp2>
Maximum image size: 1600 × 1200 [pixel]
Tile size: 256 x 256 [pixel]
Number of tiles: 35 = (7 × 5)
Number of layers: 5
Number of resolution levels: 3
Image size for each resolution level:
Resolution level 2: 1600 × 1200 pixel] (tile size: 256 × 256 [pixel])
Resolution level 1: 800 x 600 [pixel] (tile size: 128 x 128 [pixel])
Resolution level 0: 400 x 300 [pixel] (tile size: 64 x 64 [pixel])
The difference between the above two files, sample.jp2 and example.jp2, is the number of layers. The former is encoded with 2 layers and the latter is encoded with 5 layers.

(Basic processing)
In the present embodiment, the server maintains the number of image data image quality (layers) provided from the client side (hereinafter referred to as the provided image quality number) prior to transmission / reception of image data while maintaining a session between the client and the server. The notification is acquired, and the number of image data layers held by the server is changed according to the value. Thereafter, image data is transmitted and received using JPIP.

  The operation of such a server will be described with reference to FIG. FIG. 8 is a flowchart showing a processing flow of the server apparatus. In addition, although the client of this embodiment assumes that the application which has three image quality choices is mounted, the application range of this structure is not restricted to this.

  First, in step S801, a session is started with a client. A known method such as TCP / IP can be applied to start the session.

  Next, in step S802, the client is inquired about the number M of provided image quality, and the number is acquired. In this embodiment, since the client is an application having three image quality options, M = 3.

  In step S803, a request from the client is received. The request includes information such as the URL of the server, the image file name, the resolution level, and the image quality (how far the layer is to be acquired). The provided image quality number M acquired in step S802 may be included in this request, for example.

  Next, in step S804, the request received in step S803 is analyzed. That is, information values such as server URL, image file name, resolution level, and image quality included in the request are acquired.

  In step S805, the image file name acquired in step S804 is acquired, and it is determined whether or not the request for the image file is the first access in this session. If it is the first access (YES in step S805), the process proceeds to step S806. If it is not the first time, that is, if the requested image file is a file accessed in this session (NO in step S805), step is performed. The process proceeds to S807. Here, it is determined whether or not the request is the first time based on whether or not a request in which the image file name or the identifier attached to the image data matches is received.

In this embodiment, the request sent from the client
http://www.image.com/JPIP.cgi?target=sample.jp2& ・ ・ ・
If so, it is access to sample.jp2,
http://www.image.com/JPIP.cgi?target=example.jp2& ・ ・ ・
If so, it is access to example.jp2. Hereinafter, the case where the first request is made for any of the image data, that is, the case where the process proceeds to step S806 will be exemplarily described.

  In step S806, a return code stream is set, that is, image data already stored in the server is converted into image data (return code stream) to be sent to the client. This setting process will be described later with reference to FIG. Then, the process proceeds to step S807.

  In step S807, based on the result analyzed in step S804, data to be returned is extracted from the return code stream set in step S806, and return data is created and transmitted. In step S807, for example, processing similar to processing in normal JPIP can be applied.

  In step S808, it is determined whether to close the session. When it is determined that the session is closed due to a request for closing the session from the client or when a predetermined time has elapsed since the start of the session and a timeout has occurred (YES in step S808), the process proceeds to step S809. If it is determined to maintain (NO in step S808), the process returns to step S803 and operates so that a request from the client can be received.

  In step S809, processing for closing the session with the client is performed. Next, in step S810, it is determined whether the return code stream and the encoded data of the original file are the same. If they are the same (YES in step S810), the flow (process) is terminated. If they are different (NO in step S810), the process proceeds to step S811. In step S811, since a return code stream is created separately from the original file, this return code stream is deleted. Then, the process ends.

(Return code stream setting process)
Next, the return code stream setting process in step S805 will be described with reference to FIG. FIG. 9 is a flowchart showing the flow of the return code stream setting process.

  First, in step S901, the layer number Q of the requested file, that is, the original file stored in the server is acquired. This value is obtained by analyzing the COD marker in the main header of the original file.

  FIG. 11 is a diagram schematically showing the configuration of the COD marker. As shown in FIG. 11, the COD marker is composed of five parts, COD, Lcod, Scod, SGcod, and SPcod. Among them, SGcod 1101 further includes three parts, 1102, 1103, and 1104. The first part 1102 describes the progression order of the code stream. The second part 1103 describes the number of layers. In the third part 1104, color conversion information is described. Therefore, in the present embodiment, the number of layers 2 is described in the second part 1103 of the SGcod 1101 of sample.jp2, and the number of layers 5 is described in 1103 of example.jp2.

  Next, in step S902, it is determined whether the provided image quality number M acquired in step S802 is equal to the value of the layer number Q acquired in step S901. If they are equal (YES in step S902), it is not necessary to convert the original code stream, so the process proceeds to step S906. If they are different (NO in step S902), it is necessary to convert the original code stream in accordance with the provided image quality number M. Since there is, the process proceeds to step S903.

  In step S906, since there is no need to convert the original code stream, the original file name is set as the return code stream name, and this flow (process) is terminated.

  In the above example, whether the request is for sample.jp2 (Q = 2) or the request for example.jp2 (Q = 5), the provided image quality number M is different from 3. The process proceeds to step S903.

  In step S903, the provided image quality number M and the layer number Q are compared. If the layer number Q is small (NO in step S903), the process proceeds to step S907. If the layer number Q is large (YES in step S903), step S903 is performed. The process proceeds to S904. In the case of the above example, if Q = 2 <M = 3 if the request is for sample.jp2, the process proceeds to step S907. If the request is for example.jp2, Q = 5> M = 3. Since there is, it will progress to step S904.

  In step S904, since the number of layers Q is larger than the image quality provision number M, layer composition processing for creating a file tmp_dec with the number of layers reduced to M is performed. For example, an original file name and a file name (e.g. example_3.jp2) reflecting the changed number of layers are attached to the file tmp_dec. For example, by using the name with the number of layers after conversion after the original file name, when another client with the same image quality provision number M issues a request to the same image file during a client session, This data can be reused. This tmp_dec creation, that is, layer synthesis processing will be described later with reference to FIG.

  In step S905, the return code stream name is set to tmp_dec created in step S904, and this flow (process) is terminated.

  In step S907, since the number of layers Q is smaller than the number M of provided image quality, the original image data is once decoded for re-encoding.

  In step S908, a file tmp_inc is generated by re-encoding the image data decoded in step S907 so that the number of layers is M. Similarly to tmp_dec, the file name tmp_inc uses the number of layers after the change to the original file name (e.g. sample_3.jp2). For example, a known method can be applied to the process of creating the file tmp_inc.

  Next, in step S909, tmp_inc created in step S908 is set in the return code stream name, and this flow ends.

  As described above, after the return code stream setting process is executed, the return code stream is a code stream in which the provided image quality number M and the layer number Q match.

(Layer composition processing)
Next, the file conversion processing for reducing the number of layers to M in step S904 will be described with reference to FIG. FIG. 10 is a flowchart showing the flow of the file conversion process. In the above example, this flow is executed when the client requests example.jp2.

  First, in step S1001, the main header is extracted from the original code stream, the number of layers is rewritten to M, and stored in a tmp_dec file. Specifically, the number stored in 1103 in the COD marker shown in FIG. This is because the number of layers of tmp_dec created by this flow is created to match the provided image quality number M. In the above example, since the value 5 is stored in the COD marker 1103, the value is rewritten to 3 by this processing.

  Next, in step S1002, a quotient b and a remainder x obtained by dividing the number Q of layers of the original code stream by the number M of provided image quality are obtained. In the case of the above example, since Q = 5 and M = 3, b = 1 and x = 2.

  In step S1003, the number of tiles TN of the original code stream is acquired. This can be easily calculated by analyzing the main header. In the above example, TN = 35.

  Next, in step S1004, an area for the variable t for the tile is secured in a predetermined storage device such as the temporary storage 102, and the value 0 is substituted and initialized.

  Next, in step S1005, an area for a variable q for counting the layer number of the original code stream is secured in a predetermined storage device such as the temporary storage 102, and is initialized by substituting the value 0.

  Next, in step S1006, an area for the variable nq for counting the layer number of tmp_dec is secured in a predetermined storage device such as the temporary storage 102, and the value 0 is substituted and initialized.

  Next, in step S1007, a layer q to a layer (q + b−1) of layer t (layer q, layer q + 1, layer q + 2,..., Layer (q + b−1)) is extracted from the original code stream. Process to convert to layer. Then, the converted layer is set as a layer nq of tmp_dec. For example, a method of extracting each packet body 305, rearranging the bit planes, and recreating the packet header can be employed for the process of making the plurality of layers into one. By adopting such a method, it is not necessary to perform inverse DWT (discrete wavelet transform), so that the conversion process for integrating layers is reduced.

  Next, in step S1008, b is added to the variable q, and 1 is further added to the variable nq.

  Next, in step S1009, nq and (M−x) are compared, and if they are the same value (YES in step S1009), the process proceeds to step S1010, and a different value, that is, nq has reached (M−x). If not (NO in step S1009), the process returns to step S1007, and the processes in steps S1007 and S1008 are repeated.

  As described above, in the processing of steps S1007 to S1009, (M−x) groups having b layers constituting the original codestream are created, and a set of layers constituting the group is created for each group. A process of combining into one layer is performed. Accordingly, in steps S1007 to S1009, the number of layers of the original code stream to which the process is applied is b × (M−x).

  In the case of the above example, since b = 1, q = (q + b−1) = q. Therefore, the target in step S1007 is one layer at a time. Further, since M = 3 and x = 2, once passing through step S1008, nq = 1 = (M−x) = (3-2), and the process proceeds to step S1010. That is, layer 0 of the original code stream corresponds to layer 0 even in tmp_dec.

  Next, in step S1010, the variables nq and M are compared. If the values are equal (YES in step S1010), the process proceeds to step S1013. If the values are different (NO in step S1010), the process proceeds to step S1011. If it is determined in step S1002 that the number Q of layers of the original code stream is divisible by the number M of provided image quality, the process proceeds to step S1013 without performing the processes in steps S1011 and S1012.

  In the above example, since the remainder x = 2 ≠ 0 obtained by dividing the number of layers Q (= 5) by the number of provided image quality M (= 3), the process proceeds to step S1011.

  In step S1011, the layer (layer q, layer q + 1, layer q + 2,..., Layer (q + b)) of layer q to layer (q + b) of tile t is converted into one layer, and is set as layer nq of tmp_dec. The layer conversion process can employ the same method as the process in step S1007.

  Next, in step S1012, (b + 1) is added to the variable q, and 1 is further added to the variable nq, and the process proceeds to step S1010.

  As described above, in the processing of steps S1010 to S1012, x groups are created in which (b + 1) layers constituting the original codestream exist, and one set of layers constituting the group is created for each group. Processing to compose the layer. Therefore, in steps S1010 to S1012, the number of layers of the original code stream to which the process is applied is (b + 1) × x.

  In addition, the total number of layers of the original code stream to which the synthesis process is applied is b × (M−x) + (b + 1) × x = bM + x = Q by the processes of steps S1007 to S1009 and steps S1010 to S1012. It will be appreciated that the process applies to all layers of the original codestream. In addition, by having comprised as mentioned above, the number of the layers which comprise a group is the same about each group, or differs by one.

  In the above example, when the process moves to step S1011 for the first time, q = 1, nq = 1, and b = 1 in step S1002, so that the layer converted from layer 1, layer 2 to one layer Becomes layer 1 of tmp_dec, and the layer converted from layer 3 and layer 4 to layer 1 becomes layer 2 of tmp_dec. Then, the process proceeds to step S1013.

  In step S1013, the tile header of tile t is rewritten. That is, when a plurality of layers are converted into one layer in step S1007 or step S1011, the packet data length before and after the conversion is different, so that the tile data length changes. Based on the changed data length of the tile, processing for updating the value of the tile header is performed.

  Next, in step S1014, data created from the tile t with the reduced number of layers is stored in tmp_dec. Specifically, the layer 0 to layer M created in step S1007 and step S1011 and the tile header rewritten in step S1013 are stored in tmp_dec.

  In step S1015, the tile variable t is incremented by one, and the flow advances to step S1016.

  In step S1016, the variable t is compared with the tile number TN. If the variable t and the number of tiles TN are the same value (YES in step S1016), it is determined that the conversion process has been completed for all tiles tile 0 to tile (TN-1), and this process ends. Conversely, if the variable t and the number of tiles TN are different (NO in step S1016), it is determined that there are still tiles to be converted, and the process returns to step S1005 and continues.

  As described above, since the server according to the present embodiment converts the number of layers of image data in accordance with the number of provided image quality notified from the client, the client performs operations such as mapping from the number of layers of the server to image quality options. Without having to do so, a JPEG2000 image having the same number of layers as the notified image quality option can be obtained. Also, there is no image quality that cannot be provided by the server among image quality options designed as UI on the client.

  Further, in the layer synthesis process, it is only necessary to decode the image to the point where the DWT coefficient is obtained without completely decoding the image, and to recreate the layer. Therefore, the load accompanying the conversion of the number of layers is small.

  Furthermore, since the server side stores the converted codestream from the start of the session with the client until the session is closed, the return time is set in the second and subsequent image data communication within the same session. It can be shortened.

  The conversion code stream is created for each session and deleted for each session. Therefore, since the server side does not store a huge number of code streams for one code stream, the server side storage capacity is not compressed.

  Of course, a storage device for holding the converted code stream for a long period of time may be configured in accordance with the application and purpose, and this data may be stored. In this case, since the return data can be created from the created code stream for other clients having the same number of provided image quality levels, the response time can be shortened.

  In this embodiment, it is necessary to maintain a session during communication between the server and the client. For this, for example, a known method such as TCP / IP can be applied. For example, a method of adding SSL information to an HTTP header, a method of maintaining a session based on a cookie using a stateless system, a method of using source IP address information, or the like can be applied. However, when a stateless system is used, the session close detection in step S808 in FIG. 8 is performed by the occurrence of a timeout event in which a predetermined time has elapsed without access.

[Second Embodiment]
In the first embodiment, when the image quality provision number M is larger than the layer number Q, the original JPEG2000 data is once decoded and re-encoded so that the layer number Q is obtained. However, as described with reference to FIG. 4, since the layers constituting the image data are composed of one or more bit planes, the position information of the boundaries of the bit planes constituting one layer is obtained for each packet. It may be configured to divide the number of layers into the image quality provision number M by acquiring and dividing the layers at bit plane boundaries based on the information. In the present embodiment, for example, it is assumed that a client whose image quality option number (image quality provision number) M is 3 requests sample.jp2 with the number of layers Q = 2.

  In the present embodiment, the process for setting the return code stream is different from that in the first embodiment. The basic processing is executed based on the flowchart of FIG. 8 as in the first embodiment.

  The return code stream setting process of this embodiment will be described with reference to FIG. FIG. 12 is a flowchart showing the flow of the return code stream setting process. However, here, the difference from FIG. 9 of the first embodiment will be mainly described, and the same processes as those of the first embodiment will be denoted by the same reference numerals and description thereof will be omitted.

  In FIG. 12, steps S901 to S906 are the same processing as in the first embodiment, and thus the description thereof is omitted.

  If it is determined in step S903 that the number Q of layers is smaller than the provided image quality number M (NO in step S903), the process advances to step S1201.

  In step S1201, for each packet, information on the position of image data delimiters (bit plane boundaries) that can divide one layer into a plurality of layers is acquired. This information may be stored as a separate file, but may be stored in the same file (image data file). In this embodiment, it is assumed that position information is stored in a unique format in a UUID box as vendor-defined information.

  In step S1202, with reference to the information acquired in step S1201, the layer of the image data stored in the server is divided and converted into a return code stream tmp_inc. This process will be described later with reference to FIG. After creating tmp_inc in step S1202, the process proceeds to step S909, where tmp_inc is set as the return code stream name, and this process ends.

(Layer division processing)
Next, a layer division process for dividing a layer will be described with reference to FIG. FIG. 13 is a flowchart showing the flow of the layer division process. However, steps that perform the same processing as the layer synthesis processing shown in FIG. 10 of the first embodiment are assigned the same numbers as in FIG. 10, and detailed descriptions thereof are omitted.

  First, in step S1001, as in the first embodiment, the main header is extracted from the original code stream, the number of layers is rewritten from Q to M, and stored.

  Next, in step S1301, as in the first embodiment, the quotient b and the remainder x when the image quality option number M is divided by the layer number Q are obtained. In the case of the above example, since Q = 2 and M = 3, b = 1 and x = 1. Then, the process proceeds to step S1003.

  Steps S1003 to S1006 are the same processes as those in FIG. 10 of the first embodiment, and a description thereof will be omitted. In the case of the above example, the number of tiles TN acquired in step S1003 is 35. When the process of step S1006 ends, the process proceeds to step S1302.

  In step S1302, it is determined whether the remainder x obtained in step S1301 is greater than zero. If the remainder x is greater than 0 (YES in step S1302), the process proceeds to step S1303. If the remainder x is not greater than x, that is, equal to 0 (NO in step S1302), the process proceeds to step S1305. That is, it is checked whether the number M of image quality options is divisible by the number Q of layers. If it is divisible (NO in step S1302), the process proceeds to step S1305. The processes of S1303 and step S1304 are repeated.

  In the case of the above example, since x = 1 at the time of entering the process from step S1006 to step S1302, the process proceeds to step S1303.

  In step S1303, the layer q of the tile t is set to (b + 1) by dividing the layer at the bit plane boundary based on the position information of the bit plane boundary that can be divided into the layers of each packet acquired in step S1201. The layers are divided into layers nq to layer (nq + b) of tile t of tmp_inc. That is, the packet header of the packet q is analyzed, and the position in the packet q corresponding to the point that can be divided into layers acquired in step S1201 is specified. The packet body is divided at the specified location, a packet header corresponding to each packet body is newly created, and the packet is divided by combining with the packet body.

  Next, in step S1304, the layer number counter q of the original code stream is incremented by 1, (b + 1) is added to the variable nq of the layer number of temp_inc, the remainder x is further decreased by 1, and the process returns to step S1302.

  In the case of the above example, since q = 0 and b = 1 at the time of entering step S1303 for the first time, layer 0 of the original codestream is divided into two layers, which become layer 0 and layer 1 of tmp_inc, respectively. Thereafter, in step S1304, q = 1, nq = 2, and x = 0, and the process returns to step S1302. Since x = 0 at the time of returning to step S1302, the process proceeds to step S1305.

  In step S1305, the layer q of the tile t is divided into b layers, and processing of layer nq to layer (nq + b-1) of tmp_inc is performed. Similarly to step S1303, this processing is also performed by dividing the layer at the boundary of the bit plane based on the position information of the boundary of the bit plane that can be divided into the layers of each packet acquired in step S1201.

  In step S1306, 1 is added to the variable q of the layer number of the original code stream, and b is added to the layer number variable nq of tmp_inc.

  In step S1307, it is determined whether or not the layer number variable nq of tmp_inc is equal to the number M of image quality choices. If nq = M (YES in step S1307), it is determined that the division into M layers has been completed, and the process proceeds to step S1013. If nq is not equal to M (NO in step S1307), it is determined that the layer of the original codestream needs to be further divided, the process returns to step S1305, and the processes of steps S1305 and S1306 are continued.

  In the case of the above example, since q = 1, nq = 2, and b = 1 when moving from step S1302 to step S1305, layer 1 of the original codestream is divided into one layer in step S1305. . In this case, since the number of layers does not change before and after the division, there is no need to divide layer 1 of the original code stream, and layer 2 of tmp_inc is used as it is.

  In step S1306, q = 2 and nq = 2 + 1 = 3. Since nq = M = 3 in step S1307, it is determined that nq and M are equal (YES in step S1307), and the process proceeds to step S1013. .

  Steps S1013 to S1016 are the same as the processing in FIG. 10 of the first embodiment, and thus description thereof is omitted.

  As described above, in this embodiment, the position information of the boundary of the bit plane that can be layer-divided for each packet is analyzed in advance, and the packet division processing is performed using this information in the layer division processing. As a result, the code stream conversion process can be simplified, and the conversion time can be further shortened. In other words, instead of re-encoding from a completely decoded state, the code stream conversion time is further reduced by performing packet division at the DWT coefficient stage based on the position information of the boundary of the bit plane that can be divided into layers. can do.

[Third Embodiment]
In the first and second embodiments, the code stream conversion is performed on the server side in accordance with the number of image quality options provided by the upper application of the client. This code stream conversion is not necessarily performed by the server, but may be configured to be performed by the client side. In this embodiment, the client creates a conversion code stream in accordance with the number of image quality options of the application. First, the layer of JPEG2000 encoded data in the server is mapped to the image quality option of the application. Thereafter, a JPIP request is created based on the application display request, and data is requested from the server. The data returned from the server is cached with the server side encoding conditions. When the display code stream is transferred from the cache data to the application, code stream conversion is performed in accordance with the number of image quality options. As in the second embodiment, the JPEG200 image data held on the server side includes bit plane boundary position information that can be divided into layers in each packet as vendor-defined information in the UUID box of each file. It shall be stored in its own format. The client performs code stream conversion using information on the division position (bit plane boundary position).

(Client processing)
A client that operates in this manner will be described with reference to FIG. FIG. 14 is a flowchart showing the flow of client processing.

  First, in step S1401, the number M of provided image quality options is acquired from the upper application on the client. Hereinafter, a case where there are three image quality option numbers of low, medium, and high will be described as an example.

  In step S1402, a display request for image data is acquired from the upper application. In this case, the requirements regarding the name of the image file to be displayed, the size of the entire image, the position and size of the partial area to be displayed, the image quality, and the like are acquired. Note that the number M of provided image quality options may be acquired in this requirement instead of in step S1401.

  Next, in step S1403, a file corresponding to the image data described in the request received from the application in step S1402 exists in a predetermined storage device (eg, temporary storage 102, secondary storage 103, etc.) on the client. It is determined whether or not to do. If cache data does not exist (YES in step S1403), the process proceeds to step S1404. If cache data exists (NO in step S1403), the process proceeds to step S1406.

  In step S1404, based on the requirements acquired in step S1402, image transmission request (request) information including the main header of the image to be displayed and each packet information is sent to the server. This packet information is information on the position where one layer can be divided into a plurality of layers, that is, position information on the boundary of the bit plane. In the present embodiment, this corresponds to the UUID box.

  In step S1405, the main header and packet information returned from the server are received and stored as a cache in a predetermined storage device (eg, temporary storage 102, secondary storage 103, etc.) on the client. Then, the process proceeds to step S1406.

  In step S1406, the cached main header is analyzed, and the number Q of layers constituting the image data received from the server is acquired. This is obtained by analyzing the COD marker.

  In step S1407, a correspondence relationship between the number of layers Q acquired in step S1406 and the number of provided image quality M acquired in step S1401 is created. The correspondence creation process will be described later with reference to FIG. In the case of the above example, if sample.jp2 is requested, layer 0 corresponds to the low-level and medium-level image quality, and layer 1 corresponds to the high-level image quality. If example.jp2 is requested, layers 0 and 1 correspond to the low level, layers 2 and 3 correspond to the middle level, and layer 4 corresponds to the high level.

  In step S1408, the display request image quality is mapped to a layer from the correspondence created in step S1407. When the display required image quality is associated with a plurality of layers, it is mapped to the highest image quality layer. In the above example, for example, when the application requests to display example.jp2 at a medium level, the layer 2 and the layer 3 are mapped to the layer 3 that is a high-quality layer.

  Next, in step S1409, the cache data is referred to, and it is determined whether or not there is a shortage of cached data in order to perform the display requested by the upper application. If it is determined that there is insufficient data (YES in step S1409), the process proceeds to step S1410. If it is determined that there is no insufficient data (NO in step S1409), the process proceeds to step S1412.

  In step S1410, a JPIP request is created and transmitted to the server. For the JPIP request creation processing, for example, processing similar to processing performed by a normal JPIP client can be employed.

  Next, in step S1411, response data from the server is received and cached. As for the cache method, for example, the method disclosed in Patent Document 3 may be used, or other methods may be used. The cache method is not the main point of this case, so the explanation is omitted. Then, the process proceeds to step S1412.

  In step S1412, a code stream for display is created from the cache data, and the display code stream is provided to the application that has issued the image display request. At this time, the number of layers Q is converted to be the same as the number M of provided image quality options. This can be realized by the same processing as in the first and second embodiments. That is, no conversion is performed when Q = M. When Q> M, the same processing as the processing (layer synthesis processing) shown in FIG. 10 is performed. In the case of Q <M, the same processing as the processing (layer division processing) shown in FIG. 13 is performed.

  In step S <b> 1413, the upper application receives the code stream created in step S <b> 1412, decodes the code stream, and displays an image on the output device 105.

  Next, in step S1414, it is determined whether or not there is a new display request. If there is a new display request (YES in step S1414), the process proceeds to step S1415, and if there is no display request (NO in step S1414). This flow is finished.

  In step S1415, a new display request from the application is acquired, and the process returns to step S1408.

(Correspondence creation process)
Next, the correspondence creation process between the number of layers Q and the number of provided image quality M in step S1407 will be described with reference to FIG. FIG. 15 is a flowchart showing the flow of correspondence creation processing.

  In step S1501, initialization is performed by substituting 0 into both the provided image quality counter i and the layer counter q. These values are temporarily stored with an area secured in the temporary storage 102 or the like.

  Next, in step S1502, it is determined whether or not the number of layers Q and the provided image quality number M are equal. If they are equal (YES in step S1502), the process proceeds to step S1503. move on.

  In the processing after step S1503, since the number of layers Q and the number of provided image quality M are the same, processing for associating the layer with the provided image quality one-to-one is performed.

  In step S1503, the layer number q is substituted into the array m [i] that stores the layer number corresponding to each provided image quality level. This array m [i] is also temporarily stored with an area secured in the temporary storage 102 or the like.

  In step S1504, the provided image quality counter i and the layer counter q are each incremented by one. Next, in step S1505, the value of the provided image quality counter i is compared with the value of the provided image quality number M. If they are equal (YES in step S1505), this flow ends. If not (NO in step S1505), step S1503 is executed. The process is returned to step S1503 and steps S1504 are repeated.

  In the case of the above example, sample.jp2 has 2 layers, example.jp2 has 5 layers, and the number of provided image quality is 3, so it is a request to either sample.jp2 or example.jp2. Also, the process proceeds from step S1502 to step S1506 (NO in step S1502).

  In step S1506, the number of layers Q is compared with the number of provided image quality M. If Q is larger than M (YES in step S1506), the process proceeds to step S1507. If Q is smaller than M (NO in step S1506), the process proceeds to step S1514. In the case of the above example, if Q = 2 <M = 3 if the request is for sample.jp2, the process proceeds to step S1514. If the request is for example.jp2, Q = 5> M = 3. Since there is, it will progress to step S1507.

  In step S1507, the number of layers Q is divided by the number M of provided image quality, the quotient is b, and the remainder is x.

  Next, in step S1508, the numbers q to (q + b-1) of layer q to layer (q + b-1) are stored in the array m [i] for storing the layer numbers corresponding to the respective provided image quality levels. The array m [i] secures a necessary area in the temporary storage 102 and temporarily holds a value, for example.

  In step S1509, 1 is added to the provided image quality level counter i, and b is added to the layer counter q.

  In step S1510, the provided image quality level counter i is compared with the value obtained by subtracting the remainder x obtained in step S1507 from the provided image quality number M. If the values are equal (YES in step S1510), the process advances to step S1511. If the values are different (NO in step S1510), the process returns to step S1508, and the processes in steps S1508 and S1509 are repeated. By performing such processing, b layers are allocated to (M−x) image quality levels.

  In step S1511, it is determined whether the value x is greater than zero. If greater than 0 (YES in step S1511), the process proceeds to step S1512. If not (NO in step S1511), the flow ends.

In step S1512, layer q to layer (q + b) numbers q to (q + b) are stored in an array m [i] that stores layer numbers corresponding to the respective provided image quality levels.
In step S1513, 1 is added to the provided image quality level counter i, (b + 1) is added to the layer counter q, and the value of x is decreased by one.

  In other words, since x is the value of the remainder x obtained in step S1507, if Q ÷ M is divisible, this flow is terminated without executing steps S1512 and S1513, and if not divisible, The processes in steps S1512 and S1513 are repeated as many times as the remainder x.

  In the above example, when a request is made to example.jp2, since Q = 5 and M = 3, Q ÷ M = 5 ÷ 3 = 1 remainder 2. Therefore, processing for assigning layer 0 to the first level (level low) is performed by step S1511. Further, in steps S1511 to S1513, processing for assigning layer 1 and layer 2 to the second level (medium level) and assigning layer 3 and layer 4 to the third level (level high) is performed.

  As described above, in the present embodiment, when a request is made to sample.jp2, since Q = 2 <M = 3, the process proceeds from step S1506 to step S1514.

  In step S1514, the provided image quality number M is divided by the layer number Q, the quotient is b, and the remainder is x.

  Next, in step S1515, the number q of the layer q is substituted into an array m [i] to m [i + b-1] that stores the layer number corresponding to each provided image quality level. Similar to the above, the array m [i] is configured to reserve a necessary area in the temporary storage 102 and temporarily hold a value, for example.

  In step S1516, a process of adding b to the provided image quality level counter i is performed.

  Next, in step S1517, it is determined whether or not the value of x is greater than zero. If the value of x is greater than 0 (YES in step S1517), the process proceeds to step S1518. If not (NO in step S1517), the process proceeds to step S1520.

  In step S1518, the number q of the layer q is substituted into the array m [i] that stores the layer number corresponding to each provided image quality level.

  In step S1519, 1 is added to the provided image quality level counter i, and the value of x is decreased by one. Then, the process proceeds to step S1520.

  In step S1520, 1 is added to the layer counter q.

  In step S1521, the provided image quality level counter i is compared with the provided image quality number M. If the provided image quality level counter i is equal to the provided image quality number M (YES in step S1521), this flow ends. If not (NO in step S1521), the process returns to step S1515, and steps S1515 to S1520 are performed. Repeat the process. That is, up to the same number of layers as the remainder x obtained in step S1514, one layer is divided into (b + 1) provided image quality levels, and the remaining (Q−x) layers are b one layer. Will be divided at the provided image quality level.

  In the above example, when a request is made to sample.jp2, since Q = 2 and M = 3, M ÷ Q = 3 ÷ 2 = 1 and the remainder is 1. Therefore, layer 0 is divided and assigned to two provided image quality levels (level low and medium), and layer 1 is assigned to one provided image quality level (level high).

  As described above, in the configuration of the present embodiment, when the code stream conversion process is performed on the client side, the number of layers of the original code stream does not match the number of image quality levels assumed by the upper application of the client In this case, the host application on the client can acquire and display image data of the number of image quality levels designed in advance.

  In addition, when the code stream cached on the client is converted to the code stream to be passed to the application, it is converted to the number of image quality required by the application. Two cache data can be shared. That is, various code streams can be generated from the same cache data in accordance with various uses of the application. Therefore, the capacity of the client cache only needs to be large enough to store the original code stream.

[Fourth Embodiment]
In the first to third embodiments, a server / client system that transmits and receives JPEG2000 images in a fragmented manner via a network has been described. However, the image data is downloaded from a medium such as a CD-ROM or an external storage device connected to the client or provided in the client without passing through the network, and the image data is transferred to the host application and displayed. May be configured to convert the number of layers in accordance with the application.

(Download data conversion process)
Processing for downloading JPEG 2000 image data and converting the number of layers as necessary (download data conversion processing) will be described with reference to FIG. FIG. 16 is a flowchart showing the flow of download data conversion processing.

  In step S1601, the image quality number M provided by an application that uses (for example, displays) image data is acquired.

  In step S1602, all the image data files to be displayed are downloaded from a medium such as a CD-ROM or an external storage device.

  In step S1603, the main header of the image downloaded in step S1602 is analyzed, and the number Q of layers is acquired.

  In step S1604, image data is created by changing the layer number Q of the file downloaded in step S1602 in accordance with the provided image quality number M acquired in step S1601. For this process, for example, any one of the processes of the first to third embodiments can be adopted.

  In step S1605, the image data created in step S1604 is transferred to the upper application, and this flow ends. The host application that has received the image data can perform processing using the image data whose number of layers has been changed.

  In the configuration of the present embodiment, the image data is downloaded from the external storage device in units of files, the number of layers is changed based on the number of image quality levels assumed by the application (UI design), and then passed to the application. Therefore, the image data can be converted into the number of layers corresponding to the application by a single conversion process without being divided and distributed.

[Other Embodiments]
As described above, the exemplary embodiments of the present invention have been described in detail. However, the present invention can take an embodiment as, for example, a system, an apparatus, a method, a program, or a storage medium. You may apply to the system comprised from an apparatus, and may apply to the apparatus which consists of one apparatus.

  The present invention can also be achieved by supplying a program that realizes the functions of the above-described embodiment directly or remotely to a system or apparatus, and the computer of the system or apparatus reads and executes the supplied program code. Including the case where it is achieved.

  Therefore, since the functions of the present invention are implemented by a computer, the program code installed in the computer is also included in the technical scope of the present invention. That is, the present invention includes a computer program itself for realizing the functional processing of the present invention.

  In that case, as long as it has the function of a program, it may be in the form of object code, a program executed by an interpreter, script data supplied to the OS, or the like.

  As a recording medium for supplying the program, for example, floppy (registered trademark) disk, hard disk, optical disk, magneto-optical disk, MO, CD-ROM, CD-R, CD-RW, magnetic tape, nonvolatile memory card ROM, DVD (DVD-ROM, DVD-R) and the like.

  As another program supply method, a client computer browser is used to connect to an Internet homepage, and the computer program of the present invention itself or a compressed file including an automatic installation function is downloaded from the homepage to a recording medium such as a hard disk. Can also be supplied. It can also be realized by dividing the program code constituting the program of the present invention into a plurality of files and downloading each file from a different homepage. That is, a WWW server that allows a plurality of users to download a program file for realizing the functional processing of the present invention on a computer is also included in the present invention.

  In addition, the program of the present invention is encrypted, stored in a storage medium such as a CD-ROM, distributed to users, and key information for decryption is downloaded from a homepage via the Internet to users who have cleared predetermined conditions. It is also possible to execute the encrypted program by using the key information and install the program on a computer. In addition to the functions of the above-described embodiments being realized by the computer executing the read program, the OS running on the computer based on an instruction of the program is a part of the actual processing. Alternatively, the functions of the above-described embodiment can be realized by performing all of them and performing the processing.

  Furthermore, after the program read from the recording medium is written in a memory provided in a function expansion board inserted into the computer or a function expansion unit connected to the computer, the function expansion board or The CPU or the like provided in the function expansion unit performs part or all of the actual processing, and the functions of the above-described embodiments are realized by the processing.

It is the block diagram which showed the hardware constitutions of the server and client in the structure of this embodiment. It is the schematic diagram which showed the outline of the system in the structure of this embodiment. It is the schematic of the encoding data of JPEG2000. It is the figure which showed the relationship between a layer and a bit plane. It is the figure which showed the correspondence of the request and response of a packet unit. It is the schematic of the structure of precinct data-bin. It is a figure which shows an example of JPIP Response Data. It is the flowchart which showed the flow of the process of the server apparatus. It is the flowchart which showed the flow of the return code stream setting process. It is the flowchart which showed the flow of the file conversion process. It is the figure which showed the structure of the COD marker typically. It is the flowchart which showed the flow of the return code stream setting process. It is the flowchart which showed the flow of the layer division | segmentation process. It is the flowchart which showed the flow of the client process. It is the flowchart which showed the flow of the correspondence creation process. It is the flowchart which showed the flow of the conversion process of download data.

Claims (10)

An accepting means for accepting a request for image data composed of a plurality of layers, at least including a designation of the number of layers;
Determination means for determining whether or not the specified number of layers matches the number of layers of the requested image data;
An information processing apparatus comprising: conversion means for converting the image data into image data composed of the designated number of layers when the determination means determines that they do not match. The converting means includes
A plurality of the layers constituting the image data are classified into a group of the specified number of layers, and for each group, combining means for combining the set of layers constituting the group into one layer;
2. The conversion is performed using the synthesizing unit when the designated number of layers is smaller than the number of layers of the requested image data composed of the plurality of layers. The information processing apparatus described.   The information processing apparatus according to claim 2, wherein the number of the layers constituting the group is equal or different for each group. The layer constituting the image data is composed of one or more bit planes,
Holds the position information of the boundary of the bit plane constituting the layer in the device,
The converting means includes
When the specified number of layers is larger than the number of layers of the requested image data composed of the plurality of layers, the layers are divided at the boundary of the bit plane based on the position information. The information processing apparatus according to claim 1, wherein the conversion is performed. The information processing device is a server device connected to an external device via a network,
The accepting means accepts the request from the external device;
5. The information processing apparatus according to claim 1, further comprising a sending unit that sends the converted image data to the external apparatus. Further comprising application execution means for performing processing based on the image data;
The accepting means accepts the request from the application executing means,
The information processing apparatus according to claim 1, further comprising a delivery unit that delivers the converted image data to the application execution unit.   The information processing apparatus according to claim 1, wherein the image data including the plurality of layers is encoded data based on a JPEG2000 system. An accepting step of accepting a request for image data composed of a plurality of layers, at least including a designation of the number of layers;
A determination step of determining whether or not the specified number of layers matches the number of layers of the requested image data;
And a conversion step of converting the image data into image data composed of the specified number of layers when it is determined in the determination step that they do not coincide with each other. .   A computer program for causing a computer to function as the information processing apparatus according to claim 1.   A computer-readable storage medium storing the computer program according to claim 9.

Images