Image coding/decoding method and recording medium having program for this method recorded thereon

[0002] This invention relates to an image coding/decoding method and to a recording medium on which a program for this method has been recorded. More specifically, the invention relates to an image coding/decoding method that is capable of reproducing a high-quality image (CG images, animated images and natural images, etc.) at high speed even with comparatively low-performance hardware (CPU, memory, etc.) such as that of a game machine, and to a recording medium on which the program of this method has been recorded.

[0003] FIGS. 16 and 17 diagrams (1), (2), for describing the prior art, in which FIG. 16 illustrates the concept of image compression processing in accordance with the JPEG standard.

[0004] In accordance with the JPEG standard, which currently is the main scheme for compressing still pictures, an image is divided into blocks of 8×8 pixels, as shown in FIG. 16(A), and the block is converted to DC (a mean value) and to coefficient values ranging from a fundamental frequency to a frequency which is 63 times the fundamental frequency by a two-dimensional DCT (Discrete Cosine Transform). By utilizing the fact that the frequency components of a natural image concentrate in the low-frequency region, each coefficient value is quantized at a different quantization step to such an extent that image quality will not decline, and variable-length coding (Huffman coding) is performed after the quantity of information is reduced.

[0005] In a case where such coded image data is utilized in a home game machine, the fact that there are limitations upon CPU performance and memory capacity results in various disadvantages when an image compression method (JPEG, etc.) involving a large decoding burden is implemented by software. For example, with the JPEG scheme, 64 codes for undergoing variable-length coding are generated for a block of 8×8 pixels, thereby inviting an increase in computation load at the time of decoding.

[0006] FIG. 16(B) illustrates a portion of Huffman code.

[0007] With Huffman coding, a coefficient H₁₃, etc., having a high frequency of appearance is coded by bits of relatively short code length, and a coefficient H₆, etc., having a low frequency of appearance is coded by bits of relatively long code length. As a consequence, these codes are packed into each octet (byte) unevenly in the manner illustrated. This increases computation load greatly at the time of decoding. In a conventional game system, therefore, the state of the art is such that sacrifice of image quality is inevitable in order to decode images at a speed that allows the images to appear as a moving picture.

[0008] In regard to image quality, the higher the frequency component, the coarser the precision with which quantization is carried out. As a result, image information concerning contours is lost, thereby producing mosquito noise. Such a scheme is not suitable for the compression of characters and animated images. In particular, since game software makes abundant use of artificial images (CG images and animated images, etc.), a decline in subjective image quality due to mosquito noise is a major problem.

[0009] In this regard, the following literature (1) to (5) has been reported in recent years:

[0010] (1) Michael F. Barnsley, Lyman P. Hurd “FRACTAL IMAGE COMPRESSION”, A K Peters Ltd., 1993;

[0011] (2) Takashi Ida, Takeshi Datake “Image Compression by Iterative Transformation Coding”, 5^thCircuit and System Karuizawa Workshop Collection of Papers, pp. 137-142, 1992;

[0012] (3) Hyunbea You, Takashi Takahashi, Hiroyuki Kono, Ryuji Tokunaga “Improving LIFS Image Coding Scheme by Applying Gram Schmidt Orthogonalization”, The Institute of Electronics, Information and Communication Engineers Research Report, vol. NLP-98, no. 146, pp. 37-42, 1998;

[0013] (4) Toshiaki Watanabe, Kazuo Ozeki “Study of AC Component Prediction Scheme Using Mean Values”, Image Coding Symposium (PCSJ89), pp. 29-30, October 1989; and

[0014] (5) Takashi Takahashi, Ryuji Tokunaga “High-Speed Computation Algorithm for Predicting AC Components from Block Mean Values of Images”, The Institute of Electronics, Information and Communication Engineers Papers, Vol. J81-D-II, No. 4, pp. 778-780, April 1998.

[0015] Schemes (1) and (2) relate to fractal coding as a compression method involving little decoding computation load, scheme (3) relates to improvements in adaptive orthogonal transformation having a coding efficiency equivalent to that of the JPEG scheme, and schemes (4) and (5) concern AC-component prediction based upon block mean values (DC values).

[0016] Among these, scheme (3) is a block coding method which divides an image into square blocks of K×K pixels and approximates all blocks by the AC-component prediction method, fractal conversion method or adaptive orthogonal transformation, depending upon an allowable error Z. The AC-component prediction method is utilized in block coding by mean-value separation in which an AC component (addition data) of a local block is found from the block mean values (DC values) of blocks surrounding the local block, and the residual between this and an image of interest is coded. Adaptive orthogonal transformation is a method in which use is made of the autosimilarity possessed by an image, a base vector for approximating a block image is extracted from an image (nest) corresponding to a vector quantization code book, and an orthogonal base system of the minimum required dimensions is constructed by the Gram Schmidt Method.

[0017] However, the fractal conversion of schemes (1) and (2) necessitates iterative computation in decoding and consumes work space on the scale of the image plane. This scheme is therefore not suitable for video game machines.

[0018] The adaptive orthogonal transformation of scheme (3) utilizes addition data, the size of which is equivalent to that of the image of interest, as a nest. As a consequence, a very large work space is required at the time of decoding. Furthermore, though image quality is improved because blocks decompressed at the time of decoding are sequentially written back to corresponding blocks in the nest, the load imposed by address computation and data transfer is great. Further, Huffman coding is applied to compression of the coordinates of the base and to sampling coefficients in scheme (3). In the case of a natural image, however, large deviations are absent in the frequency of occurrence of any base whatsoever. Consequently, not only is there no improvement in compression efficiency but what is expended is only the amount of computation of Huffman code. With adaptive orthogonal transformation, there are cases where, depending upon the image, the number of orthogonal bases of the minimum required number of dimensions is large. When the number of bases is large, however, the number of bits used is greater than when the residual vector is coded directly, and coding efficiency declines as a result.

[0019] With the AC component prediction method of scheme (4), there is a tendency for overshoot or undershoot to occur in the vicinity of contours in the image, and image quality tends to be degraded in the case of artificial images in which luminance rises sharply.

[0020] In the case of the indirect method of AC component prediction of scheme (5), not only is the load on the CPU great but it is also required to have a storage area for interpolated values that are generated along the way.

[0021] FIG. 17 illustrates the concept of the indirect method of AC component prediction.

[0022] In accordance with indirect method of AC component prediction, as shown in FIG. 17(A), the DC values of sub-blocks S₁˜S₄in a block S of interest are estimated in accordance with the following equations from the DC values (S, U, R, B, L) of four surrounding blocks and the block of interest:

[0023] S₁=S+(U+L−B−R)/8

[0024] S₂=S+(U+R−B−L)/8

[0025] S₃=S+(B+L−U−R)/8

[0026] S₄=S+(B+R−U−L)/8

[0027] In FIG. 17(B), the above equations are applied recursively, whereby the pixel values of four pixels P₁˜P₄in sub-block S₁can be estimated in accordance with the following equations:

[0028] P₁=S₁+(U₃+L₂−S₃−S₂)/8

[0029] P₂=S₁+(U₃+S₂−S₃−L₂)/8

[0030] P₃=S₁+(S₃+L₂−U₃−S₂)/8

[0031] P₄=S₁+(S₃+S₂−U₃−L₂)/8

[0032] Similarly, the pixel values of four pixels P₁˜P₄in sub-block S₂can be estimated in accordance with the following equations:

[0033] P₁=S₂+(U₄+S₁−S₄−R₁)/8

[0034] P₂=S₂+(U₄+R₁−S₄−S₁)/8

[0035] P₃=S₂+(S₄+S₁−U₄−R₁)/8

[0036] P₄=S₂+(S₄+R₁−U₄−S₁)/8

[0037] The pixel values of four pixels P₁˜P₄in the sub-blocks S₃, S₄can be estimated in a similar manner.

[0038] However, in order to obtain all of the predicted values P₁˜P₄of the original image by starting from the initial DC values (S, U, R, B, L), the above-cited equations must applied in steps to achieve refinement and not only is a memory for storing intermediate values necessary but there is also an increase in computation load upon the CPU.

[0039] The present invention has been devised in view of the problems of the prior art mentioned above and an object thereof is to provide an image coding/decoding method in which the compression rate of computer-utilizable image data is raised while the image data is maintained at a high image quality, and in which computation load at the time of decoding can be reduced, as well as a recording medium having the program of this method recorded thereon.

[0040] The foregoing object is attained by the arrangement of FIG. 1(A). Specifically, an image coding method according to claim (1) of the present invention comprises dividing image data into a plurality of pixel blocks and generating a DC image comprising mean values of respective ones of the blocks; separating from each pixel block a corresponding block mean value and obtaining a residual vector for every block; and in a case where the magnitude of the residual vector becomes equal to or greater than an allowable value, obtaining one or two or more orthogonal bases for approximating the residual vector by an adaptive orthogonal transformation that employs a nest of the DC image; and coding an orthogonal base system comprising a linear combination of these orthogonal bases.

[0041] In claim (1) of the present invention, the load upon the CPU and memory at the time of image coding/decoding is greatly alleviated by virtue of the arrangement in which one, two or more orthogonal bases are obtained from the nest of the DC image. Further, an improvement in image quality can be expected in an artificial image such as a CG image or animated image which has many flat luminance components and, as a result, exhibits strong correlation with respect to the DC image.

[0042] Preferably, in claim (2) of the present invention, in a case where the magnitude of the residual vector is less than the allowable value in claim (1) of the present invention, information indicative of number of bases=0 is coded instead of obtaining orthogonal bases.

[0043] For example, with regard to an artificial image in which luminance rises sharply, code indicative of number of bases=0 is generated in limited fashion with respect to a pixel block in which a contour portion does not exist nearby (i.e., a pixel block in which the magnitude of the residual vector is less than the allowable value).

[0044] On the decoding side, on the other hand, the indirect method of AC component prediction or the direct method of AC component prediction according to the present invention is applied in limited fashion to the corresponding pixel block, thereby making it possible to reproduce the pixel block with little CPU and memory load.

[0045] Preferably, in claim (3) of the present invention, in a case where total amount of code of the orthogonal base system obtained in claim (1) of the present invention is equal to or greater than total amount of code of the residual vector, the residual vector itself is coded instead of the orthogonal base system. As a result, no purposeless decline in image compression rate is brought about.

[0046] Preferably, in claim (4) of the present invention, in a case where a first error <d_nk> with respect to (between) a residual vector <d> becomes less than the allowable value owing to a number nk of bases obtained in advance in claim (1) of the present invention, second error vectors <d_m> following use of m (0≦m<nk) bases in the order in which the bases were obtained are scalar-quantized by quantization coefficients Q_ykpredetermined in accordance with a number yk (=nk−m) of remaining bases that have not been used, and the result is subjected to scalar inverse quantization; the smallest error is selected from among third error vectors <d′_m> of nk types, which are obtained by subtracting the scalar inverse-quantized second error vectors from the second error vectors <d_m>, and the first error <d_nk>; and the corresponding bases and, if necessary, the corresponding second error vector, are coded.

[0047] One example of the coding method will be described in detail with reference to (c), (d) in FIG. 12(A). In (c) of FIG. 12(A), assume that there has been obtained a linear combination

[0048] <d>≈β₁<v₁>+β₂<v₂>+β₃<v₃>  (nk=3)

[0049] comprising nk (e.g., nk=3) bases for which the magnitude ∥<d_nk>∥ of the error with respect to the residual vector <d> is made less than an allowable value Z. It should be noted that <v> indicates that v is a vector.

[0050] A first error vector <d₃>=<d_nk> in the case where nk=3 bases have been used and second error vectors <d₀>˜<d₂> following use of m (0≦m<nk) bases in the order in which they were obtained are related as follows:

[0051] In (d) of FIG. 12A, the second error vectors <d₀>˜<d₂> are scalar-quantized (and clipped) by respective ones of quantization coefficients Q_yk(e.g., Q₃=6, Q₂=7, Q₁=8) predetermined in accordance with the remaining number of bases yk=3, 2, 1 not used, and these are subjected to inverse quantization by the same quantization coefficients Q_ykto thereby find inverse-quantized second error vectors <d₀Q′>˜<d₂Q′>.

[0052] <d₀Q′>=[<d₀>/Q₃]×Q₃

[0053] <d₁Q′>=[<d₁>/Q₂]×Q₂

[0054] <d₂Q′>=[<d₂>/Q₁]×Q₁

[0055] where the symbol [ ] indicates that the result of computation is made a whole number.

[0056] Furthermore, there are found third error vectors <d′₀>˜<d′₂>, which are obtained by subtracting these inverse-quantized second error vectors from respective ones of the second error vectors <d₀>, <d₁>, <d₂>.

[0057] <d′₀>=<d₀>−<d₀Q′>

[0058] <d′₁>=<d₁>−<d₁Q′>

[0059] <d′₂>=<d₂>−<d₂Q′>

[0060] The magnitudes of these third error vectors <d′₀>˜<d′₂> are not necessarily greater than the magnitude of the first error vector <d₃>. In other words, the final decoding error may be smaller when, as the result of coding the two bases β₁<v₁>+β₂<v₂> and utilizing the amount of code of the one remaining base to scalar-quantize the second error vector <d₂>, the error after decoding becomes the third error vector=<d′₂>, than when, as the result of coding the three β₁<v₁>+β₂<v₂>+β₃<v₃>, the error after decoding becomes the first error vector=<d₃>.

[0061] Accordingly, in claim (4) of the present invention, from among the third error vectors <d′₀>, <d′₁>, <d′₂> and first error vector <d₃>, the smallest error is selected and the corresponding bases and, if necessary, the corresponding second error vector, are coded.

[0062] In terms of the example set forth above, if the third error vector <d′₂> gives the smallest error, {β₁<v₁>+β₂<v₂>} is adopted as the orthogonal base system and these bases are coded. In addition, the second error vector <d₂> is coded (scalar-quantized) conjointly. The quantization coefficients Q_ykare decided in such a manner that the code thus generated will not exceed the total amount of code in a case where nk-number of bases are used. As a result, image quality can be improved without increasing the amount of code per pixel block.

[0063] Thus, the residual vector <d> can be coded with higher precision by virtue of the arrangement of claim (4) of the present invention in which joint use is made of adaptive orthogonal transformation and, if necessary, scalar quantization of second error vectors after m-number of bases have been used. Further, when this is carried out, the second error vectors are scalar-quantized by the quantization coefficients Q_ykconforming to the remaining number of bases yk (=nk−m), and these are coded to an amount of code equivalent to the remaining number yk of bases. As a result, only image quality is increased and not the total amount of code per pixel block. In addition, code length per pixel block can be put into easily decodable form (a multiple of a prescribed number of bits), thereby making it possible to greatly reduce computation load at the time of decoding.

[0064] An image coding/decoding method according to claim (5) of the present invention based upon the arrangement shown in FIG. 1(B) is such that on the basis of a total of five items of DC image data of upper, bottom, left, right blocks U, B, L, R inclusive of a local block S comprising a block mean value of K×K pixels, items of pixel data P₁˜P₄of (K/2)×(K/2) pixels of a first sub-block S₁at the upper left of the local block S are obtained in accordance with the following equations:

[0065] P₁=S+(2U+2L−2S−B−R)/8

[0066] P₂=S+(2U−B−R)/8

[0067] P₃=S+(2L−B−R)/8

[0068] P₄=S+(2S−B−R)/8

[0069] items of pixel data P₁˜P₄of pixels (K/2)×(K/2) of a second sub-block S₂at the upper right of the local block S are obtained in accordance with the following equations:

[0070] P₁=S+(2U−B−L)/8

[0071] P₂=S+(2U+2R−2S−B−L)/8

[0072] P₃=S+(2S−B−L)/8

[0073] P₄=S+(2R−B−L)/8

[0074] items of pixel data P₁˜P₄of pixels (K/2)×(K/2) of a third sub-block S₃at the lower left of the local block S are obtained in accordance with the following equations:

[0075] P₁=S+(2L−U−R)/8

[0076] P₂=S+(2S−U−R)/8

[0077] P₃=S+(2B+2L−2S−U−R)/8

[0078] P₄=S+(2B−U−R)/8

[0079] and/or items of pixel data P₁˜P₄of pixels (K/2)×(K/2) of a fourth sub-block S₄at the lower right of the local block S are obtained in accordance with the following equations:

[0080] P₁=S+(2S−U−L)/8

[0081] P₂=S+(2R−U−L)/8

[0082] P₃=S+(2B−U−L)/8

[0083] P₄=S+(2B+2R−2S−U−L)/8

[0084] In claim (5) of the present invention, CPU and memory load are greatly alleviated at the time of image coding/decoding by virtue of the arrangement in which image data of K×K pixels in the local block S is obtained directly in-stepless fashion from the neighboring DC image data S, U, B, L, R inclusive of the local block. It should be noted that the method of claim (5) of the present invention can be utilized in the prediction of AC components at the time of image coding and in the reproduction of AC components at the time of image decoding.

[0085] Further, a recording medium according to claim (6) of the present invention is a computer-readable recording medium on which has been recorded a program for causing a computer to execute the processing described in any one of claims (1) to (5) of the present invention.

[0086] FIG. 1 is a diagram for describing the principles of the present invention;

[0087] FIG. 2 is a diagram showing the construction of an image coding/decoding system according to an embodiment;

[0088] FIG. 3 is a flowchart (1) of image coding processing according to an embodiment;

[0089] FIG. 4 is a flowchart (2) of image coding processing according to an embodiment;

[0090] FIG. 5 is a flowchart (3) of image coding processing according to an embodiment;

[0091] FIG. 6 is a flowchart (4) of image coding processing according to an embodiment;

[0092] FIG. 7 is a flowchart (5) of image coding processing according to an embodiment;

[0093] FIG. 8 is a diagram for describing a table in image coding processing according to an embodiment;

[0094] FIG. 9 is a conceptual view (1) of image coding processing according to an embodiment;

[0095] FIG. 10 is a conceptual view (2) of image coding processing according to an embodiment;

[0096] FIG. 11 is a conceptual view (3) of image coding processing according to an embodiment;

[0097] FIG. 12 is a conceptual view (4) of image coding processing according to an embodiment;

[0098] FIG. 13 is a flowchart of image decoding processing according to an embodiment;

[0099] FIG. 14 is a conceptual view of direct AC component prediction processing according to an embodiment;

[0100] FIG. 15 is a graph of coding efficiency according to an embodiment;

[0101] FIG. 16 is a diagram (1) for describing the prior art; and

[0102] FIG. 17 is a diagram (2) for describing the prior art.

[0103] A preferred embodiment of the present invention will now be described in detail in accordance with the accompanying drawings. It should be noted that identical reference characters indicate identical or corresponding components throughout the drawings.

[0104] FIG. 2 is a diagram showing the construction of an image coding/decoding system according to an embodiment and illustrating an example of application to a game machine.

[0105] Shown in FIG. 2 are a game machine 10 proper; a CPU (game processor) 11 for performing main control of the game machine (such as control for reading in a game program, 3D CG and texture data TXD and control for reading in data resulting from manipulation of the game by a user) and for executing game processing (such as processing for moving game characters) related to 3D CG animation; a main memory (MM) 12 comprising a RAM, ROM or EEPROM, etc., used by the CPU 11; a local (host) bus 13 of the CPU 11; a bus 14 capable of transferring data at high speed; a bridge 15 for controlling connection between the buses (and for controlling contention arbitration); a control pad 16 having various control keys (a start key, a select key and a cross-hair key, etc.) for controlling the game and setting parameters, as well as position input means such as a mouse and joystick; a peripheral interface (PIF) 17 through which the control pad 16 is accommodated in the game system; a ROM cartridge (ROM-C) 18 in which a game program (a processing procedure, game parameters, 3D CG model data, texture data, etc.) has been recorded on a mask ROM or the like; a ROM-cartridge interface (ROM-CIF) 19 that makes it possible to removably accommodate the ROM cartridge 18 in the game system; a compact disk ROM (CD-ROM) 20 on which the game program has been recorded; a CD-ROM driver 21 that makes it possible to removably accommodate the CD-ROM 20 in the game system and to drive the CD-ROM; a communication controller (COM) 22 which connects the system to a public network (not shown) in order to achieve the online downloading of game programs and to play games with other game machines; and a communication line 23.

[0106] Also shown are a 3D accelerator 30 for subjecting input 3D CG model data to a perspective transformation on a 2D screen; a geometry processor 31; a modeling converter 32 for generating and expanding a 3D CG model of actual size comprising a set of polygons or the like at corresponding positions in 3D space in accordance with reference position data of characters and background, etc., and the shape model data thereof; a shading processor 33 for subjecting the generated model to shading that takes light (sunlight, illumination light, etc.) into consideration; a viewpoint transformation unit 34 for converting 3D CG image data in a world coordinate system XYZ to 3D CG image data in a viewpoint coordinate system xyz that is in accordance with camera viewpoint information; and a perspective transformation unit 35 for performing a perspective transformation of a generated 3D CG model in accordance with camera viewpoint information (viewpoint coordinate system xyz).

[0107] Also shown are a rendering (raster) processor 36 for executing processing synchronized to a display raster; a scanning-line analyzer 37 for extracting each item of pixel data after a perspective transformation in accordance with a scanning-line address x, y of a CRT 45; a Z buffer 38; a hidden-surface removal unit 39 which uses the Z buffer 38 to replace pixel data of a portion which should not be visible on a screen 45A by pixel data of a portion which can be seen on the screen 45A; a texture decoder 40 for decompressing (decoding) a compressed texture data input in accordance with the present invention; a texture buffer 41 for temporarily storing texture data; a texture processor 42 for pasting corresponding items of texture data in the texture buffer 41 onto each item of pixel data of the portion that can be seen on the screen 45A; a frame memory 43 for storing output color image data (R, G, B); a D/A converter (DAC) 44 for converting color pixel data in the frame memory 43 to an analog pixel signal to supply the CRT 45 with a video signal VS; a color CRT monitor 45, for example, serving as a display unit; the display screen 45A of the monitor; and a CRT controller (CRTC) 46 for generating horizontal and vertical synchronizing signals H, V of the CRT 45 and x, y synchronizing-signals of the 3D accelerator 30.

[0108] Furthermore, an external game creation unit 50 creates a game program (processing procedure, game parameters, 3D CG model data, texture data, etc.) and records the game program in the ROM cartridge 18 or CD-ROM 20. When texture data is created, the image coding scheme according to the present invention is executed and texture data TXD that has undergone image compression is recorded in the ROM cartridge 18 or CD-ROM 20. The texture data TXD that has undergone image compression is decoded at high speed by the texture decoder 40, pasted to a 2D perspective image and displayed on the screen 45A. Image coding (compression) processing in the game creation unit 50 will be described below.

[0109] FIGS. 3 to 7 are flowcharts (1)˜(5) of image coding processing according to this embodiment, FIG. 8 is a diagram for describing a table in this image coding processing, and FIGS. 9˜12 are conceptual views (1)˜(4) of this image coding processing. The details of image coding processing will be described with reference to these drawings.

[0110] Throughout the specification, the symbols “< >”, “∥ ∥”, “·” and “[operation]” represent a vector, the magnitude of a vector, the inner product of vectors and the fact that the result of computation is made a whole number, respectively. However, in a case where the symbol “[operation]” is used in a different sense, a supplementary note will be attached to this effect. Further, vectors in diagrams and equations are represented by bold characters.

[0111] In the flowcharts, the size of an original image is taken to be n pixels horizontally and m pixels vertically. Further, the symbol T_{m, n}represents partial image data obtained by extracting a square block of 4×4 pixels from m rows and n columns of an image T, and the symbol B_y,x,sy,sxrepresents a block obtained by extracting data of 4×4, for a total of 16, pixels at steps of sx in the horizontal direction and sy in the vertical direction from y rows and columns of a DC image.

[0112] FIG. 3 illustrates the main processing of the image coding processing.

[0113] Original image data is read in at step S1.

[0114] FIG. 9(A) illustrates the concept of original image data. An image of interest in the RGB system is read in upon being converted to an image in the YUV system. Here Y corresponds to luminance data and U, V to color difference data, wherein U, V are downsampled using 2-pixel luminance averaging in the horizontal direction. The luminance data Y in this example comprises 960 pixels vertically×1280 pixels horizontally, and U, V each comprise 960 pixels vertically×640 pixels horizontally. By way of example, eight bits are allocated to each item of pixel data of Y, U and V.

[0115] Though the focus of the description below is the processing of the luminance data Y, it should be noted that U, V can be processed in the same manner.

[0116] With reference again to FIG. 3, DC-image creation processing is executed at step S2. This DC-image creation processing is processing for dividing the original image into blocks of 4×4 pixels each and creating a DC image comprising mean values M of respective ones of the blocks.

[0117] FIG. 4 is a flowchart of DC-image creation processing. Items of address data i,j of the original image are both initialized to “0” at step S21. At step S22, i/4, j/4 are set in DC-image address registers I, J. Block data T_j,iof 4×4 pixels is extracted from the original image at step S23. The mean value M of the 16 items of pixel data contained in the block data T_j,iis found at step S24. The mean value M is stored at a DC-image storage location DC_J,Iat step S25. The operation i=i+4 is performed at step S26, and it is determined at step S27 whether i>n holds. If i>n does not hold, control returns to step S22. Now the mean value M of the block data T_j,iof the next column is found and this is stored at DC_J,Iof the next column. Control thenceforth proceeds in the same manner. When it is finally found that i>n holds at the discrimination of step S27, i is initialized to “0” and the operation j=j+4 is performed at step S28. It is then determined at step S29 whether j>m holds. If j>m does not hold, control returns to step S22. Now the mean value M of the block data T_j,iof the next row is found and this is stored at DC_J,Iof the next row. Control thenceforth proceeds in the same manner. When it is finally found that j>m holds at the discrimination of step S29, this processing is exited.

[0118] FIG. 9(B) illustrates the concept of the DC image data DC. The DC image of this example comprises 240 DC values vertically×320 DC values horizontally.

[0119] With reference again to FIG. 3, the DC image is output upon being coded by two-dimensional DPCM at step S3.

[0120] FIG. 10(A) illustrates the concept of two-dimensional DPCM processing. Let the DC value of row J, column I of the DC image be DC_J,I. By way of example, a predicted value DC′_J,Iof DC_J,Iis found by DC′_J,I=(DC_J,I−1+DC_J−1,I)/2, the predicted error thereof ΔDC_J,I=DC_J,I−DC′_J,Iis scalar-quantized by a quantization coefficient Q_S{that is, [ΔDC_J,I/Q_S]} and the result is output. It should be noted that the symbol [a] in this case represents the result of rounding off a real number a. Furthermore, run length is taken into consideration only in a case where the predicted error ΔDC_J,Iis “0”, with the predicted error ΔDC_J,Iand run length being Huffman-coded independently.

[0121] FIG. 8(A) illustrates a table of quantization coefficients Q_S. The values of the quantization coefficients Q_Sare correlated with allowable errors Z of multiple stages. The user selects the allowable error Z within a small range when high image quality is required and within a large range when low image quality is acceptable. In accordance with the selection, the quantization coefficient Q_Swill vary over a range of from 1 to 8.

[0122] With reference again to FIG. 3, the address registers i,j of the original image are both initialized to “0” at step S4, and i/4, j/4 are set in the address registers I, J of the DC image at step S5. A 16-dimension residual vector <d> corresponding to a 4×4 pixel block is found in accordance with

[0123] <d>=T_j,i−DC_J,I

[0124] at step S6.

[0125] FIG. 10(B) illustrates the concept of the residual vector <d>. Eight bits are allocated to each element of the residual vector <d>.

[0126] With reference again to FIG. 3, it is determined at step S7 whether the magnitude (the square) of the residual vector <d> is less than the allowable error Z. If it is less, this means that the block image data T_J,Iof this portion can be reconstructed with high precision on the decoding side by the direct method of AC component prediction, described later. Accordingly, control proceeds to step S18, at which the number “0” of bases is output as the code F₁. If the residual vector is not less than the allowable error, then control proceeds to step S8, where adaptive orthogonalization processing is executed for the purpose of searching for base vectors that approximate the residual vector <d>.

[0127] FIG. 11 illustrates the concept of adaptive orthogonalization processing. Adaptive orthogonalization processing is processing for finding the number nk of base vectors and each base vector <v_nk> necessary to approximate the residual vector <d> within the allowable approximation error Z. In this embodiment, a portion of a DC image, which has been obtained by compressing the original image at a ratio of 1:K (e.g., K=4) in both the vertical and horizontal directions, is extracted and used as a nest to thereby lighten the nest. in FIG. 11(A), an area of, e.g., 39 DC values vertically×71 DC values horizontally is extracted from the DC image and adopted as a nest. The search for a base vector <v_nk> involves setting vertex (x,y) ε [0,63]×[0,31] for every DC value vertically and horizontally and adopting a total of four types of subsampling intervals, i.e., (sx,sy) ε {(1,1), (1,2), (2,1), (2,2)}. This is just one example; the size of the nest, the position at which it is extracted and the subsampling intervals of the base vectors can be set at will.

[0128] FIG. 11(B) illustrates a state in which DC values obtained by sampling the nest using various patterns are gathered in a 4×4 storage area of the base vector <v_nk>. That is, 4×4 DC values are gathered from a 4×4 area of the nest when (sx,sy)=(1,1) holds, DC values are gathered from an area of the nest extended in the y direction when (sx,sy)=(1,2) holds, DC values are gathered from an area of the nest extended in the x direction when (sx,sy)=(2,1) holds, and DC values are gathered from an area of the nest extended in both the x and y directions when (sx,sy)=(2,2) holds. These values are stored in the storage area of the base vector <v_nk>. This is processing which utilizes the autosimilarity possessed by the original image to find, from the DC image in the nest, images that resemble the pixel blocks of the original image at various angles.

[0129] FIGS. 5 and 6 are flowcharts of adaptive orthogonalization processing according to this embodiment.

[0130] At step S31 in FIG. 5, a large value (e.g., 100000) is set in an error register E_rrand a base-number register nk is initialized to “1”, starting-address registers x, y of the nest image are both initialized to “0” at step S32, and subsample-interval registers sx, sy of the nest image are both initialized to “1” at step S33.

[0131] At step S34, a 4×4 DC block image B_y,x,sy,sxis extracted from the nest image to create the base vector <v_nk> {which corresponds to a base vector <u_nk> in FIG. 11(C), described later}, and in a case where nk>1 holds, this vector is made orthogonal to the previous base vector by Gram Schmidt orthogonalization.

[0132] The Gram Schmidt Orthogonalization Method is a method of forming, from one base {v₁, . . . , v_n} of n-dimensional inner-product space V, a normal orthogonal base ({v′₁, . . . , v_n} of V. The Gram Schmidt Orthogonalization Method will be described in brief with reference to FIG. 11(C). Let a first base vector be represented by <v₁> (where this corresponds to <u₁>). Since a first normalized base vector <v′₁> is a unit vector, it can be replaced by $v_1^{\prime }=\frac{v_1}{\Vert v_1\Vert }=a_{11}{u}_1$

[0133] Next, when a second base vector <u₂> is extracted from the nest image, a second orthogonal base vector <v₂> that is orthogonal to the first normalized base vector <v′₁> can be replaced temporarily by

[0134] v₂=u₂+kv′₁

[0135] whereupon the following relation is obtained from <v₂>·<v′₁>=0:

[0136] v₂·v′₁=(u₂+kv′₁)·v′₁=u₂·v′₁+k(v′₁·v′₁)=u₂·v′₁+k=0

[0137] The scalar coefficient k in this case is

[0138] k=−(u₂·v′₁)

[0139] If the coefficient k is substituted into the above equation, then the second orthogonal base vector <v₂> can be expressed as follows:

[0140] v₂=u₂−(u₂·v′₁)v′₁

[0141] Since a second normalized base vector <v′₂> also is a unit vector, we have $v_2^{\prime }=\frac{v_2}{\Vert v_2\Vert }=\frac{u_2-\left(u_2·v_1^{\prime }\right)v_1^{\prime }}{\Vert u_2-\left(u_2·v_1^{\prime }\right)v_1^{\prime }\Vert }=a_{21}{u}_1+a_{22}{u}_2$

[0142] In similar fashion, an nth normalized base vector <v′_n> is expressed as follows in general: $v_n^{\prime }=\frac{v_n}{\Vert v_n\Vert }=\frac{u_n-\left(u_n·v_1^{\prime }\right)v_1^{\prime }\to ·\leftarrow \left(u_n·v_{n-1}^{\prime }\right)v_{n-1}^{\prime }}{\Vert u_n-\left(u_n·v_1^{\prime }\right)v_1^{\prime }\to ·\leftarrow \left(u_n·v_{n-1}^{\prime }\right)v_{n-1}^{\prime }\Vert }=\sum _{i=1}^n{a}_{\mathrm{ni}}{u}_i$

[0143] Using the normalized base vector <v′_nk>, step S35 finds a base-vector expansion coefficient α_nkthat will minimize the distance to the residual vector <d>.

[0144] The concept of processing for approximating the residual vector <d> using the normalized base vector <v′_nk> is illustrated at (a) in FIG. 12(A). In (a) of FIG. 12A, the magnitude of a difference vector {<d>−α_nk<v′_nk>} between the residual vector <d> and a base vector α_nk<v′_nk> that has been multiplied by the expansion coefficient α_nkis minimum when the base vector α_nk<v′_nk> and difference vector {<d>−α_nk<v′_nk>} are orthogonal (inner product=0). Therefore, the expansion coefficient α_nkof the normalized base vector <v′_nk> is found in accordance with the following equations: $\left(d-{\alpha }_{\mathrm{nk}}{v}_{\mathrm{nk}}^{\prime }\right)·a_{\mathrm{nk}}{v}_{\mathrm{nk}}^{\prime }=0$ ${\alpha }_{\mathrm{nk}}d·v_{\mathrm{nk}}^{\prime }-{\alpha }_{\mathrm{nk}}^2{v}_{\mathrm{nk}}^{\prime }·v_{\mathrm{nk}}^{\prime }=0$ ${\alpha }_{\mathrm{nk}}=\frac{d·v_{\mathrm{nk}}^{\prime }}{{\Vert v_{\mathrm{nk}}^{\prime }\Vert }^2}$

[0145] A description of (b) in FIG. 12(A) will be given later.

[0146] With reference again to FIG. 5, the magnitude ε_rof an error vector which prevails when the residual vector <d> is approximated by the base vector α_nk<v′_nk> is obtained at step S36. It is determined at step S37 whether ε_r<E_rrholds. If ε_r<E_rrholds, at step S38 the ε_r, x, y, sx, sy prevailing at this time are retained in registers E_rr, X, Y, SX, SY for storing various information relating to the minimum value of ε_r. Further, the expansion coefficient α_nkat this time is stored in a register α, the base vector <v_nk> at this time is stored in a base-vector storage area v, and the orthogonalized base vector <v′_nk> at this time is stored in the storage area v′ of the orthogonalized base vector. Further, if ε_r<E_rrdoes not hold, the processing of step S38 is skipped.

[0147] The operation sx=sx+1 is performed at step S39 and it is determined at step S40 whether sx>2 holds. If sx>2 does not hold, control returns to step 34. Now the above-described processing is executed with regard to a base vector <v_nk> that has been extracted at a different sampling interval sx. Processing thenceforth proceeds in similar fashion. When sx>2 is finally found to hold at the discrimination step S40, sx is initialized to “1” and the sampling interval sy is incremented by +1 at step S41. It is determined at step S42 whether sy>2 holds. If sy>2 does not hold, control returns to step S34. Now the above-described processing is executed with regard to a base vector <v_nk> that has been extracted at a different sampling interval sy. Processing thenceforth proceeds in similar fashion. When sy>2 is finally found to hold at the discrimination step S41, base vectors <v_nk> of a total of four types having different sampling intervals (sx,sy)=(1,1),(1,2),(2,1),(2,2) will have been tried with regard to the starting position (x,y)=(0,0) of the nest image. Program then proceeds to step S43 in FIG. 6.

[0148] The starting position x of the nest is incremented by +1 at step S43 and it is determined at step S44 whether x>p (e.g., p=63) holds. If x>p does not hold, control returns to step S33 ({circle around (2)}). Now processing similar to the above is executed with regard to each base vector <v_nk> of a starting position shifted by one DC value in the x direction. Processing thenceforth proceeds in similar fashion. When x>p is finally found to hold at the discrimination step S44, the starting position x is initialized to “0” and the starting position y is incremented by +1 at step S45. It is then determined at step S46 whether y>q (e.g., q=31) holds. If y>q does not hold, control returns to step S33 ({circle around (2)}). Now processing similar to the above is executed with regard to each base vector <v_nk> of a starting position shifted by one DC value in the y direction. Processing thenceforth proceeds in similar fashion. When y>q is finally found to hold at the discrimination step S46, base vectors <v_nk> of all sampling intervals (sx,sy) ε{(1,1),(1,2),(2,1),(2,2)} will have been tried with regard to all starting positions (x,y) ε[0,63]×[0,31] of the nest image. Control then proceeds to step S47.

[0149] At step S47 the orthogonal base vector α<v′> that has been shifted by the minimum approximation error ε_ris subtracted from the residual vector <d> to find the size (magnitude) of the error, and it is determined whether this size is less than the allowable error Z. If it is not less, then, at step S48, the residual vector <d> is updated by being replaced by {<d>−α<v′>}. Further, the orthogonal base vector α<v′> that has been shifted by the minimum approximation error ε_r, the content of the base vector <v> and the content of the orthogonalized base vector <v′> are saved in the storage area as α_nk, <v_nk>, <v′_nk>, respectively. It should be noted that when nk=1 holds, α₁, <v₁>, <v′₁> are saved. Further, nk is incremented by +1 and control returns to step 32 ({circle around (1)}).

[0150] Processing thenceforth proceeds in similar fashion. When it is finally found at the discrimination step S47 that the approximation residual is less than the allowable value Z, control proceeds to step S49, where a vector comprising a linear combination of orthogonalized base vectors α_nk<v′_nk> (where nk=1, 2, . . . ) is transformed to a vector comprising a linear combination of base vectors β_nk<v_nk> {which correspond to the base vectors <u_nk> of FIG. 11(C)}. The coefficient β will be referred to as the expansion coefficient of the base vector <v> below.

[0151] The transformation method of step S49 will now be described in detail. Assume that k=1˜nk holds and let V represent a matrix comprising base vectors <v_k> {which correspond to the base vector <u_k> of FIG. 11(C)}, let B represent a matrix comprising scalar expansion coefficients β_k, let V′ represent a matrix comprising normalized orthogonal base vectors <v′_k> and let A represent a matrix comprising scalar coefficients α_k. If these are replaced respectively by $V=\left[v_1,v_2,\dots ,v_{\mathrm{nk}}\right]B=\left[\begin{array}{c}{\beta }_1\\ {\beta }_2\\ ⋮\\ {\beta }_{\mathrm{nk}}\end{array}\right]V^{\prime }=\left[v_1^{\prime },v_2^{\prime },\dots ,v_{\mathrm{nk}}^{\prime }\right]A=\left[\begin{array}{c}{\alpha }_1\\ {\alpha }_2\\ ⋮\\ {\alpha }_{\mathrm{nk}}\end{array}\right]$

[0152] the transformation of step S49 will be obtained by making the replacement

[0153] VB=V′A

[0154] In order to solve this with regard to the matrix B, first the matrix V is multiplied by a matrix V^T(where V^Trepresents a transposed matrix of V) from the left for the purpose of transforming the matrix V to a square matrix, thereby obtaining

[0155] V^TVB=V^TV′A

[0156] This matrix (V^TV) is expanded in the manner $V^{T}V=\left[\begin{array}{c}{v}_1\\ v_2\\ ⋮\\ v_{\mathrm{nk}}\end{array}\right]\left[v_1,v_2,\dots ,v_{\mathrm{nk}}\right]=\left[\begin{array}{cccc}{v}_1·v_1& v_1·v_2& \dots & v_1·v_{\mathrm{nk}}\\ v_2·v_1& v_2·v_2& \dots & v_2·v_{\mathrm{nk}}\\ ⋮& ⋮& ⋮& ⋮\\ v_{\mathrm{nk}}·v_1& v_{\mathrm{nk}}·v_2& \dots & v_{\mathrm{nk}}·v_{\mathrm{nk}}\end{array}\right]$

[0157] where <v_i>·<v_j> represents the inner product and <v_i>·<v_j>=<v_j>·<v_i> holds. A square matrix symmetrical with respect to diagonal elements is therefore obtained and <v_i> is different from <v_j>. An inverse matrix therefore exists. Accordingly, multiplying by the inverse matrix (V^TV)^{31 1}of the matrix (V^TV) from the left, we obtain

[0158] (V^TV)⁻¹V^TVB=B=(V^TV)⁻¹V^TV′A

[0159] Thus, this embodiment finds orthogonalized vectors <V′_nk> of the minimum number nk necessary to approximate the error with respect to the residual vector <d> in such a manner that the error will be less than the allowable value Z, then expresses these vectors by a linear combination of the original base vectors <v_nk> (=<u_nk>), obtains the expansion coefficient β_nkof each base vector <v_nk> and codes these coefficients. By virtue of this arrangement, the design is such that Gram Schmidt orthogonalization computation is no longer required at the time of decoding. Further, normalization of the norm to 1 also is eliminated.

[0160] The concept of residual-vector approximation in a case where number of bases nk=3 holds is illustrated at (b) of FIG. 12(A). Initially a first base vector α₁<v′₁> that will minimize the error ε_rwith respect to the residual vector <d> is found. Next, a second orthogonalized base vector α₂<v′₂> that is orthogonal to this vector <v′¹> and that will minimize the error ε_rwith respect to an updated remaining residual vector <d′> is found. Next, a third orthogonalized base vector α₃<v′₃> that is orthogonal to this vector <v′₂> and that will minimize the error ε_rwith respect to an updated remaining residual vector <d″> is found.

[0161] With reference again to FIG. 3, it is determined at step S9 whether the number of bases used nk>7 holds. If nk>7 (8 or greater) holds, there is no advantage in performing image compression even if base vectors are used. Accordingly, control proceeds to step S19, where the number “8” of bases is output as a code F₁, the number “0” of bases used is output as a code F₂and the residual vector <d> itself is output as a code F₃. In case of nk≦7, control proceeds to step S10, at which scalar quantization processing set forth below is executed conjointly with use of the above-mentioned base vectors.

[0162] In scalar quantization processing, error vectors <d_m> in a case where m (0≦m≦nk) bases have been adopted in a selected order among the selected number nk are found in accordance with $d_m=d-\sum _{i=1}^m{\beta }_i{v}_i$ $\mathrm{The}\mathrm{summation}$ $\sum _{i=1}^m{\beta }_i{v}_i$

[0163] for the case where m=0 holds represents a zero vector. Furthermore, the error vectors <d_m> are scalar-quantized by amount of code corresponding to a remaining number of bases yk=nk−m not adopted. That is, the error vectors <d_m> are scalar-quantized by quantization coefficients Q_ykwhich correspond to the remaining number yk of bases, and these values are clipped in the region of values [−2^yk−1, 2^yk−1−1].

[0164] It should be noted that error vectors <d′_m> thus scalar-quantized and clipped will not necessarily be the same as the original error vectors <d_m> after decoding. Accordingly, with regard to each m (m=1, 2, . . . , nk), inverse-quantized residual vectors <d″_m> are found beforehand by inverse-quantizing each quantized error vector <d ′_m> by the corresponding quantization coefficient Q_yk, an m that will minimize the error ∥<d_m>−<d″_m>∥ is searched for, and code for a case where these m-number of bases have been adopted is eventually generated.

[0165] FIG. 8(B) illustrates a scalar quantization table.

[0166] In a case where nk 8 holds, number of remaining bases yk=7 holds when one base is used (m=1). In similar fashion, number of remaining bases yk=1 holds when seven bases are used (m=7).

[0167] Though the details will be given later, in this embodiment two bytes are used for code per base. If eight bases are used, therefore, the total code length with be 16 bytes. However, if there is capacity for 16 bytes, a 16-dimension residual vector <d> can coded as is and, hence, there will be no advantage to be gained in executing adaptive orthogonal transformation. Accordingly, the number of bases used is within the range of 0˜7 and, in conformity therewith, the number yk of remaining bases is 7˜1.

[0168] Each quantization coefficient Q_ykis determined beforehand in conformity with the remaining number yk of bases. Preferably, each quantization coefficient Q_ykis selected in such a manner that the error vector <d_m> will fall within an amount of code equivalent to the remaining number yk of bases.

[0169] In a case where number of remaining bases yk=1 holds, 16×1 bits can be used in scalar quantization of the error vector <d_m>. This is one bit of code per element of the error vector <d_m>. That is, in this case the error vector <d_m> is scalar-quantized at Q_yk=8 and this value is clipped to [−2¹⁻¹, 2¹⁻¹−1]=[−1, 0]. By way of example, bit “0” of the code corresponds to magnitude “−1” and bit “1” corresponds to magnitude “0”. Operation proceeds in similar fashion. Then, in a case where number of remaining bases yk=7 holds, 16×7 bits can be used in scalar quantization of the error vector <d_m>. This is seven bits of code per element of the error vector <d_m>. In this case the error vector <d_m> is scalar-quantized at Q_yk=2 and this value is clipped to [−2⁷⁻¹, 2⁷⁻¹−1]=[−64, 63]. By thus making joint use of m-number of bases and scalar-quantized error, image quality can be improved without changing the amount of code. Further, since expansion coefficients β of a number equivalent to the remaining number yk of bases are unnecessary, there is a decrease in the slight amount of code.

[0170] FIG. 7 is a flowchart of scalar quantization processing. A register m for counting the number of bases used is initialized to “0” at step 61, and the error vector <d_m> after adoption of m-number of bases is found at step S62. It should be noted that the Σ term represents a zero vector in a case where m=0 holds. More specifically, we have error vector <d₀>=<d> (residual vector). The number yk of remaining bases not used in the current trial among the nk (1≦nk Σ≦7)-number thereof is found from yk=nk−m at step S63. The error vector <d_m> is scalar-quantized by Q_ykand each element of the resulting error vector <d′_m> is clipped to the range [−2^yk−1, 2y^k−1−1] at step S64.

[0171] The resulting error vector <d′_m> (scalar-quantized and clipped) is subjected to scalar inverse quantization by the corresponding quantization coefficient Q_ykat step S65. Error εr_mat the time of comparing original error vector <d_m> with said scalar inverse-quantized error vector <d″_m> is calculated, and the error εr_mis memorized to predetermined storage area at step S66. The register m is incremented by +1 at step S67 and it is determined at step S68 whether m>nk (1≦nk≦7) holds. If m>nk does not hold, control returns to step S62 and executes processing similar to the foregoing.

[0172] When it is eventually found at the discrimination step S68 that m>nk holds, errors εr₀˜εr_nkin a case where m (m=0, 1, 2, 3, . . . , nk)-number of bases have been adopted are found. The smallest error εr_mkis extracted from among the errors εr₀˜εr_nkat step S69, the number nk of bases is output as the code F₁at step S70 and the number mk of bases used (the number of effective bases) is output as the code F₂at step S71. The starting position (x,y), in the nest, of each base used, the subsampling interval (sx,sy) and the remainder obtained by quantizing the expansion coefficient β of each base used by Q (e.g., 8) are packed into 16 bits for every base and output as a code F₄at step S72.

[0173] The breakdown of the code F₄is as follows: six bits horizontally and five bits vertically, for a total of 11 bits, for the starting position (x,y) in the nest, two bits for the subsampling interval of any of four types, and three bits for the remainder of the expansion coefficient β, for a grand total of 16 bits. Accordingly, the code F₄consumes two bytes for every base used.

[0174] The expansion coefficients β of the bases are quantized by Q (e.g., 8) and output its quotient as a code F₅at step S73. Error vectors <d′_mk> at minimum inverse quantization error εr_mkare allocated to an area of 16×(nk−mk) bits equivalent to the remaining number yk of bases and are output as a code F₃. Processing is then exited.

[0175] With reference again to FIG. 3, coding of one residual vector <d> of the original image is thus completed. The address register i is incremented by +4 at step S11 and it is determined at step S12 whether i>n holds. If i>n does not hold, control returns to step S5 and coding is performed by executing processing similar to the foregoing with regard to one residual vector <d> from a position that has been shifted four bits along the i axis. Control thenceforth proceeds in the same manner. When it is finally found that i>n holds at the discrimination of step S12, i is initialized to “0” and the operation j=j+4 is performed at step S13. It is then determined at step S14 whether j>m holds. If j>m does not hold, control returns to step S5 and coding is performed by executing processing similar to the foregoing with regard to each residual vector <d> shifted four bits along the j axis. Control thenceforth proceeds in the same manner. When it is finally found that j>m holds at the discrimination of step S14, the above-described coding processing ends for all residual vectors <d> of the image.

[0176] FIG. 12(B) illustrates image compression code. This table will be referred to in the description given below.

[0177] With reference again to FIG. 3, the variable-length codes F₁, F₂, F₅are Huffman coded and output at step S15. With regard to the number “nk” of bases of the code F₁, Huffman coding is performed taking run length into consideration only in the case of nk=0. A similar approach is adopted in regard to the number “mk” of bases used of the code F₂. With regard to the code F₅, the quotient obtained by quantizing the expansion coefficient β by the constant Q (e.g., 8) is Huffman coded. In a case where number of remaining bases yk≠0 holds, a code EOB for indicating changeover of the image block is written in.

[0178] The variable-length code F₆is Huffman coded and output at step S16. The code F₆is obtained by quantizing, by the quantization coefficient Q_S, the predicted residual ΔDC_J,Ibased upon two-dimensional DPCM of DC values. It should be noted that the predicted residual ΔDC_J,Iand run length are Huffman coded independently of each other taking run length into consideration only in a case where predicted residual ΔDC_J,I=0 holds.

[0179] The variable-length code F₃and fixed-length code F₄are Huffman coded and output at step S17. The code F₃is obtained by scalar-quantizing, by Q_yk, the final error vector <d′_mk> in a case where number of bases used mk>0 holds [i.e., <d′_mk>/Q_yk]. In a case where number of bases used mk=0 holds, the original residual vector <d> itself is coded. The code F4 is fixed at a total of 16 bits per base, namely 11 bits for the starting coordinates (x,y) of the nest, two bits for the subsampling coefficients (sx,sy) and three bits for the remainder (β/Q) of the expansion coefficient β. These bits are packed in the order in which the bases used appear.

[0180] A code string is constructed as the overall code by packing code in the order of appearance in pixel block units. In actuality, the number nk of bases is around two in more than half the blocks and the small number of variable-length codes obtained are only the quotient which is the result of quantizing the expansion coefficient β of the base by Q, DPCM code of the DC image, the number “nk” of bases and the number “mk” of bases used.

[0181] FIG. 13 is a flowchart of image decoding processing according to this embodiment. Image code data is read in at step S81 and the DC values of Y, U, V are decompressed (decoded) at step S82. In this regard, a DC value DC″_J,Ithat results from decoding is obtained in accordance with DC″_J,I=DC′_J,I+[ΔDC_J,I/Q_S]Q_S, where DC′_J,Irepresents a predicted value of DC on the decoding side and is given by DC′_J,I=(DC″_J,I−1+DC″_J−1,I)/2. A nest is generated from the DC values of the Y component at step S83. The nest can be generated upon separately receiving starting-position and size information of the DC image. Address registers i, j of the decoded (reproduced) image are both initialized to “0” at step S84.

[0182] Code data relating to a block image (i.e., the residual vector) is input at step S85 and it is determined at step S86 whether number of bases nk>0 holds. If nk=0 holds, 16 pixels of luminance data is found by the direct method of AC component prediction (described later) at step S97. If nk>0 holds, it is determined at step S87 whether number of based used mk>0 holds.

[0183] If mk=0 holds, the residual vector <d> is inverse-quantized at step S96 and the decoded DC value is added to the obtained residual vector <d> at step S90. If mk>0 holds, the number yk of remaining bases (=nk−mk) is found and the error vector <d′_mk> is inverse-quantized by Q_ykat step S88. Next, at step S89, mk-number of base vectors are created from the nest in accordance with the starting position (x,y) of each base and the subsampling interval (sx,sy), the products between the vectors and the expansion coefficients β are obtained, an approximation vector (orthogonal base system) comprising a linear combination of these products is formed and the error vector <d′_mk> is combined with the approximation vector to reproduce the original residual vector <d>. The decoded DC value is added to the obtained residual vector <d> at step S90. The 4×4 block image T_j,iis thus reproduced by any method described above. The reproduced image T_j,iis stored in an image memory at step S91.

[0184] The address register is incremented by +4 at step S92 and it is determined at step S93 whether i>n holds. If i>n does not hold, control returns to step S85. Now the block image data T_j,iof the next column is decoded and stored in the image memory. Control thenceforth proceeds in the same manner. When it is finally found that i>n holds at the discrimination of step S93, i is initialized to “0” and the operation j=j+4 is performed at step S94. It is then determined at step S95 whether j>m holds. If j>m does not hold, control returns to step S85. Now each item of block data T_j,iof the next row is decoded and stored in the image memory. Control thenceforth proceeds in the same manner. When it is finally found that j>m holds at the discrimination of step S95, image decoding processing is exited.

[0185] It should be noted that the YUV system is converted to the RGB system, though this is not illustrated. In upsampling of U, V at this time, identical values are substituted into two horizontal pixels without utilizing an interpolation filter.

[0186] FIG. 14 is a conceptual view of direct AC component prediction processing according to this embodiment. In this embodiment, approximation images (AC images) of an original pixel block are generated at a stroke from the neighboring DC image by the direct method of AC component prediction.

[0187] In accordance with the indirect method AC component prediction according to the prior art described above, the DC values of sub-blocks S₁˜S₄in a block S of interest are estimated in accordance with the following equations from the DC values (S, U, R, B, L) of four surrounding blocks and the block of interest:

[0188] S₁=S+(U+L−B−R)/8

[0189] S₂=S+(U+R−B−L)/8

[0190] S₃=S+(B+L−U−R)/8

[0191] S₄=S+(B+R−U−L)/8

[0192] FIG. 14(A) illustrates again a diagram similar to that of FIG. 17(B) described above. In similar fashion, U₁˜U₄, L₁˜L₄, R₁˜R₄, B₁˜B₄are estimated in the first stage. By using the above-described method recursively, the four pixels P₁˜P₄in S₁are estimated in accordance with the following equations:

[0193] P₁=S₁+(U₃+L₂−S₃−S₂)/8

[0194] P₂=S₁+(U₃+S₂−S₃−L₂)/8

[0195] P₃=S₁+(S₃+L₂−U₃−S₂)/8

[0196] P₄=S₁+(S₃+S₂−U₃−L₂)/8

[0197] the four pixels P₁˜P₄in S₂are estimated in accordance with the following equations:

[0198] P₁=S₂+(U₄+S₁−S₄−R₁)/8

[0199] P₂=S₂+(U₄+R₁−S₄−S₁)/8

[0200] P₃=S₂+(S₄+S₁−U₄−R₁)/8

[0201] P₄=S₂+(S₄+R₁−U₄−S₁)/8

[0202] the four pixels P₁˜P₄in S₃are estimated in accordance with the following equations:

[0203] P₁=S₃+(S₁+L₄−B₁−S₄)/8

[0204] P₂=S₃+(S₁+S₄−B₁−L₄)/8

[0205] P₃=S₃+(B₁+L₄−S₁−S₄)/8

[0206] P₄=S₃+(B₁+S₄−S₁−L₄)/8

[0207] and the four pixels P₁˜P₄in S₄are estimated in accordance with the following equations:

[0208] P₁=S₄+(S₂+S₃−B₂−R₃)/8

[0209] P₂=S₄+(S₂+R₃−B₂−S₃)/8

[0210] P₃=S₄+(B₂+S₃−S₂−R₃)/8

[0211] P₄=S₄+(B₂+R₃−S₂−S₃)/8

[0212] FIG. 14B illustrates the direction method of AC component prediction according to this embodiment. Reference will be had to FIG. 14(A) as well in the description that follows. First, in a case where four pixels P₁˜P₄in S₁are found, the approximations S₂≈S₃≈S, U₃≈U, L₂≈L are performed. When these approximations are applied to the equation of P₁in S₁above, the following is obtained: $\begin{array}{c}{P}_1=S_1+\left(U_3+L_2-S_3-S_2\right)/8\\ =S_1+\left(U+L-S-S\right)/8\end{array}$

[0213] Furthermore, when the above equation of S₁, namely S₁=S+(U+L−B−R)/8, is substituted into this equation, P₁in S₁can finally be expressed as follows:

[0214] P₁=S+(2U+2L−2S−B−R)/8

[0215] Further, with regard to P₂in S₁, the following is obtained: $\begin{array}{c}{P}_2=S_1+\left(U_3+S_2-S_3-L_2\right)\text{/}8\\ =S_1+\left(U+S-S-L\right)\text{/}8\end{array}$

[0216] Furthermore, when the above equation of S₁, namely S₁=S+(U+L−B−R)/8, is substituted into this equation, P₂in S₁can finally be expressed as follows:

[0217] P₂=S+(2U−B−R)/8

[0218] Further, with regard to P₃in S₁, the following is obtained: $\begin{array}{c}{P}_3=S_1+\left(S_3+L_2-U_3-S_2\right)\text{/}8\\ =S_1+\left(S+L-U-S\right)\text{/}8\end{array}$

[0219] Furthermore, when the above equation of S₁, namely S₁=S+(U+L−B−R)/8, is substituted into this equation, P₃in S₁can finally be expressed as follows:

[0220] P₃=S+(2L−B−R)/8

[0221] Further, with regard to P₄in S₁, the following is obtained: $\begin{array}{c}{P}_4=S_1+\left(S_3+S_2-U_3-L_2\right)\text{/}8\\ =S_1+\left(S+S-U-L\right)\text{/}8\end{array}$

[0222] Furthermore, when the above equation of S₁, namely S₁=S+(U+L−B−R)/8, is substituted into this equation, P₄in S₁can finally be expressed as follows:

[0223] P₄=S+(2S−B−R)/8

[0224] Accordingly, P₁˜P₄in S₁can finally be expressed as follows:

[0225] P₁=S+(2U+2L−2S−B−R)/8

[0226] P₂=S+(2U−B−R)/8

[0227] P₃=S+(2L−B−R)/8

[0228] P₄=S+(2S−B−R)/8

[0229] Next, in a case where four pixels P₁˜P₄in S₂are found, the approximations S₁≈S₄≈S, R₁≈R, U₄≈U are performed. When these approximations are applied to the equation of P₁in S₂above, the following is obtained: $\begin{array}{c}{P}_1=S_2+\left(U_4+S_1-S_4-R_1\right)\text{/}8\\ =S_1+\left(U+S-S-R\right)\text{/}8\end{array}$

[0230] Furthermore, when the above equation of S₂, namely S₂=S+(U+R−B−L)/8, is substituted into this equation, P₁in S₂can finally be expressed as follows:

[0231] P₁=S+(2U−B−L)/8

[0232] Further, with regard to P₂in S₂, the following is obtained: $\begin{array}{c}{P}_2=S_2+\left(U_4+R_1-S_4-S_1\right)\text{/}8\\ =S_2+\left(U+R-S-S\right)\text{/}8\end{array}$

[0233] Furthermore, when the above equation of S₂, namely S₂=S+(U+R−B−L)/8, is substituted into this equation, P₂in S₂can finally be expressed as follows:

[0234] P₂S+(2U+2R−2S−B−L)/8

[0235] Further, with regard to P₃in S₂, the following is obtained: $\begin{array}{c}{P}_3=S_2+\left(S_4+S_1-U_4-S_1\right)\text{/}8\\ =S_2+\left(S+S-U-R\right)\text{/}8\end{array}$

[0236] Furthermore, when the above equation of S₂, namely S₂=S+(U+R−B−L)/8, is substituted into this equation, P₃in S₂can finally be expressed as follows:

[0237] P₃=S+(2S−B−L)/8

[0238] Further, with regard to P₄in S₂, the following is obtained: $\begin{array}{c}{P}_4=S_2+\left(S_4+R_1-U_4-S_1\right)\text{/}8\\ =S_2+\left(S+R-U-S\right)\text{/}8\end{array}$

[0239] Furthermore, when the above equation of S₂, namely S₂=S+(U+R−B−L)/8, is substituted into this equation, P₄in S₂can finally be expressed as follows:

[0240] P₄=S+(2R−B−L)/8

[0241] Accordingly, P₁˜P₄in S₂can finally be expressed as follows:

[0242] P₁=S+(2U−B−L)/8

[0243] P₂=S+(2U+2R−2S−B−L)/8

[0244] P₃=S+(2S−B−L)/8

[0245] P₄=S+(2R−B−L)/8

[0246] Next, in a case where four pixels P₁˜P₄in S₃are found, the approximations S₁≈S₄≈S, L₄≈L, B₁≈B are performed. When these approximations are applied to the equation of P₁in S₃above, the following is obtained: $\begin{array}{c}{P}_1=S_3+\left(S_1+L_4-B_1-S_4\right)\text{/}8\\ =S_3+\left(S+L-B-S\right)\text{/}8\end{array}$

[0247] Furthermore, when the above equation of S₃, namely S₃=S+(B+L−U−R)/8, is substituted into this equation, P₁in S₃can finally be expressed as follows:

[0248] P₁=S+(2L−U−R)/8

[0249] Further, with regard to P₂in S₃, the following is obtained: $\begin{array}{c}{P}_2=S_3+\left(S_1+S_4-B_1-L_4\right)\text{/}8\\ =S_3+\left(S+S-B-L\right)\text{/}8\end{array}$

[0250] Furthermore, when the above equation of S₃, namely S₃=S+(B+L−U−R)/8, is substituted into this equation, P₂in S₃can finally be expressed as follows:

[0251] P₂=S+(2S−U−R)/8

[0252] Further, with regard to P₃in S₃, the following is obtained: $\begin{array}{c}{P}_3=S_3+\left(B_1+L_4-S_1-S_4\right)\text{/}8\\ =S_3+\left(B+L-S-S\right)\text{/}8\end{array}$

[0253] Furthermore, when the above equation of S₃, namely S₃=S+(B+L−U−R)/8, is substituted into this equation, P₃in S₃can finally be expressed as follows:

[0254] P₃=S+(2B+2L−2S−U−R)/8

[0255] Further, with regard to P₄in S₃, the following is obtained: $\begin{array}{c}{P}_4=S_3+\left(B_1+S_4-S_1-L_4\right)\text{/}8\\ =S_3+\left(B+S-S-L\right)\text{/}8\end{array}$

[0256] Furthermore, when the above equation of S₃, namely S₃=S+(B+L−U−R)/8, is substituted into this equation, P₄in S₃can finally be expressed as follows:

[0257] P₄=S+(2B−U−R)/8

[0258] Accordingly, P₁˜P₄in S₃can finally be expressed as follows:

[0259] P₁=S+(2L−U−R)/8

[0260] P₂=S+(2S−U−R)/8

[0261] P₃=S+(2B+2L−2S−U−R)/8

[0262] P₄=S+(2B−U−R)/8

[0263] Next, in a case where four pixels P₁˜P₄in S₄are found, the approximations S₂≈S₃≈S, R₃≈R, B₂≈B are performed. When these approximations are applied to the equation of P₁in S₄above, the following is obtained: $\begin{array}{c}{P}_1=S_4+\left(S_2+S_3-B_2-R_3\right)\text{/}8\\ =S_4+\left(S+S-B-R\right)\text{/}8\end{array}$

[0264] Furthermore, when the above equation of S₄, namely S₄=S+(B+R−U−L)/8, is substituted into this equation, P₁in S₄can finally be expressed as follows:

[0265] P₁=S+(2S−U−L)/8

[0266] Further, with regard to P₂in S₄, the following is obtained: $\begin{array}{c}{P}_2=S_4+\left(S_2+R_3-B_2-S_3\right)\text{/}8\\ =S_4+\left(S+R-B-S\right)\text{/}8\end{array}$

[0267] Furthermore, when the above equation of S₄, namely S₄=S+(B+R−U−L)/8, is substituted into this equation, P₂in S₄can finally be expressed as follows:

[0268] P₂=S+(2R−U−L)/8

[0269] Further, with regard to P₃in S₄, the following is obtained: $\begin{array}{c}{P}_3=S_4+\left(B_2+S_3-S_2-R_3\right)\text{/}8\\ =S_4+\left(B+S-S-R\right)\text{/}8\end{array}$

[0270] Furthermore, when the above equation of S₄, namely S₄=S+(B+R−U−L)/8, is substituted into this equation, P₃in S₄can finally be expressed as follows:

[0271] P₃=S+(2B−U−L)/8

[0272] Further, with regard to P₄in S₄, the following is obtained: $\begin{array}{c}{P}_4=S_4+\left(B_2+R_3-S_2-S_3\right)\text{/}8\\ =S_4+\left(B+R-S-S\right)\text{/}8\end{array}$

[0273] Furthermore, when the above equation of S₄, namely S₄=S+(B+R−U−L)/8, is substituted into this equation, P₄in S₄can finally be expressed as follows:

[0274] P₄=S+(2B+2R−2S−U−L)/8

[0275] Accordingly, P₁˜P₄in S₄can finally be expressed as follows:

[0276] P₁=S+(2S−U−L)/8

[0277] P₂=S+(2R−U−L)/8

[0278] P₃=S+(2B−U−L)/8

[0279] P₄=S+(2B+2R−2S−U−L)/8

[0280] Thus, in accordance with this embodiment, an approximation image of 4×4 pixels is obtained directly (in stepless fashion) from neighboring DC values (S, U, R, B, L) inclusive of its own DC value.

[0281] FIG. 15 is a graph of coding efficiency according to this embodiment. Using a sample image (320×240 pixels, with a precision of eight bits per pixel in each of the R, G, B components), coding performance was evaluated in accordance with

[0282] PSNR[dB]=20log₁₀(255/{square root over ( )}(ε²))

[0283] versus

[0284] BPR=[total amount of data (bits) after compression]/[number of pixels in original image]

[0285] where BPR represents bits per pixel and PSNR represents peak-to-peak signal-to-noise ratio. It should be noted that ε²represents mean square error per pixel.

[0286] FIG. 15(A) illustrates the result in the case of an animated image, in which the solid line indicates the result in the case of this embodiment and the dotted line the result in the case of JPEG. A coding efficiency greatly exceeding that of JPEG was obtained, as illustrated. FIG. 15(B) illustrates the result in a case where a CG image is used. A tendency similar to that mentioned above was obtained. With the present scheme, moreover, mosquito noise and block noise peculiar to the orthogonal transformation coding method do not appear, and it is believed that this scheme is effective for artificial images. Though not shown, a performance substantially the same as that of JPEG was obtained for natural images.

[0287] Though an example of application to a game machine is described above in the foregoing embodiment, it is obvious that the present invention can be applied also to the coding/decoding of ordinary frame images such as photographic images and animated images.

[0288] Though a preferred embodiment of the present invention is described above, it goes without saying that the components, processing and combinations thereof may be modified in various ways without departing from the idea of the present invention.

[0289] Thus, in accordance with the present invention, as described above, since the nest can be lightened and the amount of variable-length code reduced, the computation load at the time of decoding can be reduced and it is possible to utilize moving-picture and still-picture image data, without degrading image quality, even in a system having a comparatively low performance. In addition, mosquito noise is not produced even at contours and it is possible to provide highly compressed image data featuring good reproducibility in regard to characters and animated images.