diff options
Diffstat (limited to 'src/mesa/main')
| -rw-r--r-- | src/mesa/main/texcompress_fxt1.c | 675 |
1 files changed, 640 insertions, 35 deletions
diff --git a/src/mesa/main/texcompress_fxt1.c b/src/mesa/main/texcompress_fxt1.c index 5a37a259c73..cd5b0c3d603 100644 --- a/src/mesa/main/texcompress_fxt1.c +++ b/src/mesa/main/texcompress_fxt1.c @@ -26,6 +26,7 @@ /** * \file texcompress_fxt1.c * GL_EXT_texture_compression_fxt1 support. + * \author Daniel Borca */ @@ -40,15 +41,15 @@ #include "texstore.h" -static GLuint -compress_fxt1 (GLcontext *ctx, - GLsizei srcWidth, - GLsizei srcHeight, - GLenum srcFormat, - const GLchan *source, - GLint srcRowStride, - GLubyte *dest, - GLint dstRowStride); +int +fxt1_encode (GLcontext *ctx, + unsigned int width, unsigned int height, + int srcFormat, + const void *source, int srcRowStride, + void *dest, int destRowStride); +void +fxt1_decode_1 (const void *texture, int width, + int i, int j, unsigned char *rgba); /** @@ -77,17 +78,14 @@ texstore_rgb_fxt1(STORE_PARAMS) ASSERT(dstYoffset % 4 == 0); ASSERT(dstZoffset == 0); - /* [dBorca] - * we still need to pass 4byte/texel to the codec - */ - if (1 || srcFormat != GL_RGB || + if (srcFormat != GL_RGB || srcType != CHAN_TYPE || ctx->_ImageTransferState || srcPacking->SwapBytes) { /* convert image to RGB/GLchan */ tempImage = _mesa_make_temp_chan_image(ctx, dims, baseInternalFormat, - /*dstFormat->BaseFormat*/GL_RGBA, + dstFormat->BaseFormat, srcWidth, srcHeight, srcDepth, srcFormat, srcType, srcAddr, srcPacking); @@ -95,7 +93,7 @@ texstore_rgb_fxt1(STORE_PARAMS) return GL_FALSE; /* out of memory */ _mesa_adjust_image_for_convolution(ctx, dims, &srcWidth, &srcHeight); pixels = tempImage; - srcRowStride = /*3*/4 * srcWidth; + srcRowStride = 3 * srcWidth; srcFormat = GL_RGB; } else { @@ -108,11 +106,11 @@ texstore_rgb_fxt1(STORE_PARAMS) GL_COMPRESSED_RGB_FXT1_3DFX, texWidth, (GLubyte *) dstAddr); - compress_fxt1(ctx, srcWidth, srcHeight, srcFormat, pixels, srcRowStride, - dst, dstRowStride); + fxt1_encode(ctx, srcWidth, srcHeight, srcFormat, pixels, srcRowStride, + dst, dstRowStride); if (tempImage) - _mesa_free((void *) tempImage); + _mesa_free((void*) tempImage); return GL_TRUE; } @@ -163,8 +161,8 @@ texstore_rgba_fxt1(STORE_PARAMS) GL_COMPRESSED_RGBA_FXT1_3DFX, texWidth, (GLubyte *) dstAddr); - compress_fxt1(ctx, srcWidth, srcHeight, srcFormat, pixels, srcRowStride, - dst, dstRowStride); + fxt1_encode(ctx, srcWidth, srcHeight, srcFormat, pixels, srcRowStride, + dst, dstRowStride); if (tempImage) _mesa_free((void*) tempImage); @@ -177,7 +175,7 @@ static void fetch_texel_2d_rgba_fxt1( const struct gl_texture_image *texImage, GLint i, GLint j, GLint k, GLchan *texel ) { - /* XXX to do */ + fxt1_decode_1(texImage->Data, texImage->Width, i, j, texel); } @@ -187,7 +185,7 @@ fetch_texel_2d_f_rgba_fxt1( const struct gl_texture_image *texImage, { /* just sample as GLchan and convert to float here */ GLchan rgba[4]; - fetch_texel_2d_rgba_fxt1(texImage, i, j, k, rgba); + fxt1_decode_1(texImage->Data, texImage->Width, i, j, rgba); texel[RCOMP] = CHAN_TO_FLOAT(rgba[RCOMP]); texel[GCOMP] = CHAN_TO_FLOAT(rgba[GCOMP]); texel[BCOMP] = CHAN_TO_FLOAT(rgba[BCOMP]); @@ -199,7 +197,8 @@ static void fetch_texel_2d_rgb_fxt1( const struct gl_texture_image *texImage, GLint i, GLint j, GLint k, GLchan *texel ) { - /* XXX to do */ + fxt1_decode_1(texImage->Data, texImage->Width, i, j, texel); + texel[ACOMP] = 255; } @@ -209,11 +208,11 @@ fetch_texel_2d_f_rgb_fxt1( const struct gl_texture_image *texImage, { /* just sample as GLchan and convert to float here */ GLchan rgba[4]; - fetch_texel_2d_rgb_fxt1(texImage, i, j, k, rgba); + fxt1_decode_1(texImage->Data, texImage->Width, i, j, rgba); texel[RCOMP] = CHAN_TO_FLOAT(rgba[RCOMP]); texel[GCOMP] = CHAN_TO_FLOAT(rgba[GCOMP]); texel[BCOMP] = CHAN_TO_FLOAT(rgba[BCOMP]); - texel[ACOMP] = CHAN_TO_FLOAT(rgba[ACOMP]); + texel[ACOMP] = 1.0; } @@ -263,16 +262,622 @@ const struct gl_texture_format _mesa_texformat_rgba_fxt1 = { }; -static GLuint -compress_fxt1 (GLcontext *ctx, - GLsizei srcWidth, - GLsizei srcHeight, - GLenum srcFormat, - const GLchan *source, - GLint srcRowStride, - GLubyte *dest, - GLint dstRowStride) +/***************************************************************************\ + * FXT1 encoder + * + * The encoder was built by reversing the decoder, + * and is vaguely based on Texus2 by 3dfx. Note that this code + * is merely a proof of concept, since it is higly UNoptimized; + * moreover it is sub-optimal due to Lloyd's algorithm. + * Only CHROMA and non-lerp ALPHA is implemented! +\***************************************************************************/ + + +#define MAX_COMP 4 /* ever meeded maximum number of components in texel */ +#define MAX_VECT 4 /* ever needed maximum number of base vectors to find */ +#define N_TEXELS 32 /* number of texels in a block (always 32) */ +#define LL_N_REP 50 /* number of iterations in lloyd's vq */ +#define LL_MAX_E 255 /* fault tolerance (maximum error) */ + + +static int +fxt1_besterr (float vec[][MAX_COMP], int nv, + unsigned char input[MAX_COMP], int nc, + float *d) +{ + int i, j, best = -1; + float err = 1e5; /* big enough */ + + for (j = 0; j < nv; j++) { + float e = 0; + for (i = 0; i < nc; i++) { + e += (vec[j][i] - input[i]) * (vec[j][i] - input[i]); + } + if (e < err) { + err = e; + best = j; + } + } + + *d = err; + return best; +} + + +static int +fxt1_worsterr (float vec[MAX_COMP], + unsigned char input[N_TEXELS][MAX_COMP], int nc, int n) +{ + int i, k, worst = -1; + float err = -1; /* small enough */ + + for (k = 0; k < n; k++) { + float e = 0; + for (i = 0; i < nc; i++) { + e += (vec[i] - input[k][i]) * (vec[i] - input[k][i]); + } + if (e > err) { + err = e; + worst = k; + } + } + + return worst; +} + + +static void +fxt1_lloyd (float vec[][MAX_COMP], int nv, + unsigned char input[N_TEXELS][MAX_COMP], int nc, int n) +{ + /* Use the generalized lloyd's algorithm for VQ: + * find 4 color vectors. + * + * for each sample color + * sort to nearest vector. + * + * replace each vector with the centroid of it's matching colors. + * + * repeat until RMS doesn't improve. + * + * if a color vector has no samples, or becomes the same as another + * vector, replace it with the color which is farthest from a sample. + * + * vec[][MAX_COMP] resulting colors + * nv number of resulting colors required + * input[N_TEXELS][MAX_COMP] input texels + * nc number of components in input / vec + * n number of input samples + */ + + int sum[MAX_VECT][MAX_COMP]; /* used to accumulate closest texels */ + int cnt[MAX_VECT]; /* how many times a certain vector was chosen */ + float error; + + int i, j, k, rep; + + /* choose the base vectors from input */ + for (j = 0; j < nv; j++) { + int m = j * (n - 1) / (nv - 1); + for (i = 0; i < nc; i++) { + vec[j][i] = input[m][i]; + } + } + + /* the quantizer */ + for (rep = 0; rep < LL_N_REP; rep++) { + /* reset sums & counters */ + for (j = 0; j < nv; j++) { + for (i = 0; i < nc; i++) { + sum[j][i] = 0; + } + cnt[j] = 0; + } + error = 0; + + /* scan whole block */ + for (k = 0; k < n; k++) { + float d; + int best = fxt1_besterr(vec, nv, input[k], nc, &d); + /* add in closest color */ + for (i = 0; i < nc; i++) { + sum[best][i] += input[k][i]; + } + /* mark this vector as used */ + cnt[best]++; + /* accumulate error */ + error += d; + } + + /* accumulated distance (error) small enough? */ + if (error < LL_MAX_E) { + break; + } + + /* move each vector to the barycenter of its closest colors */ + for (j = 0; j < nv; j++) { + if (cnt[j]) { + float div = 1.0 / cnt[j]; + for (i = 0; i < nc; i++) { + vec[j][i] = div * sum[j][i]; + } + } else { + /* this vec has no samples or is identical with a previous vec */ + int worst = fxt1_worsterr(vec[j], input, nc, n); + for (i = 0; i < nc; i++) { + vec[j][i] = input[worst][i]; + } + } + } + } +} + + +static void +fxt1_quantize_CHROMA (unsigned long *cc, + unsigned char input[N_TEXELS][MAX_COMP]) +{ + const int n_vect = 4; /* 4 base vectors to find */ + const int n_comp = 3; /* 3 components: R, G, B */ + float vec[MAX_VECT][MAX_COMP]; + int i, j, k; + unsigned long long hihi; /* high quadword */ + unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */ + float d; + + fxt1_lloyd(vec, n_vect, input, n_comp, N_TEXELS); + + hihi = 4; /* cc-chroma = "010" + unused bit */ + for (j = 0; j < n_vect; j++) { + for (i = 0; i < n_comp; i++) { + /* add in colors */ + hihi <<= 5; + hihi |= (unsigned int)vec[n_vect - 1 - j][i] >> 3; + } + } + ((unsigned long long *)cc)[1] = hihi; + + lohi = lolo = 0; + /* right microtile */ + for (k = N_TEXELS - 1; k >= N_TEXELS/2; k--) { + lohi <<= 2; + lohi |= fxt1_besterr(vec, n_vect, input[k], n_comp, &d); + } + /* left microtile */ + for (; k >= 0; k--) { + lolo <<= 2; + lolo |= fxt1_besterr(vec, n_vect, input[k], n_comp, &d); + } + cc[1] = lohi; + cc[0] = lolo; +} + + +static void +fxt1_quantize_ALPHA0 (unsigned long *cc, + unsigned char input[N_TEXELS][MAX_COMP], + unsigned char reord[N_TEXELS][MAX_COMP], int n) +{ + const int n_vect = 3; /* 3 base vectors to find */ + const int n_comp = 4; /* 4 components: R, G, B, A */ + float vec[MAX_VECT][MAX_COMP]; + int i, j, k; + unsigned long long hihi; /* high quadword */ + unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */ + float d; + + /* the last vector indicates zero */ + for (i = 0; i < n_comp; i++) { + vec[n_vect][i] = 0; + } + + /* the first n texels in reord are guaranteed to be non-zero */ + fxt1_lloyd(vec, n_vect, reord, n_comp, n); + + hihi = 6; /* alpha = "011" + lerp = 0 */ + for (j = 0; j < n_vect; j++) { + /* add in alphas */ + hihi <<= 5; + hihi |= (unsigned int)vec[n_vect - 1 - j][n_comp - 1] >> 3; + } + for (j = 0; j < n_vect; j++) { + for (i = 0; i < n_comp - 1; i++) { + /* add in colors */ + hihi <<= 5; + hihi |= (unsigned int)vec[n_vect - 1 - j][i] >> 3; + } + } + ((unsigned long long *)cc)[1] = hihi; + + lohi = lolo = 0; + /* right microtile */ + for (k = N_TEXELS - 1; k >= N_TEXELS/2; k--) { + lohi <<= 2; + lohi |= fxt1_besterr(vec, n_vect + 1, input[k], n_comp, &d); + } + /* left microtile */ + for (; k >= 0; k--) { + lolo <<= 2; + lolo |= fxt1_besterr(vec, n_vect + 1, input[k], n_comp, &d); + } + cc[1] = lohi; + cc[0] = lolo; +} + + +static void +fxt1_quantize (unsigned long *cc, const unsigned char *lines[], int comps) { - /* here be dragons */ + int trualpha = 0; + unsigned char reord[N_TEXELS][MAX_COMP]; + + unsigned char input[N_TEXELS][MAX_COMP]; + int i, k, l; + + /* 8 texels each line */ + for (l = 0; l < 4; l++) { + for (k = 0; k < 4; k++) { + for (i = 0; i < comps; i++) { + input[k + l * 4][i] = *lines[l]++; + } + for (; i < MAX_COMP; i++) { + input[k + l * 4][i] = 255; + } + } + for (k = 0; k < 4; k++) { + for (i = 0; i < comps; i++) { + input[k + l * 4 + 16][i] = *lines[l]++; + } + for (; i < MAX_COMP; i++) { + input[k + l * 4 + 16][i] = 255; + } + } + } + + /* [dBorca] + * stupidity flows forth from this + */ + + if (comps == 4) { + /* skip all transparent black texels */ + l = 0; + for (k = 0; k < N_TEXELS; k++) { + int t = 0; + /* test all components against 0 */ + for (i = 0; i < comps; i++) { + reord[l][i] = input[k][i]; + t += input[k][i]; + } + if (t) { + /* texel is not transparent black */ + if (reord[l][comps - 1] < 255) { + /* non-opaque texel */ + trualpha = !0; + } + l++; + } else { + /* transparent black texel */ + trualpha = !0; + } + } + } + + if (trualpha) { + fxt1_quantize_ALPHA0(cc, input, reord, l); + } else { + fxt1_quantize_CHROMA(cc, input); + } +} + + +int +fxt1_encode (GLcontext *ctx, + unsigned int width, unsigned int height, + int srcFormat, + const void *source, int srcRowStride, + void *dest, int destRowStride) +{ + const int comps = (srcFormat == GL_RGB) ? 3 : 4; + unsigned int x, y; + const unsigned char *data = source; + unsigned long *encoded = dest; + GLubyte *newSource = NULL; + + /* + * Rescale image if width is less than 8 or height is less than 4. + */ + if (width < 8 || height < 4) { + GLint newWidth = (width + 7) & ~7; + GLint newHeight = (height + 3) & ~3; + newSource = MALLOC(comps * newWidth * newHeight * sizeof(GLchan)); + _mesa_upscale_teximage2d(width, height, newWidth, newHeight, + comps, source, srcRowStride, newSource); + source = newSource; + width = newWidth; + height = newHeight; + srcRowStride = comps * newWidth; + } + + destRowStride = (destRowStride - width * 2) / 4; + for (y = 0; y < height; y += 4) { + for (x = 0; x < width; x += 8) { + const unsigned char *lines[4]; + lines[0] = &data[x * comps + (y + 0) * srcRowStride]; + lines[1] = &data[x * comps + (y + 1) * srcRowStride]; + lines[2] = &data[x * comps + (y + 2) * srcRowStride]; + lines[3] = &data[x * comps + (y + 3) * srcRowStride]; + fxt1_quantize(encoded, lines, comps); + /* 128 bits per 8x4 block = 4bpp */ + encoded += 4; + } + encoded += destRowStride; + } + return 0; } + + +/***************************************************************************\ + * FXT1 decoder + * + * The decoder is based on GL_3DFX_texture_compression_FXT1 + * specification and serves as a concept for the encoder. +\***************************************************************************/ + + +/* lookup table for scaling 5 bit colors up to 8 bits */ +static unsigned char _rgb_scale_5[] = { + 0, 8, 16, 25, 33, 41, 49, 58, + 66, 74, 82, 90, 99, 107, 115, 123, + 132, 140, 148, 156, 165, 173, 181, 189, + 197, 206, 214, 222, 230, 239, 247, 255 +}; + +/* lookup table for scaling 6 bit colors up to 8 bits */ +static unsigned char _rgb_scale_6[] = { + 0, 4, 8, 12, 16, 20, 24, 28, + 32, 36, 40, 45, 49, 53, 57, 61, + 65, 69, 73, 77, 81, 85, 89, 93, + 97, 101, 105, 109, 113, 117, 121, 125, + 130, 134, 138, 142, 146, 150, 154, 158, + 162, 166, 170, 174, 178, 182, 186, 190, + 194, 198, 202, 206, 210, 215, 219, 223, + 227, 231, 235, 239, 243, 247, 251, 255 +}; + + +#define CC_SEL(cc, which) ((cc)[(which) / 32] >> ((which) & 31)) +#define UP5(c) _rgb_scale_5[(c) & 31] +#define UP6(c, b) _rgb_scale_6[(((c) & 31) << 1) | ((b) & 1)] +#define LERP(n, t, c0, c1) (((n) - (t)) * (c0) + (t) * (c1) + (n) / 2) / (n) +#define ZERO_4UBV(v) *((unsigned long *)(v)) = 0 + + +static void +fxt1_decode_1HI (unsigned long code, int t, unsigned char *rgba) +{ + const unsigned long *cc; + + t *= 3; + cc = (unsigned long *)(code + t / 8); + t = (cc[0] >> (t & 7)) & 7; + + if (t == 7) { + ZERO_4UBV(rgba); + } else { + cc = (unsigned long *)(code + 12); + if (t == 0) { + rgba[BCOMP] = UP5(CC_SEL(cc, 0)); + rgba[GCOMP] = UP5(CC_SEL(cc, 5)); + rgba[RCOMP] = UP5(CC_SEL(cc, 10)); + } else if (t == 6) { + rgba[BCOMP] = UP5(CC_SEL(cc, 15)); + rgba[GCOMP] = UP5(CC_SEL(cc, 20)); + rgba[RCOMP] = UP5(CC_SEL(cc, 25)); + } else { + rgba[BCOMP] = LERP(6, t, UP5(CC_SEL(cc, 0)), UP5(CC_SEL(cc, 15))); + rgba[GCOMP] = LERP(6, t, UP5(CC_SEL(cc, 5)), UP5(CC_SEL(cc, 20))); + rgba[RCOMP] = LERP(6, t, UP5(CC_SEL(cc, 10)), UP5(CC_SEL(cc, 25))); + } + rgba[ACOMP] = 255; + } +} + + +static void +fxt1_decode_1CHROMA (unsigned long code, int t, unsigned char *rgba) +{ + const unsigned long *cc; + unsigned long kk; + + cc = (unsigned long *)code; + if (t & 16) { + cc++; + t &= 15; + } + t = (cc[0] >> (t * 2)) & 3; + + t *= 15; + cc = (unsigned long *)(code + 8 + t / 8); + kk = cc[0] >> (t & 7); + rgba[BCOMP] = UP5(kk); + rgba[GCOMP] = UP5(kk >> 5); + rgba[RCOMP] = UP5(kk >> 10); + rgba[ACOMP] = 255; +} + + +static void +fxt1_decode_1MIXED (unsigned long code, int t, unsigned char *rgba) +{ + const unsigned long *cc; + unsigned int col[2][3]; + int glsb, selb; + + cc = (unsigned long *)code; + if (t & 16) { + t &= 15; + t = (cc[1] >> (t * 2)) & 3; + /* col 2 */ + col[0][BCOMP] = (*(unsigned long *)(code + 11)) >> 6; + col[0][GCOMP] = CC_SEL(cc, 99); + col[0][RCOMP] = CC_SEL(cc, 104); + /* col 3 */ + col[1][BCOMP] = CC_SEL(cc, 109); + col[1][GCOMP] = CC_SEL(cc, 114); + col[1][RCOMP] = CC_SEL(cc, 119); + glsb = CC_SEL(cc, 126); + selb = CC_SEL(cc, 33); + } else { + t = (cc[0] >> (t * 2)) & 3; + /* col 0 */ + col[0][BCOMP] = CC_SEL(cc, 64); + col[0][GCOMP] = CC_SEL(cc, 69); + col[0][RCOMP] = CC_SEL(cc, 74); + /* col 1 */ + col[1][BCOMP] = CC_SEL(cc, 79); + col[1][GCOMP] = CC_SEL(cc, 84); + col[1][RCOMP] = CC_SEL(cc, 89); + glsb = CC_SEL(cc, 125); + selb = CC_SEL(cc, 1); + } + + if (CC_SEL(cc, 124) & 1) { + /* alpha[0] == 1 */ + + if (t == 3) { + ZERO_4UBV(rgba); + } else { + if (t == 0) { + rgba[BCOMP] = UP5(col[0][BCOMP]); + rgba[GCOMP] = UP5(col[0][GCOMP]); + rgba[RCOMP] = UP5(col[0][RCOMP]); + } else if (t == 2) { + rgba[BCOMP] = UP5(col[1][BCOMP]); + rgba[GCOMP] = UP6(col[1][GCOMP], glsb); + rgba[RCOMP] = UP5(col[1][RCOMP]); + } else { + rgba[BCOMP] = (UP5(col[0][BCOMP]) + UP5(col[1][BCOMP])) / 2; + rgba[GCOMP] = (UP5(col[0][GCOMP]) + UP6(col[1][GCOMP], glsb)) / 2; + rgba[RCOMP] = (UP5(col[0][RCOMP]) + UP5(col[1][RCOMP])) / 2; + } + rgba[ACOMP] = 255; + } + } else { + /* alpha[0] == 0 */ + + if (t == 0) { + rgba[BCOMP] = UP5(col[0][BCOMP]); + rgba[GCOMP] = UP6(col[0][GCOMP], glsb ^ selb); + rgba[RCOMP] = UP5(col[0][RCOMP]); + } else if (t == 3) { + rgba[BCOMP] = UP5(col[1][BCOMP]); + rgba[GCOMP] = UP6(col[1][GCOMP], glsb); + rgba[RCOMP] = UP5(col[1][RCOMP]); + } else { + rgba[BCOMP] = LERP(3, t, UP5(col[0][BCOMP]), UP5(col[1][BCOMP])); + rgba[GCOMP] = LERP(3, t, UP6(col[0][GCOMP], glsb ^ selb), + UP6(col[1][GCOMP], glsb)); + rgba[RCOMP] = LERP(3, t, UP5(col[0][RCOMP]), UP5(col[1][RCOMP])); + } + rgba[ACOMP] = 255; + } +} + + +static void +fxt1_decode_1ALPHA (unsigned long code, int t, unsigned char *rgba) +{ + const unsigned long *cc; + + cc = (unsigned long *)code; + if (CC_SEL(cc, 124) & 1) { + /* lerp == 1 */ + unsigned int col0[4]; + + if (t & 16) { + t &= 15; + t = (cc[1] >> (t * 2)) & 3; + /* col 2 */ + col0[BCOMP] = (*(unsigned long *)(code + 11)) >> 6; + col0[GCOMP] = CC_SEL(cc, 99); + col0[RCOMP] = CC_SEL(cc, 104); + col0[ACOMP] = CC_SEL(cc, 119); + } else { + t = (cc[0] >> (t * 2)) & 3; + /* col 0 */ + col0[BCOMP] = CC_SEL(cc, 64); + col0[GCOMP] = CC_SEL(cc, 69); + col0[RCOMP] = CC_SEL(cc, 74); + col0[ACOMP] = CC_SEL(cc, 109); + } + + if (t == 0) { + rgba[BCOMP] = UP5(col0[BCOMP]); + rgba[GCOMP] = UP5(col0[GCOMP]); + rgba[RCOMP] = UP5(col0[RCOMP]); + rgba[ACOMP] = UP5(col0[ACOMP]); + } else if (t == 3) { + rgba[BCOMP] = UP5(CC_SEL(cc, 79)); + rgba[GCOMP] = UP5(CC_SEL(cc, 84)); + rgba[RCOMP] = UP5(CC_SEL(cc, 89)); + rgba[ACOMP] = UP5(CC_SEL(cc, 114)); + } else { + rgba[BCOMP] = LERP(3, t, UP5(col0[BCOMP]), UP5(CC_SEL(cc, 79))); + rgba[GCOMP] = LERP(3, t, UP5(col0[GCOMP]), UP5(CC_SEL(cc, 84))); + rgba[RCOMP] = LERP(3, t, UP5(col0[RCOMP]), UP5(CC_SEL(cc, 89))); + rgba[ACOMP] = LERP(3, t, UP5(col0[ACOMP]), UP5(CC_SEL(cc, 114))); + } + } else { + /* lerp == 0 */ + + if (t & 16) { + cc++; + t &= 15; + } + t = (cc[0] >> (t * 2)) & 3; + + if (t == 3) { + ZERO_4UBV(rgba); + } else { + unsigned long kk; + cc = (unsigned long *)code; + rgba[ACOMP] = UP5(cc[3] >> (t * 5 + 13)); + t *= 15; + cc = (unsigned long *)(code + 8 + t / 8); + kk = cc[0] >> (t & 7); + rgba[BCOMP] = UP5(kk); + rgba[GCOMP] = UP5(kk >> 5); + rgba[RCOMP] = UP5(kk >> 10); + } + } +} + + +void +fxt1_decode_1 (const void *texture, int width, + int i, int j, unsigned char *rgba) +{ + static void (*decode_1[]) (unsigned long, int, unsigned char *) = { + fxt1_decode_1HI, /* cc-high = "00?" */ + fxt1_decode_1HI, /* cc-high = "00?" */ + fxt1_decode_1CHROMA, /* cc-chroma = "010" */ + fxt1_decode_1ALPHA, /* alpha = "011" */ + fxt1_decode_1MIXED, /* mixed = "1??" */ + fxt1_decode_1MIXED, /* mixed = "1??" */ + fxt1_decode_1MIXED, /* mixed = "1??" */ + fxt1_decode_1MIXED /* mixed = "1??" */ + }; + + unsigned long code = (unsigned long)texture + + ((j / 4) * (width / 8) + (i / 8)) * 16; + int mode = CC_SEL((unsigned long *)code, 125); + int t = i & 7; + + if (t & 4) { + t += 12; + } + t += (j & 3) * 4; + + decode_1[mode](code, t, rgba); +} |