mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2026-06-19 08:28:21 +02:00
Use the GL datatypes. Lots of assorted clean-ups.
This commit is contained in:
Brian Paul
parent
404055216d
commit
25b67e6404
1 changed files with 249 additions and 244 deletions
|
|
@ -40,13 +40,14 @@
|
|||
#include "texstore.h"
|
||||
|
||||
|
||||
int
|
||||
fxt1_encode (unsigned int width, unsigned int height, int comps,
|
||||
const void *source, int srcRowStride,
|
||||
void *dest, int destRowStride);
|
||||
void
|
||||
fxt1_decode_1 (const void *texture, int stride,
|
||||
int i, int j, unsigned char *rgba);
|
||||
static GLint
|
||||
fxt1_encode (GLuint width, GLuint height, GLint comps,
|
||||
const void *source, GLint srcRowStride,
|
||||
void *dest, GLint destRowStride);
|
||||
|
||||
static void
|
||||
fxt1_decode_1 (const void *texture, GLint stride,
|
||||
GLint i, GLint j, GLubyte *rgba);
|
||||
|
||||
|
||||
/**
|
||||
|
|
@ -216,7 +217,7 @@ fetch_texel_2d_f_rgb_fxt1( const struct gl_texture_image *texImage,
|
|||
texel[RCOMP] = CHAN_TO_FLOAT(rgba[RCOMP]);
|
||||
texel[GCOMP] = CHAN_TO_FLOAT(rgba[GCOMP]);
|
||||
texel[BCOMP] = CHAN_TO_FLOAT(rgba[BCOMP]);
|
||||
texel[ACOMP] = 1.0;
|
||||
texel[ACOMP] = 1.0F;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -284,9 +285,12 @@ const struct gl_texture_format _mesa_texformat_rgba_fxt1 = {
|
|||
#define LL_RMS_D 10 /* fault tolerance (maximum delta) */
|
||||
#define LL_RMS_E 255 /* fault tolerance (maximum error) */
|
||||
#define ALPHA_TS 2 /* alpha threshold: (255 - ALPHA_TS) deemed opaque */
|
||||
#define ISTBLACK(v) (*((unsigned long *)(v)) == 0)
|
||||
#define ISTBLACK(v) (*((GLuint *)(v)) == 0)
|
||||
|
||||
|
||||
/*
|
||||
* Define a 64-bit unsigned integer type and macros
|
||||
*/
|
||||
#if defined(__GNUC__) && !defined(__cplusplus)
|
||||
|
||||
#define FX64_NATIVE 1
|
||||
|
|
@ -302,7 +306,7 @@ typedef unsigned long long Fx64;
|
|||
#define FX64_NATIVE 0
|
||||
|
||||
typedef struct {
|
||||
unsigned long lo, hi;
|
||||
GLuint lo, hi;
|
||||
} Fx64;
|
||||
|
||||
#define FX64_MOV32(a, b) a.lo = b
|
||||
|
|
@ -322,20 +326,21 @@ typedef struct {
|
|||
#endif /* !__GNUC__ */
|
||||
|
||||
|
||||
|
||||
#define F(i) 1 /* can be used to obtain an oblong metric: 0.30 / 0.59 / 0.11 */
|
||||
#define SAFECDOT 1 /* for paranoids */
|
||||
|
||||
#define MAKEIVEC(NV, NC, IV, B, V0, V1) \
|
||||
do { \
|
||||
/* compute interpolation vector */ \
|
||||
float d2 = 0; \
|
||||
float rd2; \
|
||||
GLfloat d2 = 0.0F; \
|
||||
GLfloat rd2; \
|
||||
\
|
||||
for (i = 0; i < NC; i++) { \
|
||||
IV[i] = (V1[i] - V0[i]) * F(i); \
|
||||
d2 += IV[i] * IV[i]; \
|
||||
} \
|
||||
rd2 = (float)NV / d2; \
|
||||
rd2 = (GLfloat)NV / d2; \
|
||||
B = 0; \
|
||||
for (i = 0; i < NC; i++) { \
|
||||
IV[i] *= F(i); \
|
||||
|
|
@ -347,11 +352,11 @@ typedef struct {
|
|||
|
||||
#define CALCCDOT(TEXEL, NV, NC, IV, B, V)\
|
||||
do { \
|
||||
float dot = 0; \
|
||||
GLfloat dot = 0.0F; \
|
||||
for (i = 0; i < NC; i++) { \
|
||||
dot += V[i] * IV[i]; \
|
||||
} \
|
||||
TEXEL = (int)(dot + B); \
|
||||
TEXEL = (GLint)(dot + B); \
|
||||
if (SAFECDOT) { \
|
||||
if (TEXEL < 0) { \
|
||||
TEXEL = 0; \
|
||||
|
|
@ -362,15 +367,15 @@ typedef struct {
|
|||
} while (0)
|
||||
|
||||
|
||||
static int
|
||||
fxt1_bestcol (float vec[][MAX_COMP], int nv,
|
||||
unsigned char input[MAX_COMP], int nc)
|
||||
static GLint
|
||||
fxt1_bestcol (GLfloat vec[][MAX_COMP], GLint nv,
|
||||
GLubyte input[MAX_COMP], GLint nc)
|
||||
{
|
||||
int i, j, best = -1;
|
||||
float err = 1e9; /* big enough */
|
||||
GLint i, j, best = -1;
|
||||
GLfloat err = 1e9; /* big enough */
|
||||
|
||||
for (j = 0; j < nv; j++) {
|
||||
float e = 0;
|
||||
GLfloat e = 0.0F;
|
||||
for (i = 0; i < nc; i++) {
|
||||
e += (vec[j][i] - input[i]) * (vec[j][i] - input[i]);
|
||||
}
|
||||
|
|
@ -384,15 +389,15 @@ fxt1_bestcol (float vec[][MAX_COMP], int nv,
|
|||
}
|
||||
|
||||
|
||||
static int
|
||||
fxt1_worst (float vec[MAX_COMP],
|
||||
unsigned char input[N_TEXELS][MAX_COMP], int nc, int n)
|
||||
static GLint
|
||||
fxt1_worst (GLfloat vec[MAX_COMP],
|
||||
GLubyte input[N_TEXELS][MAX_COMP], GLint nc, GLint n)
|
||||
{
|
||||
int i, k, worst = -1;
|
||||
float err = -1; /* small enough */
|
||||
GLint i, k, worst = -1;
|
||||
GLfloat err = -1.0F; /* small enough */
|
||||
|
||||
for (k = 0; k < n; k++) {
|
||||
float e = 0;
|
||||
GLfloat e = 0.0F;
|
||||
for (i = 0; i < nc; i++) {
|
||||
e += (vec[i] - input[k][i]) * (vec[i] - input[k][i]);
|
||||
}
|
||||
|
|
@ -406,19 +411,19 @@ fxt1_worst (float vec[MAX_COMP],
|
|||
}
|
||||
|
||||
|
||||
static int
|
||||
fxt1_variance (double variance[MAX_COMP],
|
||||
unsigned char input[N_TEXELS][MAX_COMP], int nc, int n)
|
||||
static GLint
|
||||
fxt1_variance (GLdouble variance[MAX_COMP],
|
||||
GLubyte input[N_TEXELS][MAX_COMP], GLint nc, GLint n)
|
||||
{
|
||||
int i, k, best = 0;
|
||||
int sx, sx2;
|
||||
double var, maxvar = -1; /* small enough */
|
||||
double teenth = 1.0 / n;
|
||||
GLint i, k, best = 0;
|
||||
GLint sx, sx2;
|
||||
GLdouble var, maxvar = -1; /* small enough */
|
||||
GLdouble teenth = 1.0 / n;
|
||||
|
||||
for (i = 0; i < nc; i++) {
|
||||
sx = sx2 = 0;
|
||||
for (k = 0; k < n; k++) {
|
||||
int t = input[k][i];
|
||||
GLint t = input[k][i];
|
||||
sx += t;
|
||||
sx2 += t * t;
|
||||
}
|
||||
|
|
@ -436,17 +441,17 @@ fxt1_variance (double variance[MAX_COMP],
|
|||
}
|
||||
|
||||
|
||||
static int
|
||||
fxt1_choose (float vec[][MAX_COMP], int nv,
|
||||
unsigned char input[N_TEXELS][MAX_COMP], int nc, int n)
|
||||
static GLint
|
||||
fxt1_choose (GLfloat vec[][MAX_COMP], GLint nv,
|
||||
GLubyte input[N_TEXELS][MAX_COMP], GLint nc, GLint n)
|
||||
{
|
||||
#if 0
|
||||
/* Choose colors from a grid.
|
||||
*/
|
||||
int i, j;
|
||||
GLint i, j;
|
||||
|
||||
for (j = 0; j < nv; j++) {
|
||||
int m = j * (n - 1) / (nv - 1);
|
||||
GLint m = j * (n - 1) / (nv - 1);
|
||||
for (i = 0; i < nc; i++) {
|
||||
vec[j][i] = input[m][i];
|
||||
}
|
||||
|
|
@ -456,26 +461,26 @@ fxt1_choose (float vec[][MAX_COMP], int nv,
|
|||
* the 8x4 tile and use those as the two representative colors.
|
||||
* There are probably better algorithms to use (histogram-based).
|
||||
*/
|
||||
int i, j, k;
|
||||
int minSum = 2000; /* big enough */
|
||||
int maxSum = -1; /* small enough */
|
||||
int minCol = 0; /* phoudoin: silent compiler! */
|
||||
int maxCol = 0; /* phoudoin: silent compiler! */
|
||||
GLint i, j, k;
|
||||
GLint minSum = 2000; /* big enough */
|
||||
GLint maxSum = -1; /* small enough */
|
||||
GLint minCol = 0; /* phoudoin: silent compiler! */
|
||||
GLint maxCol = 0; /* phoudoin: silent compiler! */
|
||||
|
||||
struct {
|
||||
int flag;
|
||||
int key;
|
||||
int freq;
|
||||
int idx;
|
||||
GLint flag;
|
||||
GLint key;
|
||||
GLint freq;
|
||||
GLint idx;
|
||||
} hist[N_TEXELS];
|
||||
int lenh = 0;
|
||||
GLint lenh = 0;
|
||||
|
||||
memset(hist, 0, sizeof(hist));
|
||||
|
||||
for (k = 0; k < n; k++) {
|
||||
int l;
|
||||
int key = 0;
|
||||
int sum = 0;
|
||||
GLint l;
|
||||
GLint key = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < nc; i++) {
|
||||
key <<= 8;
|
||||
key |= input[k][i];
|
||||
|
|
@ -508,7 +513,7 @@ fxt1_choose (float vec[][MAX_COMP], int nv,
|
|||
if (lenh <= nv) {
|
||||
for (j = 0; j < lenh; j++) {
|
||||
for (i = 0; i < nc; i++) {
|
||||
vec[j][i] = (float)input[hist[j].idx][i];
|
||||
vec[j][i] = (GLfloat)input[hist[j].idx][i];
|
||||
}
|
||||
}
|
||||
for (; j < nv; j++) {
|
||||
|
|
@ -530,9 +535,9 @@ fxt1_choose (float vec[][MAX_COMP], int nv,
|
|||
}
|
||||
|
||||
|
||||
static int
|
||||
fxt1_lloyd (float vec[][MAX_COMP], int nv,
|
||||
unsigned char input[N_TEXELS][MAX_COMP], int nc, int n)
|
||||
static GLint
|
||||
fxt1_lloyd (GLfloat vec[][MAX_COMP], GLint nv,
|
||||
GLubyte input[N_TEXELS][MAX_COMP], GLint nc, GLint n)
|
||||
{
|
||||
/* Use the generalized lloyd's algorithm for VQ:
|
||||
* find 4 color vectors.
|
||||
|
|
@ -554,11 +559,11 @@ fxt1_lloyd (float vec[][MAX_COMP], int nv,
|
|||
* 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, lasterror = 1e9;
|
||||
GLint sum[MAX_VECT][MAX_COMP]; /* used to accumulate closest texels */
|
||||
GLint cnt[MAX_VECT]; /* how many times a certain vector was chosen */
|
||||
GLfloat error, lasterror = 1e9;
|
||||
|
||||
int i, j, k, rep;
|
||||
GLint i, j, k, rep;
|
||||
|
||||
/* the quantizer */
|
||||
for (rep = 0; rep < LL_N_REP; rep++) {
|
||||
|
|
@ -574,11 +579,11 @@ fxt1_lloyd (float vec[][MAX_COMP], int nv,
|
|||
/* scan whole block */
|
||||
for (k = 0; k < n; k++) {
|
||||
#if 1
|
||||
int best = -1;
|
||||
float err = 1e9; /* big enough */
|
||||
GLint best = -1;
|
||||
GLfloat err = 1e9; /* big enough */
|
||||
/* determine best vector */
|
||||
for (j = 0; j < nv; j++) {
|
||||
float e = (vec[j][0] - input[k][0]) * (vec[j][0] - input[k][0]) +
|
||||
GLfloat e = (vec[j][0] - input[k][0]) * (vec[j][0] - input[k][0]) +
|
||||
(vec[j][1] - input[k][1]) * (vec[j][1] - input[k][1]) +
|
||||
(vec[j][2] - input[k][2]) * (vec[j][2] - input[k][2]);
|
||||
if (nc == 4) {
|
||||
|
|
@ -590,7 +595,7 @@ fxt1_lloyd (float vec[][MAX_COMP], int nv,
|
|||
}
|
||||
}
|
||||
#else
|
||||
int best = fxt1_bestcol(vec, nv, input[k], nc, &err);
|
||||
GLint best = fxt1_bestcol(vec, nv, input[k], nc, &err);
|
||||
#endif
|
||||
/* add in closest color */
|
||||
for (i = 0; i < nc; i++) {
|
||||
|
|
@ -612,13 +617,13 @@ fxt1_lloyd (float vec[][MAX_COMP], int nv,
|
|||
/* move each vector to the barycenter of its closest colors */
|
||||
for (j = 0; j < nv; j++) {
|
||||
if (cnt[j]) {
|
||||
float div = 1.0F / cnt[j];
|
||||
GLfloat div = 1.0F / 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_worst(vec[j], input, nc, n);
|
||||
GLint worst = fxt1_worst(vec[j], input, nc, n);
|
||||
for (i = 0; i < nc; i++) {
|
||||
vec[j][i] = input[worst][i];
|
||||
}
|
||||
|
|
@ -631,15 +636,15 @@ fxt1_lloyd (float vec[][MAX_COMP], int nv,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize_CHROMA (unsigned long *cc,
|
||||
unsigned char input[N_TEXELS][MAX_COMP])
|
||||
fxt1_quantize_CHROMA (GLuint *cc,
|
||||
GLubyte 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;
|
||||
const GLint n_vect = 4; /* 4 base vectors to find */
|
||||
const GLint n_comp = 3; /* 3 components: R, G, B */
|
||||
GLfloat vec[MAX_VECT][MAX_COMP];
|
||||
GLint i, j, k;
|
||||
Fx64 hi; /* high quadword */
|
||||
unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
GLuint lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
|
||||
if (fxt1_choose(vec, n_vect, input, n_comp, N_TEXELS) != 0) {
|
||||
fxt1_lloyd(vec, n_vect, input, n_comp, N_TEXELS);
|
||||
|
|
@ -650,7 +655,7 @@ fxt1_quantize_CHROMA (unsigned long *cc,
|
|||
for (i = 0; i < n_comp; i++) {
|
||||
/* add in colors */
|
||||
FX64_SHL(hi, 5);
|
||||
FX64_OR32(hi, (unsigned int)(vec[j][i] / 8.0));
|
||||
FX64_OR32(hi, (GLuint)(vec[j][i] / 8.0F));
|
||||
}
|
||||
}
|
||||
((Fx64 *)cc)[1] = hi;
|
||||
|
|
@ -672,16 +677,16 @@ fxt1_quantize_CHROMA (unsigned long *cc,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize_ALPHA0 (unsigned long *cc,
|
||||
unsigned char input[N_TEXELS][MAX_COMP],
|
||||
unsigned char reord[N_TEXELS][MAX_COMP], int n)
|
||||
fxt1_quantize_ALPHA0 (GLuint *cc,
|
||||
GLubyte input[N_TEXELS][MAX_COMP],
|
||||
GLubyte reord[N_TEXELS][MAX_COMP], GLint 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;
|
||||
const GLint n_vect = 3; /* 3 base vectors to find */
|
||||
const GLint n_comp = 4; /* 4 components: R, G, B, A */
|
||||
GLfloat vec[MAX_VECT][MAX_COMP];
|
||||
GLint i, j, k;
|
||||
Fx64 hi; /* high quadword */
|
||||
unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
GLuint lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
|
||||
/* the last vector indicates zero */
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
|
|
@ -697,13 +702,13 @@ fxt1_quantize_ALPHA0 (unsigned long *cc,
|
|||
for (j = n_vect - 1; j >= 0; j--) {
|
||||
/* add in alphas */
|
||||
FX64_SHL(hi, 5);
|
||||
FX64_OR32(hi, (unsigned int)(vec[j][ACOMP] / 8.0));
|
||||
FX64_OR32(hi, (GLuint)(vec[j][ACOMP] / 8.0F));
|
||||
}
|
||||
for (j = n_vect - 1; j >= 0; j--) {
|
||||
for (i = 0; i < n_comp - 1; i++) {
|
||||
/* add in colors */
|
||||
FX64_SHL(hi, 5);
|
||||
FX64_OR32(hi, (unsigned int)(vec[j][i] / 8.0));
|
||||
FX64_OR32(hi, (GLuint)(vec[j][i] / 8.0F));
|
||||
}
|
||||
}
|
||||
((Fx64 *)cc)[1] = hi;
|
||||
|
|
@ -725,22 +730,22 @@ fxt1_quantize_ALPHA0 (unsigned long *cc,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize_ALPHA1 (unsigned long *cc,
|
||||
unsigned char input[N_TEXELS][MAX_COMP])
|
||||
fxt1_quantize_ALPHA1 (GLuint *cc,
|
||||
GLubyte input[N_TEXELS][MAX_COMP])
|
||||
{
|
||||
const int n_vect = 3; /* highest vector number in each microtile */
|
||||
const int n_comp = 4; /* 4 components: R, G, B, A */
|
||||
float vec[1 + 1 + 1][MAX_COMP]; /* 1.5 extrema for each sub-block */
|
||||
float b, iv[MAX_COMP]; /* interpolation vector */
|
||||
int i, j, k;
|
||||
const GLint n_vect = 3; /* highest vector number in each microtile */
|
||||
const GLint n_comp = 4; /* 4 components: R, G, B, A */
|
||||
GLfloat vec[1 + 1 + 1][MAX_COMP]; /* 1.5 extrema for each sub-block */
|
||||
GLfloat b, iv[MAX_COMP]; /* interpolation vector */
|
||||
GLint i, j, k;
|
||||
Fx64 hi; /* high quadword */
|
||||
unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
GLuint lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
|
||||
int minSum;
|
||||
int maxSum;
|
||||
int minColL = 0, maxColL = 0;
|
||||
int minColR = 0, maxColR = 0;
|
||||
int sumL = 0, sumR = 0;
|
||||
GLint minSum;
|
||||
GLint maxSum;
|
||||
GLint minColL = 0, maxColL = 0;
|
||||
GLint minColR = 0, maxColR = 0;
|
||||
GLint sumL = 0, sumR = 0;
|
||||
|
||||
/* Our solution here is to find the darkest and brightest colors in
|
||||
* the 4x4 tile and use those as the two representative colors.
|
||||
|
|
@ -749,7 +754,7 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
minSum = 2000; /* big enough */
|
||||
maxSum = -1; /* small enough */
|
||||
for (k = 0; k < N_TEXELS / 2; k++) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += input[k][i];
|
||||
}
|
||||
|
|
@ -766,7 +771,7 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
minSum = 2000; /* big enough */
|
||||
maxSum = -1; /* small enough */
|
||||
for (; k < N_TEXELS; k++) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += input[k][i];
|
||||
}
|
||||
|
|
@ -782,36 +787,36 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
}
|
||||
|
||||
/* choose the common vector (yuck!) */
|
||||
{
|
||||
int j1, j2;
|
||||
int v1 = 0, v2 = 0;
|
||||
float err = 1e9; /* big enough */
|
||||
float tv[2 * 2][MAX_COMP]; /* 2 extrema for each sub-block */
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
tv[0][i] = input[minColL][i];
|
||||
tv[1][i] = input[maxColL][i];
|
||||
tv[2][i] = input[minColR][i];
|
||||
tv[3][i] = input[maxColR][i];
|
||||
}
|
||||
for (j1 = 0; j1 < 2; j1++) {
|
||||
for (j2 = 2; j2 < 4; j2++) {
|
||||
float e = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
e += (tv[j1][i] - tv[j2][i]) * (tv[j1][i] - tv[j2][i]);
|
||||
}
|
||||
if (e < err) {
|
||||
err = e;
|
||||
v1 = j1;
|
||||
v2 = j2;
|
||||
}
|
||||
{
|
||||
GLint j1, j2;
|
||||
GLint v1 = 0, v2 = 0;
|
||||
GLfloat err = 1e9; /* big enough */
|
||||
GLfloat tv[2 * 2][MAX_COMP]; /* 2 extrema for each sub-block */
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
tv[0][i] = input[minColL][i];
|
||||
tv[1][i] = input[maxColL][i];
|
||||
tv[2][i] = input[minColR][i];
|
||||
tv[3][i] = input[maxColR][i];
|
||||
}
|
||||
for (j1 = 0; j1 < 2; j1++) {
|
||||
for (j2 = 2; j2 < 4; j2++) {
|
||||
GLfloat e = 0.0F;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
e += (tv[j1][i] - tv[j2][i]) * (tv[j1][i] - tv[j2][i]);
|
||||
}
|
||||
if (e < err) {
|
||||
err = e;
|
||||
v1 = j1;
|
||||
v2 = j2;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
vec[0][i] = tv[1 - v1][i];
|
||||
vec[1][i] = (tv[v1][i] * sumL + tv[v2][i] * sumR) / (sumL + sumR);
|
||||
vec[2][i] = tv[5 - v2][i];
|
||||
}
|
||||
}
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
vec[0][i] = tv[1 - v1][i];
|
||||
vec[1][i] = (tv[v1][i] * sumL + tv[v2][i] * sumR) / (sumL + sumR);
|
||||
vec[2][i] = tv[5 - v2][i];
|
||||
}
|
||||
}
|
||||
|
||||
/* left microtile */
|
||||
cc[0] = 0;
|
||||
|
|
@ -822,7 +827,7 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
/* add in texels */
|
||||
lolo = 0;
|
||||
for (k = N_TEXELS / 2 - 1; k >= 0; k--) {
|
||||
int texel;
|
||||
GLint texel;
|
||||
/* interpolate color */
|
||||
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
|
||||
/* add in texel */
|
||||
|
|
@ -842,7 +847,7 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
/* add in texels */
|
||||
lohi = 0;
|
||||
for (k = N_TEXELS - 1; k >= N_TEXELS / 2; k--) {
|
||||
int texel;
|
||||
GLint texel;
|
||||
/* interpolate color */
|
||||
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
|
||||
/* add in texel */
|
||||
|
|
@ -857,13 +862,13 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
for (j = n_vect - 1; j >= 0; j--) {
|
||||
/* add in alphas */
|
||||
FX64_SHL(hi, 5);
|
||||
FX64_OR32(hi, (unsigned int)(vec[j][ACOMP] / 8.0F));
|
||||
FX64_OR32(hi, (GLuint)(vec[j][ACOMP] / 8.0F));
|
||||
}
|
||||
for (j = n_vect - 1; j >= 0; j--) {
|
||||
for (i = 0; i < n_comp - 1; i++) {
|
||||
/* add in colors */
|
||||
FX64_SHL(hi, 5);
|
||||
FX64_OR32(hi, (unsigned int)(vec[j][i] / 8.0F));
|
||||
FX64_OR32(hi, (GLuint)(vec[j][i] / 8.0F));
|
||||
}
|
||||
}
|
||||
((Fx64 *)cc)[1] = hi;
|
||||
|
|
@ -871,28 +876,28 @@ fxt1_quantize_ALPHA1 (unsigned long *cc,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize_HI (unsigned long *cc,
|
||||
unsigned char input[N_TEXELS][MAX_COMP],
|
||||
unsigned char reord[N_TEXELS][MAX_COMP], int n)
|
||||
fxt1_quantize_HI (GLuint *cc,
|
||||
GLubyte input[N_TEXELS][MAX_COMP],
|
||||
GLubyte reord[N_TEXELS][MAX_COMP], GLint n)
|
||||
{
|
||||
const int n_vect = 6; /* highest vector number */
|
||||
const int n_comp = 3; /* 3 components: R, G, B */
|
||||
float b = 0.0; /* phoudoin: silent compiler! */
|
||||
float iv[MAX_COMP]; /* interpolation vector */
|
||||
int i, k;
|
||||
unsigned long hihi; /* high quadword: hi dword */
|
||||
const GLint n_vect = 6; /* highest vector number */
|
||||
const GLint n_comp = 3; /* 3 components: R, G, B */
|
||||
GLfloat b = 0.0F; /* phoudoin: silent compiler! */
|
||||
GLfloat iv[MAX_COMP]; /* interpolation vector */
|
||||
GLint i, k;
|
||||
GLuint hihi; /* high quadword: hi dword */
|
||||
|
||||
int minSum = 2000; /* big enough */
|
||||
int maxSum = -1; /* small enough */
|
||||
int minCol = 0; /* phoudoin: silent compiler! */
|
||||
int maxCol = 0; /* phoudoin: silent compiler! */
|
||||
GLint minSum = 2000; /* big enough */
|
||||
GLint maxSum = -1; /* small enough */
|
||||
GLint minCol = 0; /* phoudoin: silent compiler! */
|
||||
GLint maxCol = 0; /* phoudoin: silent compiler! */
|
||||
|
||||
/* Our solution here is to find the darkest and brightest colors in
|
||||
* the 8x4 tile and use those as the two representative colors.
|
||||
* There are probably better algorithms to use (histogram-based).
|
||||
*/
|
||||
for (k = 0; k < n; k++) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += reord[k][i];
|
||||
}
|
||||
|
|
@ -927,9 +932,9 @@ fxt1_quantize_HI (unsigned long *cc,
|
|||
|
||||
/* add in texels */
|
||||
for (k = N_TEXELS - 1; k >= 0; k--) {
|
||||
int t = k * 3;
|
||||
unsigned long *kk = (unsigned long *)((unsigned long)cc + t / 8);
|
||||
int texel = n_vect + 1; /* transparent black */
|
||||
GLint t = k * 3;
|
||||
GLuint *kk = (GLuint *)((GLuint)cc + t / 8);
|
||||
GLint texel = n_vect + 1; /* transparent black */
|
||||
|
||||
if (!ISTBLACK(input[k])) {
|
||||
if (minCol != maxCol) {
|
||||
|
|
@ -947,21 +952,21 @@ fxt1_quantize_HI (unsigned long *cc,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize_MIXED1 (unsigned long *cc,
|
||||
unsigned char input[N_TEXELS][MAX_COMP])
|
||||
fxt1_quantize_MIXED1 (GLuint *cc,
|
||||
GLubyte input[N_TEXELS][MAX_COMP])
|
||||
{
|
||||
const int n_vect = 2; /* highest vector number in each microtile */
|
||||
const int n_comp = 3; /* 3 components: R, G, B */
|
||||
unsigned char vec[2 * 2][MAX_COMP]; /* 2 extrema for each sub-block */
|
||||
float b, iv[MAX_COMP]; /* interpolation vector */
|
||||
int i, j, k;
|
||||
const GLint n_vect = 2; /* highest vector number in each microtile */
|
||||
const GLint n_comp = 3; /* 3 components: R, G, B */
|
||||
GLubyte vec[2 * 2][MAX_COMP]; /* 2 extrema for each sub-block */
|
||||
GLfloat b, iv[MAX_COMP]; /* interpolation vector */
|
||||
GLint i, j, k;
|
||||
Fx64 hi; /* high quadword */
|
||||
unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
GLuint lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
|
||||
int minSum;
|
||||
int maxSum;
|
||||
int minColL = 0, maxColL = -1;
|
||||
int minColR = 0, maxColR = -1;
|
||||
GLint minSum;
|
||||
GLint maxSum;
|
||||
GLint minColL = 0, maxColL = -1;
|
||||
GLint minColR = 0, maxColR = -1;
|
||||
|
||||
/* Our solution here is to find the darkest and brightest colors in
|
||||
* the 4x4 tile and use those as the two representative colors.
|
||||
|
|
@ -971,7 +976,7 @@ fxt1_quantize_MIXED1 (unsigned long *cc,
|
|||
maxSum = -1; /* small enough */
|
||||
for (k = 0; k < N_TEXELS / 2; k++) {
|
||||
if (!ISTBLACK(input[k])) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += input[k][i];
|
||||
}
|
||||
|
|
@ -989,7 +994,7 @@ fxt1_quantize_MIXED1 (unsigned long *cc,
|
|||
maxSum = -1; /* small enough */
|
||||
for (; k < N_TEXELS; k++) {
|
||||
if (!ISTBLACK(input[k])) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += input[k][i];
|
||||
}
|
||||
|
|
@ -1025,7 +1030,7 @@ fxt1_quantize_MIXED1 (unsigned long *cc,
|
|||
/* add in texels */
|
||||
lolo = 0;
|
||||
for (k = N_TEXELS / 2 - 1; k >= 0; k--) {
|
||||
int texel = n_vect + 1; /* transparent black */
|
||||
GLint texel = n_vect + 1; /* transparent black */
|
||||
if (!ISTBLACK(input[k])) {
|
||||
/* interpolate color */
|
||||
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
|
||||
|
|
@ -1059,7 +1064,7 @@ fxt1_quantize_MIXED1 (unsigned long *cc,
|
|||
/* add in texels */
|
||||
lohi = 0;
|
||||
for (k = N_TEXELS - 1; k >= N_TEXELS / 2; k--) {
|
||||
int texel = n_vect + 1; /* transparent black */
|
||||
GLint texel = n_vect + 1; /* transparent black */
|
||||
if (!ISTBLACK(input[k])) {
|
||||
/* interpolate color */
|
||||
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
|
||||
|
|
@ -1085,22 +1090,22 @@ fxt1_quantize_MIXED1 (unsigned long *cc,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize_MIXED0 (unsigned long *cc,
|
||||
unsigned char input[N_TEXELS][MAX_COMP])
|
||||
fxt1_quantize_MIXED0 (GLuint *cc,
|
||||
GLubyte input[N_TEXELS][MAX_COMP])
|
||||
{
|
||||
const int n_vect = 3; /* highest vector number in each microtile */
|
||||
const int n_comp = 3; /* 3 components: R, G, B */
|
||||
unsigned char vec[2 * 2][MAX_COMP]; /* 2 extrema for each sub-block */
|
||||
float b, iv[MAX_COMP]; /* interpolation vector */
|
||||
int i, j, k;
|
||||
const GLint n_vect = 3; /* highest vector number in each microtile */
|
||||
const GLint n_comp = 3; /* 3 components: R, G, B */
|
||||
GLubyte vec[2 * 2][MAX_COMP]; /* 2 extrema for each sub-block */
|
||||
GLfloat b, iv[MAX_COMP]; /* interpolation vector */
|
||||
GLint i, j, k;
|
||||
Fx64 hi; /* high quadword */
|
||||
unsigned long lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
GLuint lohi, lolo; /* low quadword: hi dword, lo dword */
|
||||
|
||||
int minColL = 0, maxColL = 0;
|
||||
int minColR = 0, maxColR = 0;
|
||||
GLint minColL = 0, maxColL = 0;
|
||||
GLint minColR = 0, maxColR = 0;
|
||||
#if 0
|
||||
int minSum;
|
||||
int maxSum;
|
||||
GLint minSum;
|
||||
GLint maxSum;
|
||||
|
||||
/* Our solution here is to find the darkest and brightest colors in
|
||||
* the 4x4 tile and use those as the two representative colors.
|
||||
|
|
@ -1109,7 +1114,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
minSum = 2000; /* big enough */
|
||||
maxSum = -1; /* small enough */
|
||||
for (k = 0; k < N_TEXELS / 2; k++) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += input[k][i];
|
||||
}
|
||||
|
|
@ -1125,7 +1130,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
minSum = 2000; /* big enough */
|
||||
maxSum = -1; /* small enough */
|
||||
for (; k < N_TEXELS; k++) {
|
||||
int sum = 0;
|
||||
GLint sum = 0;
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
sum += input[k][i];
|
||||
}
|
||||
|
|
@ -1139,10 +1144,10 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
}
|
||||
}
|
||||
#else
|
||||
int minVal;
|
||||
int maxVal;
|
||||
int maxVarL = fxt1_variance(NULL, input, n_comp, N_TEXELS / 2);
|
||||
int maxVarR = fxt1_variance(NULL, &input[N_TEXELS / 2], n_comp, N_TEXELS / 2);
|
||||
GLint minVal;
|
||||
GLint maxVal;
|
||||
GLint maxVarL = fxt1_variance(NULL, input, n_comp, N_TEXELS / 2);
|
||||
GLint maxVarR = fxt1_variance(NULL, &input[N_TEXELS / 2], n_comp, N_TEXELS / 2);
|
||||
|
||||
/* Scan the channel with max variance for lo & hi
|
||||
* and use those as the two representative colors.
|
||||
|
|
@ -1150,7 +1155,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
minVal = 2000; /* big enough */
|
||||
maxVal = -1; /* small enough */
|
||||
for (k = 0; k < N_TEXELS / 2; k++) {
|
||||
int t = input[k][maxVarL];
|
||||
GLint t = input[k][maxVarL];
|
||||
if (minVal > t) {
|
||||
minVal = t;
|
||||
minColL = k;
|
||||
|
|
@ -1163,7 +1168,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
minVal = 2000; /* big enough */
|
||||
maxVal = -1; /* small enough */
|
||||
for (; k < N_TEXELS; k++) {
|
||||
int t = input[k][maxVarR];
|
||||
GLint t = input[k][maxVarR];
|
||||
if (minVal > t) {
|
||||
minVal = t;
|
||||
minColR = k;
|
||||
|
|
@ -1188,7 +1193,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
/* add in texels */
|
||||
lolo = 0;
|
||||
for (k = N_TEXELS / 2 - 1; k >= 0; k--) {
|
||||
int texel;
|
||||
GLint texel;
|
||||
/* interpolate color */
|
||||
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
|
||||
/* add in texel */
|
||||
|
|
@ -1197,7 +1202,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
}
|
||||
|
||||
/* funky encoding for LSB of green */
|
||||
if ((int)((lolo >> 1) & 1) != (((vec[1][GCOMP] ^ vec[0][GCOMP]) >> 2) & 1)) {
|
||||
if ((GLint)((lolo >> 1) & 1) != (((vec[1][GCOMP] ^ vec[0][GCOMP]) >> 2) & 1)) {
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
vec[1][i] = input[minColL][i];
|
||||
vec[0][i] = input[maxColL][i];
|
||||
|
|
@ -1221,7 +1226,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
/* add in texels */
|
||||
lohi = 0;
|
||||
for (k = N_TEXELS - 1; k >= N_TEXELS / 2; k--) {
|
||||
int texel;
|
||||
GLint texel;
|
||||
/* interpolate color */
|
||||
CALCCDOT(texel, n_vect, n_comp, iv, b, input[k]);
|
||||
/* add in texel */
|
||||
|
|
@ -1230,7 +1235,7 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
}
|
||||
|
||||
/* funky encoding for LSB of green */
|
||||
if ((int)((lohi >> 1) & 1) != (((vec[3][GCOMP] ^ vec[2][GCOMP]) >> 2) & 1)) {
|
||||
if ((GLint)((lohi >> 1) & 1) != (((vec[3][GCOMP] ^ vec[2][GCOMP]) >> 2) & 1)) {
|
||||
for (i = 0; i < n_comp; i++) {
|
||||
vec[3][i] = input[minColR][i];
|
||||
vec[2][i] = input[maxColR][i];
|
||||
|
|
@ -1254,13 +1259,13 @@ fxt1_quantize_MIXED0 (unsigned long *cc,
|
|||
|
||||
|
||||
static void
|
||||
fxt1_quantize (unsigned long *cc, const unsigned char *lines[], int comps)
|
||||
fxt1_quantize (GLuint *cc, const GLubyte *lines[], GLint comps)
|
||||
{
|
||||
int trualpha;
|
||||
unsigned char reord[N_TEXELS][MAX_COMP];
|
||||
GLint trualpha;
|
||||
GLubyte reord[N_TEXELS][MAX_COMP];
|
||||
|
||||
unsigned char input[N_TEXELS][MAX_COMP];
|
||||
int i, k, l;
|
||||
GLubyte input[N_TEXELS][MAX_COMP];
|
||||
GLint i, k, l;
|
||||
|
||||
if (comps == 3) {
|
||||
/* make the whole block opaque */
|
||||
|
|
@ -1342,22 +1347,22 @@ fxt1_quantize (unsigned long *cc, const unsigned char *lines[], int comps)
|
|||
}
|
||||
|
||||
|
||||
int
|
||||
fxt1_encode (unsigned int width, unsigned int height, int comps,
|
||||
const void *source, int srcRowStride,
|
||||
void *dest, int destRowStride)
|
||||
static GLint
|
||||
fxt1_encode (GLuint width, GLuint height, GLint comps,
|
||||
const void *source, GLint srcRowStride,
|
||||
void *dest, GLint destRowStride)
|
||||
{
|
||||
unsigned int x, y;
|
||||
const unsigned char *data;
|
||||
unsigned long *encoded = (unsigned long *) dest;
|
||||
unsigned char *newSource = NULL;
|
||||
GLuint x, y;
|
||||
const GLubyte *data;
|
||||
GLuint *encoded = (GLuint *) dest;
|
||||
GLubyte *newSource = NULL;
|
||||
|
||||
/* Replicate image if width is not M8 or height is not M4 */
|
||||
if ((width & 7) | (height & 3)) {
|
||||
int newWidth = (width + 7) & ~7;
|
||||
int newHeight = (height + 3) & ~3;
|
||||
newSource = (unsigned char *)
|
||||
_mesa_malloc(comps * newWidth * newHeight * sizeof(unsigned char *));
|
||||
GLint newWidth = (width + 7) & ~7;
|
||||
GLint newHeight = (height + 3) & ~3;
|
||||
newSource = (GLubyte *)
|
||||
_mesa_malloc(comps * newWidth * newHeight * sizeof(GLubyte *));
|
||||
_mesa_upscale_teximage2d(width, height, newWidth, newHeight,
|
||||
comps, (const GLchan *) source,
|
||||
srcRowStride, newSource);
|
||||
|
|
@ -1367,12 +1372,12 @@ fxt1_encode (unsigned int width, unsigned int height, int comps,
|
|||
srcRowStride = comps * newWidth;
|
||||
}
|
||||
|
||||
data = (const unsigned char *) source;
|
||||
data = (const GLubyte *) source;
|
||||
destRowStride = (destRowStride - width * 2) / 4;
|
||||
for (y = 0; y < height; y += 4) {
|
||||
unsigned int offs = 0 + (y + 0) * srcRowStride;
|
||||
GLuint offs = 0 + (y + 0) * srcRowStride;
|
||||
for (x = 0; x < width; x += 8) {
|
||||
const unsigned char *lines[4];
|
||||
const GLubyte *lines[4];
|
||||
lines[0] = &data[offs];
|
||||
lines[1] = lines[0] + srcRowStride;
|
||||
lines[2] = lines[1] + srcRowStride;
|
||||
|
|
@ -1386,7 +1391,7 @@ fxt1_encode (unsigned int width, unsigned int height, int comps,
|
|||
}
|
||||
|
||||
if (newSource != NULL) {
|
||||
free(newSource);
|
||||
_mesa_free(newSource);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -1402,7 +1407,7 @@ fxt1_encode (unsigned int width, unsigned int height, int comps,
|
|||
|
||||
|
||||
/* lookup table for scaling 5 bit colors up to 8 bits */
|
||||
static unsigned char _rgb_scale_5[] = {
|
||||
static GLubyte _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,
|
||||
|
|
@ -1410,7 +1415,7 @@ static unsigned char _rgb_scale_5[] = {
|
|||
};
|
||||
|
||||
/* lookup table for scaling 6 bit colors up to 8 bits */
|
||||
static unsigned char _rgb_scale_6[] = {
|
||||
static GLubyte _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,
|
||||
|
|
@ -1422,26 +1427,26 @@ static unsigned char _rgb_scale_6[] = {
|
|||
};
|
||||
|
||||
|
||||
#define CC_SEL(cc, which) (((unsigned long *)(cc))[(which) / 32] >> ((which) & 31))
|
||||
#define CC_SEL(cc, which) (((GLuint *)(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
|
||||
#define ZERO_4UBV(v) *((GLuint *)(v)) = 0
|
||||
|
||||
|
||||
static void
|
||||
fxt1_decode_1HI (unsigned char *code, int t, unsigned char *rgba)
|
||||
fxt1_decode_1HI (GLubyte *code, GLint t, GLubyte *rgba)
|
||||
{
|
||||
const unsigned long *cc;
|
||||
const GLuint *cc;
|
||||
|
||||
t *= 3;
|
||||
cc = (unsigned long *)(code + t / 8);
|
||||
cc = (GLuint *)(code + t / 8);
|
||||
t = (cc[0] >> (t & 7)) & 7;
|
||||
|
||||
if (t == 7) {
|
||||
ZERO_4UBV(rgba);
|
||||
} else {
|
||||
cc = (unsigned long *)(code + 12);
|
||||
cc = (GLuint *)(code + 12);
|
||||
if (t == 0) {
|
||||
rgba[BCOMP] = UP5(CC_SEL(cc, 0));
|
||||
rgba[GCOMP] = UP5(CC_SEL(cc, 5));
|
||||
|
|
@ -1461,12 +1466,12 @@ fxt1_decode_1HI (unsigned char *code, int t, unsigned char *rgba)
|
|||
|
||||
|
||||
static void
|
||||
fxt1_decode_1CHROMA (unsigned char *code, int t, unsigned char *rgba)
|
||||
fxt1_decode_1CHROMA (GLubyte *code, GLint t, GLubyte *rgba)
|
||||
{
|
||||
const unsigned long *cc;
|
||||
unsigned long kk;
|
||||
const GLuint *cc;
|
||||
GLuint kk;
|
||||
|
||||
cc = (unsigned long *)code;
|
||||
cc = (GLuint *)code;
|
||||
if (t & 16) {
|
||||
cc++;
|
||||
t &= 15;
|
||||
|
|
@ -1474,7 +1479,7 @@ fxt1_decode_1CHROMA (unsigned char *code, int t, unsigned char *rgba)
|
|||
t = (cc[0] >> (t * 2)) & 3;
|
||||
|
||||
t *= 15;
|
||||
cc = (unsigned long *)(code + 8 + t / 8);
|
||||
cc = (GLuint *)(code + 8 + t / 8);
|
||||
kk = cc[0] >> (t & 7);
|
||||
rgba[BCOMP] = UP5(kk);
|
||||
rgba[GCOMP] = UP5(kk >> 5);
|
||||
|
|
@ -1484,18 +1489,18 @@ fxt1_decode_1CHROMA (unsigned char *code, int t, unsigned char *rgba)
|
|||
|
||||
|
||||
static void
|
||||
fxt1_decode_1MIXED (unsigned char *code, int t, unsigned char *rgba)
|
||||
fxt1_decode_1MIXED (GLubyte *code, GLint t, GLubyte *rgba)
|
||||
{
|
||||
const unsigned long *cc;
|
||||
unsigned int col[2][3];
|
||||
int glsb, selb;
|
||||
const GLuint *cc;
|
||||
GLuint col[2][3];
|
||||
GLint glsb, selb;
|
||||
|
||||
cc = (unsigned long *)code;
|
||||
cc = (GLuint *)code;
|
||||
if (t & 16) {
|
||||
t &= 15;
|
||||
t = (cc[1] >> (t * 2)) & 3;
|
||||
/* col 2 */
|
||||
col[0][BCOMP] = (*(unsigned long *)(code + 11)) >> 6;
|
||||
col[0][BCOMP] = (*(GLuint *)(code + 11)) >> 6;
|
||||
col[0][GCOMP] = CC_SEL(cc, 99);
|
||||
col[0][RCOMP] = CC_SEL(cc, 104);
|
||||
/* col 3 */
|
||||
|
|
@ -1562,20 +1567,20 @@ fxt1_decode_1MIXED (unsigned char *code, int t, unsigned char *rgba)
|
|||
|
||||
|
||||
static void
|
||||
fxt1_decode_1ALPHA (unsigned char *code, int t, unsigned char *rgba)
|
||||
fxt1_decode_1ALPHA (GLubyte *code, GLint t, GLubyte *rgba)
|
||||
{
|
||||
const unsigned long *cc;
|
||||
const GLuint *cc;
|
||||
|
||||
cc = (unsigned long *)code;
|
||||
cc = (GLuint *)code;
|
||||
if (CC_SEL(cc, 124) & 1) {
|
||||
/* lerp == 1 */
|
||||
unsigned int col0[4];
|
||||
GLuint col0[4];
|
||||
|
||||
if (t & 16) {
|
||||
t &= 15;
|
||||
t = (cc[1] >> (t * 2)) & 3;
|
||||
/* col 2 */
|
||||
col0[BCOMP] = (*(unsigned long *)(code + 11)) >> 6;
|
||||
col0[BCOMP] = (*(GLuint *)(code + 11)) >> 6;
|
||||
col0[GCOMP] = CC_SEL(cc, 99);
|
||||
col0[RCOMP] = CC_SEL(cc, 104);
|
||||
col0[ACOMP] = CC_SEL(cc, 119);
|
||||
|
|
@ -1616,11 +1621,11 @@ fxt1_decode_1ALPHA (unsigned char *code, int t, unsigned char *rgba)
|
|||
if (t == 3) {
|
||||
ZERO_4UBV(rgba);
|
||||
} else {
|
||||
unsigned long kk;
|
||||
cc = (unsigned long *)code;
|
||||
GLuint kk;
|
||||
cc = (GLuint *)code;
|
||||
rgba[ACOMP] = UP5(cc[3] >> (t * 5 + 13));
|
||||
t *= 15;
|
||||
cc = (unsigned long *)(code + 8 + t / 8);
|
||||
cc = (GLuint *)(code + 8 + t / 8);
|
||||
kk = cc[0] >> (t & 7);
|
||||
rgba[BCOMP] = UP5(kk);
|
||||
rgba[GCOMP] = UP5(kk >> 5);
|
||||
|
|
@ -1630,11 +1635,11 @@ fxt1_decode_1ALPHA (unsigned char *code, int t, unsigned char *rgba)
|
|||
}
|
||||
|
||||
|
||||
void
|
||||
fxt1_decode_1 (const void *texture, int stride, /* in pixels */
|
||||
int i, int j, unsigned char *rgba)
|
||||
static void
|
||||
fxt1_decode_1 (const void *texture, GLint stride, /* in pixels */
|
||||
GLint i, GLint j, GLubyte *rgba)
|
||||
{
|
||||
static void (*decode_1[]) (unsigned char *, int, unsigned char *) = {
|
||||
static void (*decode_1[]) (GLubyte *, GLint, GLubyte *) = {
|
||||
fxt1_decode_1HI, /* cc-high = "00?" */
|
||||
fxt1_decode_1HI, /* cc-high = "00?" */
|
||||
fxt1_decode_1CHROMA, /* cc-chroma = "010" */
|
||||
|
|
@ -1645,10 +1650,10 @@ fxt1_decode_1 (const void *texture, int stride, /* in pixels */
|
|||
fxt1_decode_1MIXED /* mixed = "1??" */
|
||||
};
|
||||
|
||||
unsigned char *code = (unsigned char *)texture +
|
||||
GLubyte *code = (GLubyte *)texture +
|
||||
((j / 4) * (stride / 8) + (i / 8)) * 16;
|
||||
int mode = CC_SEL((unsigned long *)code, 125);
|
||||
int t = i & 7;
|
||||
GLint mode = CC_SEL((GLuint *)code, 125);
|
||||
GLint t = i & 7;
|
||||
|
||||
if (t & 4) {
|
||||
t += 12;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue