JP6003032B2 - Image compression method, image compression apparatus and system - Google Patents

Description

  The present invention relates to an image compression method, an image compression apparatus, and a system for compressing an image.

  In cloud computing, high-speed network communication is required due to the operation of many applications. In recent years, a client terminal is provided with a service of DaAS (Desktop as a Service) in which an operation command is sent to the server side, and the server side executes processing corresponding to the operation command. As an example of using such cloud computing, there is transfer of CAD images (desktop images) in the field of product design. This desktop image is generated by the cloud server and transferred to a client (particularly a thin client) terminal. At this time, in order to reduce the load on the network, the server side compresses and transfers the desktop image.

  For example, as a technique for image recognition that can be used for image compression or the like, there is a technique for extracting a character region by extracting an arrangement (run) of pixels having a certain length or more (see, for example, Patent Document 1 below). . As a technique for compressing a desktop image, there is a technique in which a screen is divided into small blocks, and a rectangle of the same color is searched and tiled in each block (for example, see Non-Patent Document 1 below). Also, there is a technology that uses a GPU (Graphic Processing Unit) specialized for image processing, divides the entire screen into a plurality of blocks, assigns one block of processing to one thread of the GPU, and performs parallel processing with a plurality of processors ( For example, see the following non-patent document 2.)

Japanese Patent Laid-Open No. 1-217583

Tristan Richardson, “The RFB Protocol”, [online], 26, November, 2010, RealVNC Ltd, [August 15, 2011 search], Internet <URL: http: // www. realvnc. com / docs / rfbproto. pdf> YongLIU, 2 other names, “gTiledVNC-a22 Mega-pixel Display Wall Desktop Usage GPUs and VNC”, Department of Computer Science, w23 years, 15 days. . ub. uit. no / munin / bitstream / handle / 10037/2959 / appendix_b. pdf>

  When using cloud computing, access from a large number of clients causes a high-load CAD application to operate simultaneously, and the CPU and GPU loads of the server increase correspondingly. Moreover, the parallel processing using GPU efficiently cannot be performed about the compression processing for compressing the above desktop images.

  That is, in the image compression processing according to the conventional technique, the GPU needs a large amount of memory comparison processing in order to search for pixels in the processing of each block. In a GPU specialized in image processing, memory access takes time, and the memory processing in the GPU is slower than the CPU. Therefore, when performing parallel processing by block division as described above, memory access takes time, and the total processing time cannot be shortened. As problems specific to parallel processors: Memory access is slow, especially when the memory access position is skipped in the memory comparison process. 2. The branch process has an adverse effect, and as an example, 32 threads proceed while synchronizing, so if one thread branches to a long search, the other threads must also wait for synchronization. Due to such a delay in processing time in the GPU, it takes time until transfer to the client, and it becomes impossible to quickly perform design work and the like on the client side.

  When using cloud computing in the field of product design, applications can operate comfortably without burdening the CPU and GPU on the server side, desktop image compression processing, etc. can be completed at high speed and transferred to the client A technique is required.

  The disclosed image compression method, image compression apparatus, and system solve the above-described problems, and an object thereof is to quickly and efficiently compress an image.

In order to solve the above-described problems and achieve the object, the disclosed technology detects the color of each pixel by compressing multiple parallel threads executed by the processor for each image data to be compressed. The same color continuous length of any one of RGB is obtained, the image data is compressed based on the information of the same color continuous length, the same color continuous length is divided into a plurality of screens, Including making the number of pixels of a small block correspond to the number of threads, performing simultaneous parallel processing of the plurality of threads, and obtaining the number based on the color of adjacent pixels detected by other threads in the same column .

  According to the disclosed image compression method, image compression apparatus, and system, there is an effect that image compression can be performed quickly and efficiently.

FIG. 1 is a diagram illustrating a system including an image compression apparatus according to an embodiment. FIG. 2 is a flowchart illustrating a procedure of image compression processing according to the embodiment. FIG. 3 is a schematic diagram of processing for creating a compression acceleration table performed by the GPU. FIG. 4 is a flowchart showing the procedure of the compression acceleration table creation process performed by the GPU. FIG. 5 is a flowchart showing a procedure of image compression processing performed by the CPU. FIG. 6 is a flowchart showing in detail the processing content related to the determination of the background color. FIG. 7 is a flowchart illustrating in detail the processing content for detecting a rectangle of the same color. FIG. 8 is a schematic diagram of compression processing performed by the CPU. FIG. 9 is a diagram showing an application example of a system using the image compression apparatus shown in FIG.

(System configuration example)
Hereinafter, preferred embodiments of the disclosed technology will be described in detail with reference to the accompanying drawings. FIG. 1 is a diagram illustrating a system including an image compression apparatus according to an embodiment. The system 100 includes a server 101 that functions as an image compression apparatus and a client 102. In this system 100, for example, the client 102 sends an operation command to the server 101, the server 101 executes processing corresponding to the operation command, and transmits data such as a CAD image (desktop image) corresponding to the operation command to the client 102. Use DaaS service.

  The client 102 includes a CPU 102a and a memory such as a ROM and a RAM (not shown), and transmits an operation command for a desired process to the server 101 via the network 110 by operating the keyboard 103, the mouse 104, or the like. The display 105 displays operation and processing contents.

  The server 101 includes a GPU 101a, a CPU 101b, a ROM, a RAM (not shown), and the like. The server 101 is connected to a disk device 120 in which a product design application, for example, a CAD application is stored in advance. When the server 101 receives an operation command from the client 102 via the network 110, the CPU 101 b and the GPU 101 a execute the CAD application, and sends a desktop image (CAD image) as an execution result to the client 102 via the network 110. To do. The client 102 displays the received desktop image on the display 105.

  The server 101 performs overall control of the entire process by the CPU 101b, and the GPU 101a executes image processing in a shared manner with the CPU 101b. The GPU 101a is composed of a multi-core processor, and simultaneously executes a plurality of threads in parallel when a program (CAD application) is executed.

(Desktop image compression content)
Next, the contents of the desktop image compression process executed by the server 101 will be described. In the server 101, the GPU 101a and the CPU 101b share a desktop image such as a CAD image with a large amount of data. The GPU 101a executes pre-processing related to desktop image compression (creation of a compression acceleration table described later), and the CPU 101b executes compression processing based on the information of the GPU 101a.

(Image compression processing procedure)
FIG. 2 is a flowchart illustrating a procedure of image compression processing according to the embodiment. The GPU 101a reads a desktop image to be transmitted to the client as a pre-processing of compression processing performed by the CPU 101b, creates a compression acceleration table, and outputs the compression acceleration table to the CPU 101b.

  First, the GPU 101a divides the entire screen of the desktop image transmitted to the client into predetermined blocks, for example, small blocks of a 16 × 16 image, and obtains N blocks (step S201). These N numbers are set corresponding to N (for example, 256) processors of the GPU 101a, for example. The server 101 can also be configured to extract only the difference from the desktop image transmitted to the client 102 last time when transmitting a new desktop image, and to perform compression processing on the desktop image of the difference, In this case, the amount of data on the network 110 can be further reduced.

  Next, parallel processing by N processors is started (step S202). Each process (step S203) performed by the N processors will be described. One processor specifies a block to be processed by its own processor from the process numbers (1 to N) (step S213), and the compression speed of the process block is increased. A table is created (step S214). Each of the N processors creates this compression acceleration table and transfers it to the CPU 101b. Thereafter, the CPU 101b executes a compression process using the compression acceleration table (step S204).

(About pre-processing performed by GPU)
FIG. 3 is a schematic diagram of processing for creating a compression acceleration table performed by the GPU. The GPU 101a starts activation of 256 threads simultaneously for one small block (16 × 16 pixels = 256 pixels) shown in FIG. At this time, regarding the X coordinate, M is the number of pixels arranged in the same color (the number of the same color sequence). In the example illustrated in FIG. 3, as a result of detecting each RGB color for each pixel for the top row, the R (red) pixel has the same color continuous length (Run Length) of 3 and G (green) in order from the left. The same color continuous length of the pixel is 5, the same color continuous length of the R (red) pixel is 3, the same color continuous length of the B (blue) pixel is 2, and the same color continuous length of the red pixel is 3. Suppose . In this case, it is the same color sequence number M = 5 per this one column. For example, if the average M per row is 5, M is 80 in the whole of FIG. 3, and the number of M is smaller than 256 (= 16 × 16). In the GPU 101a, the continuous number of the same color (Run Length) is transferred to the CPU 101b.

  FIG. 4 is a flowchart showing the procedure of the compression acceleration table creation process performed by the GPU. The details of the processing content of step S214 in FIG. 2 are shown. The GPU 101a starts the activation of 256 threads simultaneously for one small block divided into 256 according to FIG. 2 (step S401). For the N (256) processors of the GPU 101a, the coordinates on the desktop image processed by the processor are designated from the thread number M (1 to 256) (step S411).

  Here, with respect to the X and Y coordinates, the simultaneous parallel processing is performed by changing the coordinate position where the processing is started for each thread. For example, if X = M% 16 and Y = M / 16 with respect to the coordinate X, the thread 1 has M = 1, the coordinates (X, Y) = (1, 0), and the thread 128 has M = 128. The coordinates (X, Y) = (0, 8) and the thread 256 are M = 256, and the processing starts from the position of the coordinates (X, Y) = (0, 16). [%] Is the remainder of the division, and [/] is the quotient of the division.

  Next, each thread (1 to 256) sets the continuous length of the same color as an initial value (0) (step S412), and determines whether it is 1 column (maximum 16 pixels) or less (step S413). If there is a pixel that is detected by another thread and is continuous in the same color in the X-axis direction between (maximum 16 pixels), 1 is added to the same color continuous length (step S414). If the colors are not the same, or if the maximum exceeds 16 pixels, the process exits through the loop of steps S413 and S414.

  As a result of the above processing, as shown in FIG. 3, the same color continuous length is obtained, and this same color continuous length (Run Length) is transferred to the CPU 101b, and the process ends.

  According to the above processing, threads corresponding to different pixels are simultaneously processed in parallel, and high-speed processing can be performed. In addition, since the same color continuous length addition in step S414 is serial access to the memory area (addresses are continuous), the memory used by the GPU 101a can be accessed efficiently. In particular, since only the same color continuous length (Run Length) on the horizontal X-axis (one axis) is calculated in parallel in the GPU 101a, it becomes a continuous area on the memory and is a process suitable for the GPU 101a. it can.

(About compression processing performed by CPU)
Next, compression processing performed by the CPU 101b will be described. FIG. 5 is a flowchart showing a procedure of image compression processing performed by the CPU. The CPU 101b acquires the same color continuous length (Run Length) from the GPU 101a (step S501). At this time, the number M of the same color sequence corresponding to the same color continuous length is 256 or less at the maximum. In the example shown in FIG. 3, M = 80 is sufficient.

  Based on the same color continuous length, the most appearing color is encoded (compressed) as the background (background color) on the desktop screen (step S502). This process is performed by a loop process of the same color sequence number M times (details will be described later).

  Next, a pixel having a color other than the background determined in step S502 is searched (step S503). This processing can be performed by a loop processing with the same color sequence number M times at most.

  Thereafter, a rectangle having the maximum area is detected for the color having the pixel found in step S503 at the upper left coordinate position (step S504). In this process, there is no loop process in the X-axis direction, and a maximum of 16 loop processes in the Y-axis direction are sufficient.

  Finally, the rectangular color, upper left coordinate position, and vertical and horizontal (X, Y) size detected in step S504 are encoded (step S505), and the process ends. Thereafter, the CPU 101b transmits the background information after the encoding processed in step S502 and the information of each rectangle after the encoding processed in step S505 to the client 102 via the network 110.

  In the client 102, the background information received by the CPU 102a is decoded (decoded) and displayed on the display 105 as a desktop background (background color). Further, the CPU 102a decodes (decodes) the received information of each rectangle on the background color, and displays it on the display 105 in the vertical and horizontal sizes and colors corresponding to the respective coordinate positions.

  FIG. 6 is a flowchart showing in detail the processing content related to the determination of the background color. The details of the process of step S502 of FIG. 5 executed by the CPU 101b are shown. First, Color [256], which is an appearing color, Maxcolor, which is a maximum appearing color, and the maximum appearance number MaxCnt are each initialized to 0 (step S601). Then, the following processing is executed until the variable i is counted from 0 to 255 corresponding to the number of pixels 256 (step S602).

  First, it is determined whether or not the appearing ColorData [i] is in the appearing Color (step S603). Here, if it is not an existing color due to a new color (step S603: No), color data [i] is newly registered. Also, Rle (abbreviation of Run Length) [i] is set as the number of occurrences of ColorData [i]. Further, Rle [i] is added to the variable i (step S604). On the other hand, if the color has already appeared (step S603: Yes), Rle [i] is added to the number of occurrences of the same color ColorData [i]. Further, Rle [i] is added to the variable i (step S605).

  After execution of step S604 or step S605, it is determined whether the number of occurrences of ColorData [i] is greater than the maximum number of occurrences MaxCnt (step S606). If the number of occurrences of ColorData [i] is greater than the maximum number of occurrences MaxCnt (step S606: Yes), the process proceeds to step S607, and if the number of occurrences of ColorData [i] is not greater than the maximum number of occurrences MaxCnt (step S606: No). The process returns to step S602 without executing step S607.

  In step S607, ColorData [i] is set as the maximum appearance color Maxcolor. Further, the appearance number of ColorData [i] is set to the maximum appearance number MaxCnt (step S607). Thereafter, the process returns to step S602 and the processing is continued for a different pixel i. Through the above processing, the color indicated by Maxcolor, which is the maximum appearance color, is determined as the background (background color).

  FIG. 7 is a flowchart illustrating in detail the processing content for detecting a rectangle of the same color. The details of the process of step S504 in FIG. 5 executed by the CPU 101b are shown. First, the processed flag flg [256] is initialized with 0 (step S701). A loop process is performed for the Y-axis when the variable j is between 0 and 16 (the process from step S702 to step S712). Further, a loop process is performed for the X axis when the variable i is between 0 and 16 (the processes in steps S703 to S711).

  Then, with respect to the ColorData of the pixel used in step S503, it is determined whether this ColorData [i + 16 × j] is equal to (or the same as) the background color (step S704). If it is the same color as the background (step S704: Yes), the process exits and returns to step S703. If the colors are different (step S704: No), it is determined whether the processed flag flg [i + 16 × j] is equal to 1 (same color) (step S705). If they are equal (step S705: Yes), the process returns to step S703.

  If the result of step S705 is not equal (step S705: No), 1 is set to the pixels from the processed flag flg [i + 16 × j] to flg [i + 16 × j + Rle [i + 16 × j]] (step S706). Rle is the same color continuous length as seen for each pixel.

  Next, a loop process is performed for the Y axis between the variable k from j + 1 to 16 (the process from step S707 to step S710). Then, it is determined whether Rle [i + 16 × j] and Rle [i + 16 × k] are equal (color) (step S708). If they are not equal (step S708: No), the process returns to step S703. If they are equal (step S708: Yes), 1 (same color) is set from the processed flag flg [i + 16 × k] to flg [i + 16 × k + Rle [i + 16 × k]] (step S709).

  With the above processing, it is possible to detect a rectangle having the same pixel as the found pixel in the upper left and the largest area. According to the above processing, since processing for one column is already performed in the X-axis direction by pre-compression, loop processing for newly detecting the same color range in the X-axis direction is unnecessary. . Also in the Y-axis direction, since the same color has already been detected for one column of the X-axis, a maximum of 16 loop processes can be performed for the entire 16 columns. As described above, the detection of different color ranges (rectangles) on the background performed by the CPU 101b can reduce the total number of loops and increase the compression processing of the CPU 101b.

  FIG. 8 is a schematic diagram of compression processing performed by the CPU. FIG. 8 shows the same small block (16 × 16 pixels) as FIG. The CPU 101b outputs an array of colors ColorData [256] for each pixel. In the example shown in FIG. 8, ColorData [0] = {256, 0, 0}, ColorData [1] = {256, 0, 0}, ColorData [2] = {256, 0, 0}, ColorData [3] = {0, 255, 0},... The contents in {} are in the order of red (R), green (G), and blue (B).

  Further, the CPU 101b creates and outputs the same color continuous length Rle [256] for each pixel. In the example shown in FIG. 8, Rle [0] = 3, Rle [1] = 2, Rle [2] = 1, and Rle [3] = 5. Based on the ColorData [256] and Rle [256], the CPU 101b obtains the background (background color), the color of the rectangle on the background, the upper left coordinate position, the vertical and horizontal sizes, and compresses the image data. Transfer to client 102.

  FIG. 9 is a diagram showing an application example of a system using the image compression apparatus shown in FIG. In FIG. 9, a network 110 is a network in which servers 901 and 902 and clients 931 to 934 can communicate with each other, and includes, for example, a LAN (Local Area Network), a WAN (Wide Area Network), the Internet, a mobile phone network, and the like. Is done.

  The server 902 is a management server of a server group (servers 921 to 925) constituting the cloud 920. Among the clients 931 to 934, the client 931 is a notebook personal computer, the client 932 is a desktop personal computer, the client 933 is a mobile phone (may be a smartphone or PHS (Personal Handyphone System)), and the client 934 is a tablet terminal. 9 can realize the image compression apparatus (server) 101 shown in FIG. 1, and the client 102 shown in FIG. 1 can be realized by the clients 931-934 shown in FIG. can do.

  According to the embodiment described above, the desktop image is pre-compressed and the image compression is performed using the pre-compressed data, and the two stages are processed using different processors. In particular, pre-compression uses a GPU to detect the same color continuous length by simultaneously processing a sequence of pixels of the same color on a desktop image by a plurality of threads (processors) and transferring it to the CPU. Memory access can be performed efficiently and processed at high speed. Further, since the CPU obtains information on the same color continuous length from the GPU, it is not necessary for the CPU to detect the same color continuous length, and on the desktop image based on the obtained information on the same color continuous length. Of the same color (background and rectangular image on the background) can be efficiently detected. As a result, the entire processing related to the compression of the desktop image can be divided into functions suitable for the functions of the GPU and the CPU, the burden on both the GPU and the CPU can be reduced, the compression can be performed efficiently, and the client can be quickly processed. It can be sent.

  In the above embodiment, the GPU and CPU are used for the compression processing. However, the GPU processing content can also be performed using a multi-core CPU. You can do it efficiently.

  According to the above-described embodiment, it is particularly effective for image compression of an image with a large amount of data such as a CAD image at the time of product design as a desktop image. When using a service such as DaaS, the server Images can be quickly transmitted to the client, server response can be improved, operability at the client can be improved, and convenience of the entire system can be improved.

  The following additional notes are disclosed with respect to the embodiment described above.

(Supplementary Note 1) For image data to be compressed, the color of each pixel is detected by simultaneous parallel processing of a plurality of threads, and the same color continuous length in a row of pixels is obtained,
An image compression method, comprising: compressing the image data based on the information of the same color continuous length.

(Additional remark 2) The said same color continuous length is obtained by counting the continuous number for every same color of the pixel which adjoins in the arrangement | sequence of the pixel of the said 1 row by the 1st processor by the simultaneous parallel process of the said several thread | sled. The image compression method according to appendix 1, wherein

(Additional remark 3) The said same color continuous length is calculated | required by the simultaneous parallel process of the thread | sled using the said 1st processor,
The image compression method according to appendix 1 or 2, wherein the image data is compressed using a second processor.

(Additional remark 4) The said same color continuous length is calculated | required using GPU as said 1st processor, and compression of the said image data is performed using CPU as said 2nd processor. The image compression method according to any one of 1 to 3.

(Supplementary Note 5) For image data to be compressed, the entire screen is divided into a plurality of blocks, and the number of pixels of the small block after the division is made to correspond to the number of threads, thereby performing the simultaneous processing of the plurality of threads. The image compression method according to any one of appendices 1 to 4, wherein the same continuous color length is obtained.

(Supplementary Note 6) The compression of the image data is based on the same color continuous length information, and after obtaining the color that appears most on the entire screen as a background,
The image according to any one of appendices 1 to 5, wherein a color, a size, and a position of a rectangle having a maximum area are obtained for colors other than the background based on the information on the same continuous color length. Compression method.

(Appendix 7) When the background is determined, the background color is encoded,
The image compression method according to claim 6, wherein when the rectangle having the maximum area is obtained, the color, size, and position of the rectangle are encoded.

(Supplementary Note 8) For image data to be compressed, the color of each pixel is detected by simultaneous parallel processing of a plurality of threads, and the same color continuous length in the arrangement of pixels in one column is obtained. And a multi-core processor for compressing the image data.

(Supplementary Note 9) The processor sequentially reads the addresses having consecutive accesses to a memory storing a row of pixels in which the color of each pixel is detected by simultaneous parallel processing of a plurality of threads, thereby sequentially 9. The image compression apparatus according to appendix 8, wherein the length is counted.

(Supplementary Note 10) The processor
A first processor capable of parallel processing of threads for obtaining the same color continuous length;
The image compression apparatus according to appendix 8, further comprising a second processor for compressing the image data.

(Supplementary Note 11) The first processor is a GPU,
The image compression apparatus according to appendix 10, wherein the second processor is a CPU.

(Supplementary Note 12) Based on the operation command received from the client, for the image data to be compressed, the color of each pixel is detected by simultaneous parallel processing of a plurality of threads, and the same color continuous length in a row of pixels is obtained, A server including a processor that compresses the image data based on the same color continuous length information and transmits the compressed image data to the client;
Each time the operation command is transmitted to the server, the client receives compressed image data corresponding to the operation command, decodes the image data, and displays the screen.
A system characterized by including.

(Supplementary note 13) The system according to supplementary note 12, wherein the image data is a desktop image displayed by a client.

100 system 101a GPU
101b, 102a CPU
101 Image compression device (server)
102 Client 103 Keyboard 104 Mouse 105 Display 110 Network

Claims (11)

For the image data to be compressed, the color of each pixel is detected by simultaneous parallel processing of a plurality of threads executed by the processor , and the same color continuous length of any of RGB in the arrangement of pixels in one column is obtained,
Based on the information of the same color continuous length, compress the image data ,
The same color continuous length is divided into a plurality of whole screens, the number of pixels of the divided small blocks is made to correspond to the number of threads, and the plurality of threads are simultaneously processed in parallel, and other threads in the same column An image compression method characterized in that the image compression method is obtained on the basis of the color of adjacent pixels detected in step (1) .   The same color continuous length is obtained by the first processor by counting the number of consecutive pixels of the same color of adjacent pixels in the arrangement of the pixels of the one column by the simultaneous parallel processing of the plurality of threads. The image compression method according to claim 1. The same color continuous length is obtained by simultaneous parallel processing of threads using the first processor,
The image compression method according to claim 2 , wherein the compression of the image data is performed using a second processor. The same color continuous length, said first determined using the GPU as a processor, the compression of the image data, according to claim 3, characterized in that by using a CPU as the second processor Image compression method. The compression of the image data is based on the information of the same color continuous length, after obtaining the color that appears most on the entire screen as a background,
Based on the information of the same color continuous length, the color other than the background, according to claim 1, wherein the determination of the color and size and position of the rectangular area comprising the area up to Image compression method. When the background is requested, encode the background color,
6. The image compression method according to claim 5 , wherein when the rectangular range having the maximum area is obtained, the color, size, and position of the rectangle are encoded. For image data to be compressed, the color of each pixel is detected by simultaneous processing of a plurality of threads, the same color continuous length of any of RGB in the arrangement of pixels in one column is obtained, and the information of the same color continuous length is obtained. The image data is compressed , the same color continuous length is divided into a plurality of entire screens, the number of pixels of the small block after the division is made to correspond to the number of threads, and simultaneous processing of the plurality of threads is performed An image compression apparatus comprising: a multi-core processor that performs a calculation based on a color of an adjacent pixel detected by another thread in the same column . The processor counts the continuous length of the same color by sequentially reading addresses for successive accesses to a memory storing a row of pixels in which the color of each pixel is detected by simultaneous processing of a plurality of threads. The image compression apparatus according to claim 7 . The processor is
A first processor capable of parallel processing of threads for obtaining the same color continuous length;
The image compression apparatus according to claim 7 , further comprising: a second processor that compresses the image data. The first processor is a GPU;
The image compression apparatus according to claim 9 , wherein the second processor is a CPU. Based on the operation command received from the client, for the image data to be compressed, the color of each pixel is detected by simultaneous parallel processing of a plurality of threads, and the same color continuous length of any one of RGB in the arrangement of pixels in one column is obtained, Based on the information on the same color continuous length, the image data is compressed, transmitted to the client, the same color continuous length is divided into a plurality of screens, and the number of pixels included in the small block after the division Corresponding to the number of threads, a server including a processor that performs simultaneous parallel processing of the plurality of threads and obtains based on the color of an adjacent pixel detected by another thread in the same row ,
A client that receives compressed image data corresponding to the operation command each time the operation command is transmitted to the server, decodes the image data, and displays the screen;
A system characterized by including.

Images