Use the GL datatypes. Lots of assorted clean-ups.

1 files changed, 250 insertions, 245 deletions

diff --git a/src/mesa/main/texcompress_fxt1.c b/src/mesa/main/texcompress_fxt1.c
index 2939251407..ca9b9aa0c9 100644
--- a/src/mesa/main/texcompress_fxt1.c
+++ b/src/mesa/main/texcompress_fxt1.c
@@ -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 */
-
-   int minSum = 2000; /* big enough */
-   int maxSum = -1; /* small enough */
-   int minCol = 0; /* phoudoin: silent compiler! */
-   int maxCol = 0; /* phoudoin: silent compiler! */
+   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 */
+
+   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;