move _swrast_texture_table_lookup() to _mesa_lookup_rgba_chan()

6 files changed, 348 insertions, 350 deletions

diff --git a/src/mesa/main/image.c b/src/mesa/main/image.c
index 648ad8fe34..9677faeef2 100644
--- a/src/mesa/main/image.c
+++ b/src/mesa/main/image.c
@@ -957,7 +957,7 @@ _mesa_pack_float_rgba_span( GLcontext *ctx,
       }
       /* GL_COLOR_TABLE lookup */
       if (transferOps & IMAGE_COLOR_TABLE_BIT) {
-         _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
+         _mesa_lookup_rgba_float(&ctx->ColorTable, n, rgba);
       }
       /* convolution */
       if (transferOps & IMAGE_CONVOLUTION_BIT) {
@@ -977,7 +977,7 @@ _mesa_pack_float_rgba_span( GLcontext *ctx,
       }
       /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
       if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
-         _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
+         _mesa_lookup_rgba_float(&ctx->PostConvolutionColorTable, n, rgba);
       }
       /* color matrix transform */
       if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
@@ -985,7 +985,7 @@ _mesa_pack_float_rgba_span( GLcontext *ctx,
       }
       /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
       if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
-         _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
+         _mesa_lookup_rgba_float(&ctx->PostColorMatrixColorTable, n, rgba);
       }
       /* update histogram count */
       if (transferOps & IMAGE_HISTOGRAM_BIT) {
@@ -2932,7 +2932,7 @@ _mesa_unpack_chan_color_span( GLcontext *ctx,
       if (transferOps) {
          /* GL_COLOR_TABLE lookup */
          if (transferOps & IMAGE_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
+            _mesa_lookup_rgba_float(&ctx->ColorTable, n, rgba);
          }
          /* convolution */
          if (transferOps & IMAGE_CONVOLUTION_BIT) {
@@ -2952,7 +2952,7 @@ _mesa_unpack_chan_color_span( GLcontext *ctx,
          }
          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
          if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
+            _mesa_lookup_rgba_float(&ctx->PostConvolutionColorTable, n, rgba);
          }
          /* color matrix transform */
          if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
@@ -2960,7 +2960,7 @@ _mesa_unpack_chan_color_span( GLcontext *ctx,
          }
          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
          if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
+            _mesa_lookup_rgba_float(&ctx->PostColorMatrixColorTable, n, rgba);
          }
          /* update histogram count */
          if (transferOps & IMAGE_HISTOGRAM_BIT) {
@@ -3210,7 +3210,7 @@ _mesa_unpack_float_color_span( GLcontext *ctx,
       if (transferOps) {
          /* GL_COLOR_TABLE lookup */
          if (transferOps & IMAGE_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
+            _mesa_lookup_rgba_float(&ctx->ColorTable, n, rgba);
          }
          /* convolution */
          if (transferOps & IMAGE_CONVOLUTION_BIT) {
@@ -3230,7 +3230,7 @@ _mesa_unpack_float_color_span( GLcontext *ctx,
          }
          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
          if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
+            _mesa_lookup_rgba_float(&ctx->PostConvolutionColorTable, n, rgba);
          }
          /* color matrix transform */
          if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
@@ -3238,7 +3238,7 @@ _mesa_unpack_float_color_span( GLcontext *ctx,
          }
          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
          if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
+            _mesa_lookup_rgba_float(&ctx->PostColorMatrixColorTable, n, rgba);
          }
          /* update histogram count */
          if (transferOps & IMAGE_HISTOGRAM_BIT) {
diff --git a/src/mesa/main/pixel.c b/src/mesa/main/pixel.c
index f211af9170..6800170faa 100644
--- a/src/mesa/main/pixel.c
+++ b/src/mesa/main/pixel.c
@@ -1,9 +1,8 @@
-
 /*
  * Mesa 3-D graphics library
- * Version:  5.1
+ * Version:  6.1
  *
- * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -875,13 +874,12 @@ _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
 }
 
 
-/*
- * Apply a color table lookup to an array of colors.
- * XXX merge with _swrast_texture_table_lookup in s_texture.c
+/**
+ * Apply a color table lookup to an array of floating point RGBA colors.
  */
 void
-_mesa_lookup_rgba(const struct gl_color_table *table,
-                  GLuint n, GLfloat rgba[][4])
+_mesa_lookup_rgba_float(const struct gl_color_table *table,
+                        GLuint n, GLfloat rgba[][4])
 {
    if (!table->Table || table->Size == 0)
       return;
@@ -889,14 +887,14 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
    switch (table->Format) {
       case GL_INTENSITY:
          /* replace RGBA with I */
-         if (table->Type != GL_FLOAT) {
+         if (table->Type == GL_FLOAT) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLchan *lut = (const GLchan *) table->Table;
+            const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint j = IROUND(rgba[i][RCOMP] * scale);
-               GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
+               GLfloat c = lut[CLAMP(j, 0, max)];
                rgba[i][RCOMP] = rgba[i][GCOMP] =
                   rgba[i][BCOMP] = rgba[i][ACOMP] = c;
             }
@@ -904,11 +902,11 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
          else {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLfloat *lut = (const GLfloat *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint j = IROUND(rgba[i][RCOMP] * scale);
-               GLfloat c = lut[CLAMP(j, 0, max)];
+               GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
                rgba[i][RCOMP] = rgba[i][GCOMP] =
                   rgba[i][BCOMP] = rgba[i][ACOMP] = c;
             }
@@ -916,58 +914,58 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
          break;
       case GL_LUMINANCE:
          /* replace RGB with L */
-         if (table->Type != GL_FLOAT) {
+         if (table->Type == GL_FLOAT) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLchan *lut = (const GLchan *) table->Table;
+            const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint j = IROUND(rgba[i][RCOMP] * scale);
-               GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
+               GLfloat c = lut[CLAMP(j, 0, max)];
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
             }
          }
          else {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLfloat *lut = (const GLfloat *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint j = IROUND(rgba[i][RCOMP] * scale);
-               GLfloat c = lut[CLAMP(j, 0, max)];
+               GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
             }
          }
          break;
       case GL_ALPHA:
          /* replace A with A */
-         if (table->Type != GL_FLOAT) {
+         if (table->Type == GL_FLOAT) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLchan *lut = (const GLchan *) table->Table;
+            const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint j = IROUND(rgba[i][ACOMP] * scale);
-               rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
+               rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
             }
          }
-         else  {
+         else {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLfloat *lut = (const GLfloat *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint j = IROUND(rgba[i][ACOMP] * scale);
-               rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
+               rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
             }
          }
          break;
       case GL_LUMINANCE_ALPHA:
          /* replace RGBA with LLLA */
-         if (table->Type != GL_FLOAT) {
+         if (table->Type == GL_FLOAT) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLchan *lut = (const GLchan *) table->Table;
+            const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint jL = IROUND(rgba[i][RCOMP] * scale);
@@ -975,8 +973,8 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
                GLfloat luminance, alpha;
                jL = CLAMP(jL, 0, max);
                jA = CLAMP(jA, 0, max);
-               luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
-               alpha     = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
+               luminance = lut[jL * 2 + 0];
+               alpha     = lut[jA * 2 + 1];
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
                rgba[i][ACOMP] = alpha;;
             }
@@ -984,7 +982,7 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
          else {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLfloat *lut = (const GLfloat *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint jL = IROUND(rgba[i][RCOMP] * scale);
@@ -992,8 +990,8 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
                GLfloat luminance, alpha;
                jL = CLAMP(jL, 0, max);
                jA = CLAMP(jA, 0, max);
-               luminance = lut[jL * 2 + 0];
-               alpha     = lut[jA * 2 + 1];
+               luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
+               alpha     = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
                rgba[i][ACOMP] = alpha;;
             }
@@ -1001,10 +999,10 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
          break;
       case GL_RGB:
          /* replace RGB with RGB */
-         if (table->Type != GL_FLOAT) {
+         if (table->Type == GL_FLOAT) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLchan *lut = (const GLchan *) table->Table;
+            const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint jR = IROUND(rgba[i][RCOMP] * scale);
@@ -1013,15 +1011,15 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
                jR = CLAMP(jR, 0, max);
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
-               rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
-               rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
-               rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
+               rgba[i][RCOMP] = lut[jR * 3 + 0];
+               rgba[i][GCOMP] = lut[jG * 3 + 1];
+               rgba[i][BCOMP] = lut[jB * 3 + 2];
             }
          }
          else {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLfloat *lut = (const GLfloat *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint jR = IROUND(rgba[i][RCOMP] * scale);
@@ -1030,18 +1028,18 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
                jR = CLAMP(jR, 0, max);
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
-               rgba[i][RCOMP] = lut[jR * 3 + 0];
-               rgba[i][GCOMP] = lut[jG * 3 + 1];
-               rgba[i][BCOMP] = lut[jB * 3 + 2];
+               rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
+               rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
+               rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
             }
          }
          break;
       case GL_RGBA:
          /* replace RGBA with RGBA */
-         if (table->Type != GL_FLOAT) {
+         if (table->Type == GL_FLOAT) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLchan *lut = (const GLchan *) table->Table;
+            const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint jR = IROUND(rgba[i][RCOMP] * scale);
@@ -1052,16 +1050,16 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
                jA = CLAMP(jA, 0, max);
-               rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
-               rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
-               rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
-               rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
+               rgba[i][RCOMP] = lut[jR * 4 + 0];
+               rgba[i][GCOMP] = lut[jG * 4 + 1];
+               rgba[i][BCOMP] = lut[jB * 4 + 2];
+               rgba[i][ACOMP] = lut[jA * 4 + 3];
             }
          }
          else {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLfloat *lut = (const GLfloat *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
                GLint jR = IROUND(rgba[i][RCOMP] * scale);
@@ -1072,15 +1070,286 @@ _mesa_lookup_rgba(const struct gl_color_table *table,
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
                jA = CLAMP(jA, 0, max);
-               rgba[i][RCOMP] = lut[jR * 4 + 0];
-               rgba[i][GCOMP] = lut[jG * 4 + 1];
-               rgba[i][BCOMP] = lut[jB * 4 + 2];
-               rgba[i][ACOMP] = lut[jA * 4 + 3];
+               rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
+               rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
+               rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
+               rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
+            }
+         }
+         break;
+      default:
+         _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
+         return;
+   }
+}
+
+
+
+/**
+ * Apply a color table lookup to an array of GLchan RGBA colors.
+ */
+void
+_mesa_lookup_rgba_chan(const struct gl_color_table *table,
+                       GLuint n, GLchan rgba[][4])
+{
+   if (!table->Table || table->Size == 0)
+      return;
+
+   switch (table->Format) {
+      case GL_INTENSITY:
+         /* replace RGBA with I */
+         if (table->Type == GL_FLOAT) {
+            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+            const GLfloat *lut = (const GLfloat *) table->Table;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+               GLchan c;
+               CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
+               rgba[i][RCOMP] = rgba[i][GCOMP] =
+                  rgba[i][BCOMP] = rgba[i][ACOMP] = c;
+            }
+         }
+         else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            if (table->Size == 256) {
+               /* common case */
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  const GLchan c = lut[rgba[i][RCOMP]];
+                  rgba[i][RCOMP] = rgba[i][GCOMP] =
+                     rgba[i][BCOMP] = rgba[i][ACOMP] = c;
+               }
+            }
+            else
+#endif
+            {
+               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+                  rgba[i][RCOMP] = rgba[i][GCOMP] =
+                     rgba[i][BCOMP] = rgba[i][ACOMP] = lut[j];
+               }
+            }
+         }
+         break;
+      case GL_LUMINANCE:
+         /* replace RGB with L */
+         if (table->Type == GL_FLOAT) {
+            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+            const GLfloat *lut = (const GLfloat *) table->Table;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+               GLchan c;
+               CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
+               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
+            }
+         }
+         else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            if (table->Size == 256) {
+               /* common case */
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  const GLchan c = lut[rgba[i][RCOMP]];
+                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
+               }
+            }
+            else
+#endif
+            {
+               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = lut[j];
+               }
+            }
+         }
+         break;
+      case GL_ALPHA:
+         /* replace A with A */
+         if (table->Type == GL_FLOAT) {
+            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+            const GLfloat *lut = (const GLfloat *) table->Table;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
+               GLchan c;
+               CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
+               rgba[i][ACOMP] = c;
+            }
+         }
+         else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            if (table->Size == 256) {
+               /* common case */
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
+               }
+            }
+            else
+#endif
+            {
+               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
+                  rgba[i][ACOMP] = lut[j];
+               }
+            }
+         }
+         break;
+      case GL_LUMINANCE_ALPHA:
+         /* replace RGBA with LLLA */
+         if (table->Type == GL_FLOAT) {
+            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+            const GLfloat *lut = (const GLfloat *) table->Table;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+               GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
+               GLchan luminance, alpha;
+               CLAMPED_FLOAT_TO_CHAN(luminance, lut[jL * 2 + 0]);
+               CLAMPED_FLOAT_TO_CHAN(alpha, lut[jA * 2 + 1]);
+               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
+               rgba[i][ACOMP] = alpha;;
+            }
+         }
+         else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            if (table->Size == 256) {
+               /* common case */
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLchan l = lut[rgba[i][RCOMP] * 2 + 0];
+                  GLchan a = lut[rgba[i][ACOMP] * 2 + 1];;
+                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = l;
+                  rgba[i][ACOMP] = a;
+               }
+            }
+            else
+#endif
+            {
+               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+                  GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
+                  GLchan luminance = lut[jL * 2 + 0];
+                  GLchan alpha     = lut[jA * 2 + 1];
+                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
+                  rgba[i][ACOMP] = alpha;
+               }
+            }
+         }
+         break;
+      case GL_RGB:
+         /* replace RGB with RGB */
+         if (table->Type == GL_FLOAT) {
+            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+            const GLfloat *lut = (const GLfloat *) table->Table;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+               GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
+               GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 3 + 0]);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 3 + 1]);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 3 + 2]);
+            }
+         }
+         else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            if (table->Size == 256) {
+               /* common case */
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
+                  rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
+                  rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
+               }
+            }
+            else
+#endif
+            {
+               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+                  GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
+                  GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
+                  rgba[i][RCOMP] = lut[jR * 3 + 0];
+                  rgba[i][GCOMP] = lut[jG * 3 + 1];
+                  rgba[i][BCOMP] = lut[jB * 3 + 2];
+               }
+            }
+         }
+         break;
+      case GL_RGBA:
+         /* replace RGBA with RGBA */
+         if (table->Type == GL_FLOAT) {
+            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+            const GLfloat *lut = (const GLfloat *) table->Table;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+               GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
+               GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
+               GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
+               CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
+            }
+         }
+         else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            if (table->Size == 256) {
+               /* common case */
+               const GLchan *lut = (const GLchan *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
+                  rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
+                  rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
+                  rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
+               }
+            }
+            else
+#endif
+            {
+               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
+               const GLfloat *lut = (const GLfloat *) table->Table;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
+                  GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
+                  GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
+                  GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
+                  CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
+                  CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
+                  CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
+                  CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
+               }
             }
          }
          break;
       default:
-         _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba");
+         _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
          return;
    }
 }
diff --git a/src/mesa/main/pixel.h b/src/mesa/main/pixel.h
index a3efcf5666..32696c8b66 100644
--- a/src/mesa/main/pixel.h
+++ b/src/mesa/main/pixel.h
@@ -5,9 +5,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  5.1
+ * Version:  6.1
  *
- * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -94,8 +94,12 @@ _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4]);
 
 
 extern void
-_mesa_lookup_rgba(const struct gl_color_table *table,
-                  GLuint n, GLfloat rgba[][4]);
+_mesa_lookup_rgba_float(const struct gl_color_table *table,
+                        GLuint n, GLfloat rgba[][4]);
+
+extern void
+_mesa_lookup_rgba_chan(const struct gl_color_table *table,
+                       GLuint n, GLchan rgba[][4]);
 
 
 extern void
diff --git a/src/mesa/swrast/s_copypix.c b/src/mesa/swrast/s_copypix.c
index 0692adfbff..51c2f9a6e0 100644
--- a/src/mesa/swrast/s_copypix.c
+++ b/src/mesa/swrast/s_copypix.c
@@ -184,7 +184,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
       }
       /* GL_COLOR_TABLE lookup */
       if (transferOps & IMAGE_COLOR_TABLE_BIT) {
-         _mesa_lookup_rgba(&ctx->ColorTable, width, rgba);
+         _mesa_lookup_rgba_float(&ctx->ColorTable, width, rgba);
       }
    }
 
@@ -204,7 +204,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
 
       /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
       if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
-         _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgba);
+         _mesa_lookup_rgba_float(&ctx->PostConvolutionColorTable, width, rgba);
       }
       /* color matrix */
       if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
@@ -212,7 +212,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
       }
       /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
       if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
-         _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgba);
+         _mesa_lookup_rgba_float(&ctx->PostColorMatrixColorTable, width, rgba);
       }
       /* update histogram count */
       if (transferOps & IMAGE_HISTOGRAM_BIT) {
@@ -412,7 +412,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
          }
          /* GL_COLOR_TABLE lookup */
          if (transferOps & IMAGE_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->ColorTable, width, rgbaFloat);
+            _mesa_lookup_rgba_float(&ctx->ColorTable, width, rgbaFloat);
          }
          /* convolution */
          if (transferOps & IMAGE_CONVOLUTION_BIT) {
@@ -433,7 +433,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
          }
          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
          if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgbaFloat);
+            _mesa_lookup_rgba_float(&ctx->PostConvolutionColorTable, width, rgbaFloat);
          }
          /* color matrix */
          if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
@@ -441,7 +441,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
          }
          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
          if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
-            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgbaFloat);
+            _mesa_lookup_rgba_float(&ctx->PostColorMatrixColorTable, width, rgbaFloat);
          }
          /* update histogram count */
          if (transferOps & IMAGE_HISTOGRAM_BIT) {
diff --git a/src/mesa/swrast/s_texture.c b/src/mesa/swrast/s_texture.c
index 5dff9874d5..22d193381b 100644
--- a/src/mesa/swrast/s_texture.c
+++ b/src/mesa/swrast/s_texture.c
@@ -28,6 +28,7 @@
 #include "colormac.h"
 #include "macros.h"
 #include "imports.h"
+#include "pixel.h"
 #include "texformat.h"
 #include "teximage.h"
 
@@ -344,277 +345,6 @@ repeat_remainder(GLint a, GLint b)
 #define K1BIT  32
 
 
-/*
- * Do the lookup for GL_SGI_texture_color_table.
- * XXX merge with _mesa_lookup_rgba in pixel.c
- */
-void
-_swrast_texture_table_lookup(const struct gl_color_table *table,
-                             GLuint n, GLchan rgba[][4])
-{
-   if (!table->Table || table->Size == 0)
-      return;
-
-   switch (table->Format) {
-      case GL_INTENSITY:
-         /* replace RGBA with I */
-         if (table->Type == GL_FLOAT) {
-            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-            const GLfloat *lut = (const GLfloat *) table->Table;
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-               GLchan c;
-               CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
-               rgba[i][RCOMP] = rgba[i][GCOMP] =
-                  rgba[i][BCOMP] = rgba[i][ACOMP] = c;
-            }
-         }
-         else {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            if (table->Size == 256) {
-               /* common case */
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  const GLchan c = lut[rgba[i][RCOMP]];
-                  rgba[i][RCOMP] = rgba[i][GCOMP] =
-                     rgba[i][BCOMP] = rgba[i][ACOMP] = c;
-               }
-            }
-            else
-#endif
-            {
-               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-                  rgba[i][RCOMP] = rgba[i][GCOMP] =
-                     rgba[i][BCOMP] = rgba[i][ACOMP] = lut[j];
-               }
-            }
-         }
-         break;
-      case GL_LUMINANCE:
-         /* replace RGB with L */
-         if (table->Type == GL_FLOAT) {
-            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-            const GLfloat *lut = (const GLfloat *) table->Table;
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-               GLchan c;
-               CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
-               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
-            }
-         }
-         else {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            if (table->Size == 256) {
-               /* common case */
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  const GLchan c = lut[rgba[i][RCOMP]];
-                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
-               }
-            }
-            else
-#endif
-            {
-               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = lut[j];
-               }
-            }
-         }
-         break;
-      case GL_ALPHA:
-         /* replace A with A */
-         if (table->Type == GL_FLOAT) {
-            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-            const GLfloat *lut = (const GLfloat *) table->Table;
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
-               GLchan c;
-               CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
-               rgba[i][ACOMP] = c;
-            }
-         }
-         else {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            if (table->Size == 256) {
-               /* common case */
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
-               }
-            }
-            else
-#endif
-            {
-               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
-                  rgba[i][ACOMP] = lut[j];
-               }
-            }
-         }
-         break;
-      case GL_LUMINANCE_ALPHA:
-         /* replace RGBA with LLLA */
-         if (table->Type == GL_FLOAT) {
-            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-            const GLfloat *lut = (const GLfloat *) table->Table;
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-               GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
-               GLchan luminance, alpha;
-               CLAMPED_FLOAT_TO_CHAN(luminance, lut[jL * 2 + 0]);
-               CLAMPED_FLOAT_TO_CHAN(alpha, lut[jA * 2 + 1]);
-               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
-               rgba[i][ACOMP] = alpha;;
-            }
-         }
-         else {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            if (table->Size == 256) {
-               /* common case */
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLchan l = lut[rgba[i][RCOMP] * 2 + 0];
-                  GLchan a = lut[rgba[i][ACOMP] * 2 + 1];;
-                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = l;
-                  rgba[i][ACOMP] = a;
-               }
-            }
-            else
-#endif
-            {
-               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-                  GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
-                  GLchan luminance = lut[jL * 2 + 0];
-                  GLchan alpha     = lut[jA * 2 + 1];
-                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
-                  rgba[i][ACOMP] = alpha;
-               }
-            }
-         }
-         break;
-      case GL_RGB:
-         /* replace RGB with RGB */
-         if (table->Type == GL_FLOAT) {
-            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-            const GLfloat *lut = (const GLfloat *) table->Table;
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-               GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
-               GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 3 + 0]);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 3 + 1]);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 3 + 2]);
-            }
-         }
-         else {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            if (table->Size == 256) {
-               /* common case */
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
-                  rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
-                  rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
-               }
-            }
-            else
-#endif
-            {
-               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-                  GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
-                  GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
-                  rgba[i][RCOMP] = lut[jR * 3 + 0];
-                  rgba[i][GCOMP] = lut[jG * 3 + 1];
-                  rgba[i][BCOMP] = lut[jB * 3 + 2];
-               }
-            }
-         }
-         break;
-      case GL_RGBA:
-         /* replace RGBA with RGBA */
-         if (table->Type == GL_FLOAT) {
-            const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-            const GLfloat *lut = (const GLfloat *) table->Table;
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-               GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
-               GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
-               GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
-               CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
-            }
-         }
-         else {
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-            if (table->Size == 256) {
-               /* common case */
-               const GLchan *lut = (const GLchan *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
-                  rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
-                  rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
-                  rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
-               }
-            }
-            else
-#endif
-            {
-               const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
-               const GLfloat *lut = (const GLfloat *) table->Table;
-               GLuint i;
-               for (i = 0; i < n; i++) {
-                  GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
-                  GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
-                  GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
-                  GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
-                  CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
-                  CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
-                  CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
-                  CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
-               }
-            }
-         }
-         break;
-      default:
-         _mesa_problem(NULL, "Bad format in _swrast_texture_table_lookup");
-         return;
-   }
-}
-
-
 
 /*
  * Get texture palette entry.
@@ -4208,7 +3938,7 @@ _swrast_texture_span( GLcontext *ctx, struct sw_span *span )
 
          /* GL_SGI_texture_color_table */
          if (texUnit->ColorTableEnabled) {
-            _swrast_texture_table_lookup(&texUnit->ColorTable, span->end, texels);
+            _mesa_lookup_rgba_chan(&texUnit->ColorTable, span->end, texels);
          }
       }
    }
diff --git a/src/mesa/swrast/s_texture.h b/src/mesa/swrast/s_texture.h
index b0c16083da..698f363a1c 100644
--- a/src/mesa/swrast/s_texture.h
+++ b/src/mesa/swrast/s_texture.h
@@ -1,9 +1,8 @@
-
 /*
  * Mesa 3-D graphics library
- * Version:  5.1
+ * Version:  6.1
  *
- * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -32,10 +31,6 @@
 #include "swrast.h"
 
 
-extern void
-_swrast_texture_table_lookup( const struct gl_color_table *table,
-                              GLuint n, GLchan rgba[][4] );
-
 extern texture_sample_func
 _swrast_choose_texture_sample_func( GLcontext *ctx,
 				    const struct gl_texture_object *tObj );