Methods and apparatus for texture compression and computer program product therefor

1. Field of the Invention

The present invention relates to texture compression techniques.

2. Background of the Invention

Compression and decompression intended to minimize the memory size needed to store 2D textures is a promising field of application for these techniques in the 3D graphic domain. This possible field of use is becoming more and more significant as the dimensions and number of these textures tend to increase in real applications. The level of detail tends to increase as required by some applications, such as 3D games, and, without the help of such techniques, memory size and bandwidth for access would tend to require increasing performance levels hardly sustainable in mobile, ultra low power, handheld systems. More to the point, these techniques are becoming increasingly important in wireless phone architectures with 3D games processing capabilities.

For example, assuming a texture dimension of 512×512 pixels 16 bit/color each and a depth of 3, the amount of memory needed is 1.5 M bytes. Assuming 20-30 frames per second, the memory bandwidth is 30 to 45 Mbytes/s.

Additional background information on this topic can be gathered from “Real-Time Rendering” by Tomas Akenine-Möller and Eric Haines, A.K. Peters Ltd, 2 nd edition, ISBN 1568811829.

A well-known solution in this scenario was developed by the company S3; the related algorithm is designated S3TC (where TC stands for Texture Compression).

This has become a widely used de-facto standard and is included in the Microsoft DirectX libraries with adhoc API support.

Compression is performed off-line at system initialization and next the textures are stored in the main memory. Decompression processes act to decompress textures accessing the memory run-time when needed by the graphic engine. This means that only decompression is implemented in hardware form while compression is not.

Important parameters for the decompression engine are: steps needed to decompress textures and possible parallel operation; low latency between data-access-from-memory and data-out-from the decompression engine.

In order to better understand operation of the S3TC algorithm one may refer to an image in RGB format, where each color component R (Red) or G (Green) or B (Blue) is a sub-image composed by N pixels in the horizontal dimension and M pixels in vertical dimension. If each color component is coded with P bits, the number of bits per image is N*M*3*P.

For example, assuming N=M=256 and P=8, then the resulting size is 1,572,864 bits. If each sub-image R or G or B is decomposed in non-overlapping blocks of Q pixels in the horizontal dimension and S pixel in the vertical dimension, the number of blocks per sub-image is (N*M)/(Q*S) while per image is [3(NM/(Q*S)] and the number of bits per block is [3*(Q*S)]*P. If, for example Q=S=4 and P=8, then the resulting size of each block is 384 bits. If the number of bits per channel is R=5, G=6, B=5 then the resulting size of each block per image is (4*4)*(5+6+5)=256 bits. The S3TC algorithm is able to compress such an amount of data by 6 times when R=8, G=8, B=8 and 4 times when R=5, G=6, B=5. 64 bits compose the resulting compressed block always sent to decompression stage. This number is the results of the coding steps described below assuming Q=S=4.

To sum up, operation of the S3TC algorithm may be regarded as comprised of the following steps:

i) Decompose the R G B image in non-overlapped (Q=4)*(S=4) blocks of R G B colors

ii) Consider the following block composed by 16 pixels each one composed by R, G and B color components:

Pij=R ij U G ij U B ij (this denotes the pixel at the ij position the R G B image, and U is the union operator)

iii) Decompose the block above in three sub-blocks called sub-block R, sub-block G and sub-block B as shown herein below, each block including only one color component:

as shown in FIG. 1 . Specifically, FIG. 1 shows RGB blocks ordered in different planes, with a RGB block shown on the left and a corresponding de-composition shown on the right.

iv) Sort in ascending order each sub-block color

v) Detect the black color, which is a pixel made of R=0 and G=0 and B=0

vi) If the black color is not detected, then set a color palette made by

a. 1st color is the minimum value of sub-block R (min_R), minimum value of sub-block G (min_G), minimum value of sub-block B (min_B). b. 2nd color is the maximum value of sub-block R (max_R), maximum value of sub-block G (max_G), maximum value of sub-block B (max_B) c. 3 rd (Int 1 ) is composed by (2*min R+max R)/3 (Int 1 R), (2*min G+max G)/3 (Int 1 G), (2*min B+max B)/3 (Int 1 B) d. 4 th (Int 2 ) is composed by (min R+2*max R)/3 (Int 2 R), (min G+2*max G)/3 (Int 2 G), (min B+2*max B)/3 (Int 2 B)

vii) Otherwise, if black color is detected then set a color palette made by

a. 1 st color is minimum value of sub-block R (min_R), sub-block G (min_G), sub-block B (min_B) where each of them must not be equal to zero (the black color component) at the same time b. 2 nd color is maximum value of sub-block R (max_R), sub-block G (max_G), sub-block B (max_B) c. 3 rd (Int 1 ) is composed by (min R+max R)/2 (Int 1 R), (min G+max G)/2 (Int 1 G), (min B+max B)/2 (Int 1 B) d. 4 th is the black color that has R,G,B components equal to zero

viii) If black color is not detected define the look-up color palette as

If black color is detected define the color palette as

ix) Associate the following 2 bits code (in boldface, under the palette) to each column of the above palette

x) For each Pij=R ij U G ij U B ij (where i ranges from 1 to Q=4 and j ranges from 1 to S=4) compute the Euclidean distance Dist between it and each look-up color as defined above in vi.a,b,c,d or vii.a,b,c,d depending if black color has been detected or not. Essentially this is the Euclidean distance between two points in a three-dimensional coordinate space. Also, the difference is within a homologous color component (between R or G or B).

Dist1=√(| R ij −Min R| 2 +|G ij −Min G| 2 +|B ij −Min B| 2 )

Dist2=√(| R ij −Int1 R| 2 +|G ij −Int1 G| 2 +|B ij −Int1 B| 2 )

Dist3=√(| R ij −Int2 R| 2 +|G ij −Int2 G| 2 +|B ij −Int2 B| 2 )

Dist4=√(| R ij −Max R| 2 +|G ij −Max G| 2 +|B ij −Max B| 2 )

xi) For each Pij=R ij U G ij U B ij find the minimum distance among Dist 1 , Dist 2 , Dist 3 and Dist 4 . For example let it be Dist 1 .

xii) Send to a decoder process the code associated to the color enclosed in the look-up table that has the minimum distance. If it is Dist 1 then the code is 00.

xiii) The decoder receives for each Q*S block as shown in FIG. 2

a. a two-bit code for each Pij that are addresses to the look-up table b. MinR MinG MinB c. MaxR MaxG MaxB

xiv) If Min is received before Max by the decoder then black has been detected by the encoder otherwise not

xv) As shown in FIG. 2 , the decoder operates as described in steps vi or vii depending on black color detection, computing

a. Int 1 R Int 1 G Int 1 Band Int 2 R Int 2 G Int 2 B if black color is not detected by encoder otherwise b. Int 1 R Int 1 G Int 1 B if black color is detected by encoder

xvi) As shown in FIG. 2 , the decoder addresses a look-up table with 2 bits code associated to each Pij and replaces it with the color stored in the look-up table color palette. Specifically ST, LUT, and CT indicate the source text, the look-up table, and the compressed text, respectively.

FIG. 3 shows how the data sent to the decoder are arranged in a bitstream and if the black color is not detected, while FIG. 4 shows the opposite case.

As stated before, the compression ratio is 6:1 or 4:1. This is because if colors are in R=8 G=8 B=8 format then 384 bits are coded with 64 (384/64=6) and if colors are in R=5 G=6 B=5 format then 256 bits are coded with 64 (256/64=4).

As shown in FIGS. 3 and 4 , the sum of all the bits amounts to 64.

However satisfactory the prior art solution considered in the foregoing may be, the need is felt for alternative texture compression/decompression techniques of improved quality.

The aim of the present invention is thus to provide such an alternative, improved technique, leading to better performance in terms of quality achieved and complexity needed for its implementation.

According to the present invention, such an object is achieved by means of a method having the features set forth in the claims that follow. The invention also encompasses the decoding process as well as corresponding apparatus in the form of either a dedicated processor or a suitably programmed general-purpose computer (such as a DSP). In that respect the invention also relates to a computer program product directly loadable into the memory of a digital computer such as a processor and including software code portions performing the method of the invention when the product is run on a computer.

The preferred embodiment of the invention provides a significant improvement over prior art solutions such as S3TC from different viewpoints, since it uses the following compression tools:

color prediction, color-de-correlation, sorting of the prediction errors, generation of the look-up table, bitstream packing, and decoding process.

These tools are different from those used in S3TC or not even provided in S3TC.

The invention will now be described, by way of example only, with reference to the annexed figures of drawing, wherein:

FIGS. 1 to 4 , pertaining to the prior art, have already been described in the foregoing,

FIG. 5 shows a R or G or B sub-block sorted from left to right in ascending order in a possible embodiment of the invention;

FIG. 6 is a block diagram of a pipeline arrangement to evaluate the performance of the compression and decompression techniques described herein;

FIGS. 7 a to 7 h are diagrams showing the directions used to scan and predict pixels in the arrangement shown herein; and

FIGS. 8 and 9 show additional details of possible embodiments of the arrangement described herein.

A first embodiment of the invention will now be described by using the same approach previously adopted for describing, in the case of Q=S=4, the S3TC arrangement.

This method will first be described by referring to an exemplary embodiment where Q=S=3.

i) Decompose the R G B image in non-overlapped Q×S blocks of R G B colors

ii) Consider the following 3×3 block composed by nine pixels each one composed by R, G and B components:

P ij =R ij U G ij U B ij (where P ij again denotes the pixel placed in the ij position in the R G B image, and U is the union operator)

iii) Decompose the above block in three sub-blocks called sub-block R, sub-block G and sub-block B, respectively, as shown below, wherein each block includes only a color component:

iv) Define a 1st predictor for each sub-block

a. R 22 as prediction for all colors in the same sub-block R excluding R 22 b. G 22 as prediction for all colors in the same sub-block G excluding G 22 c. B 22 as prediction for all colors in the same sub-block B excluding B 22

v) Compute for each sub-block the following prediction differences:

a. Sub-block R i. (R 22 -R 11 ),(R 22 -R 12 ),(R 22 -R 13 ),(R 22 -R 21 ),(R 22 -R 23 ), (R 22 -R 31 ),(R 22 -R 32 ),(R 22 -R 33 ) b. Sub-block G i.(G 22 -G 11 ),(G 22 -G 12 ),(G 22 -G 13 ),(G 22 -G 21 ),(G 22 -G 23 ), (G 22 -G 31 ),(G 22 -G 32 ),(G 22 -G 33 ) c. Sub-block B i. (B 22 -B 11 ), (B 22 -B 12 ), (B 22 -B 13 ), (B 22 -B 21 ), (B 22 -B 23 ), (B 22 -B 31 ),(B 22 -B 32 ),(B 22 -B 33 )

vi) Sort in ascending order the prediction differences in each sub-block as shown in FIG. 5 : specifically, the figure shows R or G or B sub-block prediction differences sorted from left to right in ascending order; each number is the position in ascending order that addresses each prediction difference.

vii) Set up a look-up prediction difference palette wherein

a. 1 st value is the minimum for the prediction differences in sub-block R. The same applies for the prediction differences in sub-blocks G and B, thus yielding min_errorR, min_errorG, min_errorB. b. 2 nd value is the maximum for the prediction differences in sub-block R. The same applies for the prediction differences in sub-blocks G and B thus yielding max_errorR, max_errorG, max_errorB. c. 3 rd is Int 1 composed by

i.Int 1 R=(2*min_errorR+max_errorR)/3, Int 1 G=(2*min_errorG+max_errorG)/3, Int 1 B=(2*min_errorB+max_errorB)/3

d. 4 th is Int 2 composed by

i.Int 2 R=(min_errorR+2*max_errorR)/3 Int 2 G=(min_errorG+2*max_errorG)/3, Int 2 B=(min_errorB+2*max_errorB)/3

(In fact the relationships reported in the foregoing correspond to the presently preferred choice within the general relationships:

where a, b, c, d, e, f, g, h, i, l, m, and n are weighing factors).

viii) Define a look-up prediction error palette as

ix) Associate the following 2 bit code with each column of the above palette

x) For each Pij=R ij U G ij U B ij (where i ranges from 1 to Q=3 and j ranges from 1 to S=3) compute the prediction error using P 22 as predictor.

a. The prediction error is defined as E ij =E Rij U E Gij U E Bij =(R 22 -R ij ) U (G 22 -G ij ) U (B 22 -B ij )

xi) For each E ij compute the Euclidean distance between it and each look-up color as defined above in step ix. This is again the Euclidean distance between two points in a three-dimensional coordinate space and the difference is between homologous prediction error components.

Dist1=√(| E Rij −Min_error R| 2 +|E Gij −Min_error G| 2 +|E Bij −Min_error B| 2 )

Dist2=√(| E Rij −Int1 R| 2 +|E Gij −Int1 G| 2 +|E Bij −Int1 B| 2 )

Dist3=√(| E Rij −Int2 R| 2 +|E Gij −Int2 G| 2 +|E Bij −Int2 B| 2 )

Dist4=√(| E Rij −Max_error R| 2 +|E Gij −Max_error G| 2 +|E Bij −Max_error B| 2 )

xii) For each E ij =E Rij U E Gij U E Bij find the minimum distance among Dist 1 , Dist 2 , Dist 3 and Dist 4 . For example this may be Dist 1 .

xiii) Compose a bitstream as follows:

a. P 22 color=16 bits b. P 22 +Min_error=16 bits (=P 22 R+min_errorR U P 22 G+min_errorG U P 22 B+min_errorB) c. P 22 +Max_error=16 bits (=P 22 R+max_errorR U P 22 G+max_errorG U P 22 B+max_errorB) d. For each P 11 , P 12 , P 13 , P 21 , P 23 , P 31 , P 32 , P 33 a 2 bits code is associated following steps 11 , 12 , 13 . For example if Dist 1 is the minimum distance for P ij then the code associated and transmitted to it is 00.

xiv) Each 3*3 block in encoded to 16+16+16+(8*2)=64 bits instead of 144 bits with a compression factor of 2.25 if the RGB source format is 565. The value 3.375 if the RGB source format is 888.

In the decoding process, the decoder will receive the incoming bitstream and proceed through the following steps:

a. Get P 22 b. Get P 22 +Min_error (=P 22 R+min_errorR U P 22 G+min_errorG U P 22 B+min_errorB) c. Get P 22 +Max_error (=P 22 R+max_errorR U P 22 G+max_errorG U P 22 B+max_errorB) d. Then compute Min_error and Max_error inverting formula described in the above steps a,b for each color R,G,B as i. Min_error=(P 22 +Min_error)−P 22 ii. Max_error=(P 22 +Max_error)−P 22 e. Next compute look-up prediction error palette as per step vii) c,d and viii) f. Use 2 bit code to address look-up table and adding the value (thus addressed) to P 22 to recreate each P ij

The arrangement disclosed in the foregoing has been implemented for the following standard images and using two formats: RGB 565 and RGB 888, where 5, 6 or 8 are the number of bits per color channel.

1. 256×256 (horizontal×vertical size dimension)

Abstrwav Bricks Bricks 2 Chapt Forest Image 0 Intel Pixtest Reference Rov Teleport Topsmap

2. 512×512 (horizontal×vertical size dimension)

Donut

3. 640×480 (horizontal×vertical size dimension)

Balloon DragonFly Paper Particles Sparkle

These pictures are a representative set on which typically texture compression is applied. All pictures are in true-color format or 888, while the 565 are obtained from 888 truncating the 323 lowest bits of the 888 pictures. Alternative truncating methods can be used to transform 888 pictures into 565 pictures such as “rounding to nearest integer”, “Floyd-Steinberg dithering” etc. These alternatives do not entail changes to the arrangement disclosed herein.

To measure the performance of each algorithm, visual assessments and objective measures were performed, by taking two parameters as the reference measures, namely mean square error (MSE) and peak signal/noise ratio (PSNR) for each RGB channel.

FIG. 6 shows how measurements are carried out in the simulation environment.

Input images IS in the 888 format (called Source888) are converted at 200 into the 565 format (called Source 565), then compressed at 201 and further decompressed at 202 to the 565 format. These images are back converted at 203 into the 888 format to generate a first set of output images OS′ (also called Decoded888).

The Source-565 images from block 200 are back converted into the 888 format at 204 to generate a second set of output images OS″ to be used as a reference (called Source565to888).

A first set of PSNR values (called PSNR 888) are computed between the Source 888 IS and the Decoded888 OS′ images. A second set of PSNR (called PSNR 565) values are computed between the Source565to888 OS″ and the Decoded888 OS′ images.

The 565 images are back reported to the 888 format by simple zero bit stuffing of the 323 least important positions.

How the Source888 IS images are converted to the 565 format and back to the 888 format corresponds to conventional techniques that do not need to be described in detail herein.

Mean squared (MSE) and peak (PSNR) error are defined as follows:

MSE=(Σ| Pij−Paij| 2 )/( W*h ) where: Pij=source color

Paij=processed color, after-coding and decoding w, h=image width, height

PSNR= 10 log 10 [(2 bpp −1) 2 /MSE] where: bpp=bit per color

Due to its predictive nature, the arrangement previously described is almost invariably able to achieve better performance, while yielding a lower compression ratio than S3TC.

The proposed arrangement can be easily extended to Q=4×S=4 blocks by simply adding one more column at the right side and one more row at the bottom side of the Q=3×S=3 “chunk”.

The main difference with respect to the embodiment described in the foregoing is related to the possibility of adopting a plurality of different patterns for extending the 3×3 block to a 4×4 block as best shown in FIG. 7 of the drawing.

This extension will be described in the following.

i) Decompose the R G B image in non overlapped Q×S blocks of R G B colors

ii) Consider the following Q=4×S=4 block composed of 16 pixels each one composed by R, G and B components:

P ij =R ij U G ij U B ij (where P ij is again the pixel at the ij position in the R G B image, and U is the union operator)

iii) Decompose the above block in three sub-blocks called sub-block R, sub-block G and sub-block B. respectively, as shown below, wherein each block includes only a color component

iv) Define a 1 st predictor for each sub-block

g. R 22 as prediction for 3×3 colors surrounding R 22 (i.e. R 11 , R 12 , R 13 , R 21 , R 23 , R 31 , R 32 , R 33 ) h. G 22 as prediction for 3×3 colors surrounding G 22 (i.e. G 11 , G 12 , G 13 , G 21 , G 23 , G 31 , G 32 , G 33 ) i. B 22 as prediction for 3×3 colors surrounding B 22 (i.e. B 11 , B 12 , B 13 , B 21 , B 23 , B 31 , B 32 , B 33 ) See, in that respect, FIG. 7 a , where this prediction pattern is represented geometrically.

v) Define

j. a 2 nd set of predictors (see FIG. 7 b ) where:

i. R 23 as prediction for R 14 R 24 R 34 ii. R 32 as prediction for R 41 R 42 R 43 iii. R 33 as prediction for R 44 iv. G 23 as prediction for G 14 G 24 G 34 v. G 32 as prediction for G 41 G 42 G 43 vi. G 33 as prediction for G 44 vii. B 23 as prediction for B 14 B 24 B 34 viii. B 32 as prediction for B 41 B 42 B 43 ix. B 33 as prediction for B 44

k. or a 3 rd set of predictors (see again the pattern shown in FIG. 7 a ) with

i. R 13 as prediction for R 14 ii. R 23 as prediction for R 24 iii. R 33 as prediction for R 34 R 44 R 43 iv. R 31 as prediction for R 41 v. R 32 as prediction for R 42 vi. G 13 as prediction for G 14 vii. G 23 as prediction for G 24 viii. G 33 as prediction for G 34 G 44 G 43 ix. G 31 as prediction for G 41 x. G 32 as prediction for G 42 xi. B 13 as prediction for B 14 xii. B 23 as prediction for B 24 xiii. B 33 as prediction for B 34 B 44 B 43 xiv. B 31 as prediction for B 41 xv. B 32 as prediction for B 42

It will be appreciated that other prediction patterns are feasible, as shown in FIGS. 7 c to 7 h.

vi) Compute for each sub-block the following prediction differences:

1. Sub-block R

i. (R 22 -R 11 ),(R 22 -R 12 ),(R 22 -R 13 ),(R 22 -R 21 ), (R 22 -R 23 ),(R 22 -R 31 ),(R 22 -R 32 ),(R 22 -R 33 ) ii. and the differences between predictors as defined in step v.j and v.k and related homologous colors

m. Sub-block G

i. (G 22 -G 11 ),(G 22 -G 12 ),(G 22 -G 13 ),(G 22 -G 21 ), (G 22 -G 23 ),(G 22 -G 31 ),(G 22 -G 32 ),(G 22 -G 33 ) ii. and the differences between predictors as defined in step v.j) and v.k) and related homologous colors

n. Sub-block B

i. (B 22 -B 11 ),(B 22 -B 12 ),(B 22 -B 13 ),(B 22 -B 21 ), (B 22 -B 23 ),(B 22 -B 31 ),(B 22 -B 32 ),(B 22 -B 33 ) ii. and the differences between predictors as defined in step v.j) and v.k) and related homologous colors

o. From this point onwards, up to 8 full encodings of the block will run in parallel depending on the set of predictors used (since up to 8 prediction configurations are possible). At the end of the 8 encodings the arrangement disclosed herein will compute the MSE between block before and after each encoding (out of 8 possible). The one with the minimum MSE will be selected to generate the bitstream that will be sent to the decoder.

vii) Sort in ascending order the prediction differences for each sub-block as shown in FIG. 8 . Each number is the position that addresses each prediction differences in ascending order. Specifically, FIG. 8 shows R or G or B sub-block prediction differences sorted from left to right in ascending order

viii) Two groups are defined by the sorted prediction differences. The first is composed by the three lowest elements and the second by the three highest as shown in FIG. 8 .

ix) Set a look-up prediction differences palette composed as follows:

e. 1 st value is the median of the 1st group as defined in step 8 for sub-block R prediction differences. The same applies for sub-block G and B, thus yielding min_median_errorR, min_median_errorG, min_median_errorB. f. 2 nd value is the median of the 2 nd group as defined in step 8 for sub-block R prediction differences. The same applies for sub-block G and B, thus yielding max_median_errorR, max_median_errorG, max_median_errorB. g. 3 rd is Int 1 composed by

i.Int 1 R=(2*min_median_errorR+max_median_error)/3, Int 1 G=(2*min_median_errorG+max_median_errorG)/3, Int 1 B=(2*min_median_errorB+max_median_errorB)/3

h. 4 th is Int 2 composed by

i.Int 2 R=(min_median_errorR+2*max_median_errorR)/3, Int 2 G=(min_median_errorG+2*max_median_errorG)/3, Int 2 B=(min_median_errorB+2*max_median_errorB)/3

In FIG. 9 the groups and the two representative colors for each R, G, B sub-block are shown.

(In fact the relationships reported in the foregoing correspond to the presently preferred choice within the general relationships:

where a, b, c, d, e, f, g, h, i, l, m, and n are weighing factors).

x) Define the look-up prediction error palette as

xi) Associate the following 2 bits code with each column of the above palette

xii) For each Pij=R ij U G ij U B ij (where i ranges from 1 to Q=4 and j ranges from 1 to S=4) compute the prediction error using predictors as defined in steps v and vi.

p. Define the prediction error E ij =E Rij U E Gij U E Bij =(PredictorR kl −R ij ) U (PredictorG kl −G ij ) U (PredictorB kl −B ij )

xiii) For each E ij compute the Euclidean distance between it and each look-up color as defined above in step ix. This is again the Euclidean distance between two points in a three-dimensional coordinate space and the difference is between homologous prediction error components.

Dist1=√(| E Rij −Min_median_error R| 2 +|E Gij −

Min_median_errorG| 2 +|EBj−Min_median_errorB| 2 )

Dist2=√(| E Rij −Int1 R| 2 +|E Gij −Int1 G| 2 +|E Bij −Int1 B| 2 )

Dist3=√(| E Rij −Int2 R| 2 +|E Gij −Int2 G| 2 +|E Bij −Int2 B| 2 )

Dist4=√(| E Rij −Max_median_error R| 2 +|E Gij −

Max_median_errorG| 2 +|E Bij −Max_median_errorB| 2 )

xiv) For each E ij =E Rij U E Gij U E Bij find the minimum distance among Dist 1 , Dist 2 , Dist 3 and Dist 4 . For example, this may be Dist 1 , and the two-bit code associated thereto is 00.

xv) Each Q*S block is fully coded in 8 different sessions, where in each session uses one of the 8 configurations for the predictions shown in FIGS. 7 a to 7 h:

a. decode as per steps from xvi) below onward each of these 8 coded blocks b. for each decoded block and for each color component R, G or B compute the sum of squared differences between decoded colors and source ones (the one before their encoding) c. add the 3 numbers computed during step xv.b and find the minimum between the 8 options

xvi) Compose a bitstream as follows:

q. P 22 color=16 bits r. P 22 +Min_median_error=16 bits (=P 22 R+Min_median_error U P 22 G+Min_median_errorG U P 22 B+Min_median_errorB) s. P 22 +Max_median_error=16 bits (=P 22 R+Max_median_error U P 22 G+Max_median_errorG U P 22 B+Max_median_errorB) t. For each P 11 , P 12 , P 13 , P 14 , P 21 , P 23 , P 24 , P 31 , P 32 , P 33 , P 34 , P 41 , P 42 , P43, P 44 a 2 bits code is associated following steps iv), v.j) or v.k), vi), xii), xiii), xiv). u. One of the 8 options (encoded with 3 bits) as per step xv.c will be coded in this way

i. 2 more bits are added to the bitstream ii. 1 virtual bit is coded putting P 22 +Min_median_error before or after P 22 +Max_median_error inside the bitstream

xvii) For each block send the bitstream as defined in step xvi) to a decoder process.

xviii) Each Q×S=4*4 block in encoded to 16+16+16+(15*2)+2=80 bits=16*5=10 bytes instead of 256 bits allows a compression factor of 3.2 if the RGB source format is 565. It is 4.8 if the RGB source format is 888.

In the decoding process, the decoder receives the incoming bitstream and performs the following steps: v. getP 22 w. get P 22 +Min_median_error after P 22 +Max_median_error or P 22 +Min_median_error before P 22 +Max_median_error: in this way the virtual bits as per step xvi.u.ii) are retrieved) x. get 2 more bits that with the virtual bits will build the 3 bits as per step 16.u to select how to make the prediction by resorting to one of the patterns addressed by these three bits as shown in FIG. 7 a to 7 h y. Then compute Min_min_median_error (step xix.w-P 22 ) and Max_median_error (step xix.w-P 22 ) z. Next compute look-up prediction error palette as per step 9 aa. Use 2 bit code to address look-up table and adding the value stored at this address to P 22 as defined in step 4 to recreate each P ij bb. Use colors decoded at step xix.aa as predictors (like defined in step v) cc. Use 2 bit code to address the look-up table and adding the value stored at this address to predictors defined in xix.bb) to recreate each remaining color

The arrangement just described has been implemented the same set of pictures defined previously. The results show that the instant predictive arrangement is able to achieve at least the same performance levels of S3TC and yields a compression factor slightly lower than S3TC on 565 sequences.

The proposed arrangement however achieves unquestionably better quality in the both the 3×3 and 4×4 versions, in spite of a lower compression ratio (i.e. in 4×4 reaches 80% of performance of S3TC). Even when worse quality has been measured, visual assessments showed imperceptible artifacts.

Of course, without prejudice to the underlying principle of the invention, the details and embodiments may vary, also significantly, with respect to what has been described and shown by way of example only, without departing from the scope of the invention as defined by the annexed claims.