more changes for runtime renderbuffer depths

5 files changed, 706 insertions, 747 deletions

diff --git a/src/mesa/swrast/s_blend.c b/src/mesa/swrast/s_blend.c
index 4e6c3d909f..a8d45bbf5f 100644
--- a/src/mesa/swrast/s_blend.c
+++ b/src/mesa/swrast/s_blend.c
@@ -22,16 +22,19 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-/*
- * Regarding GL_NV_blend_square:
+
+/**
+ * \file swrast/s_blend.c
+ * \brief software blending.
+ * \author Brian Paul
  *
- * Portions of this software may use or implement intellectual
- * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
- * any and all warranties with respect to such intellectual property,
- * including any use thereof or modifications thereto.
+ * Only a few blend modes have been optimized (min, max, transparency, add)
+ * more optimized cases can easily be added if needed.
+ * Celestia uses glBlendFunc(GL_SRC_ALPHA, GL_ONE), for example.
  */
 
 
+
 #include "glheader.h"
 #include "context.h"
 #include "colormac.h"
@@ -52,33 +55,51 @@
 
 
 /**
- * Special case for glBlendFunc(GL_ZERO, GL_ONE)
+ * Integer divide by 255
+ * Declare "int divtemp" before using.
+ * This satisfies Glean and should be reasonably fast.
+ * Contributed by Nathan Hand.
+ */
+#define DIV255(X)  (divtemp = (X), ((divtemp << 8) + divtemp + 256) >> 16)
+
+
+
+/**
+ * Special case for glBlendFunc(GL_ZERO, GL_ONE).
+ * No-op means the framebuffer values remain unchanged.
+ * Any chanType ok.
  */
 static void _BLENDAPI
-blend_noop_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                 GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType)
+blend_noop(GLcontext *ctx, GLuint n, const GLubyte mask[],
+           GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
-   GLuint i;
+   GLint bytes;
+
    ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendSrcRGB == GL_ZERO);
    ASSERT(ctx->Color.BlendDstRGB == GL_ONE);
    (void) ctx;
 
-   for (i = 0; i < n; i++) {
-      if (mask[i]) {
-         COPY_CHAN4( rgba[i], dest[i] );
-      }
-   }
+   /* just memcpy */
+   if (chanType == GL_UNSIGNED_BYTE)
+      bytes = 4 * n * sizeof(GLubyte);
+   else if (chanType == GL_UNSIGNED_SHORT)
+      bytes = 4 * n * sizeof(GLushort);
+   else
+      bytes = 4 * n * sizeof(GLfloat);
+
+   _mesa_memcpy(src, dst, bytes);
 }
 
 
 /**
  * Special case for glBlendFunc(GL_ONE, GL_ZERO)
+ * Any chanType ok.
  */
 static void _BLENDAPI
 blend_replace(GLcontext *ctx, GLuint n, const GLubyte mask[],
-              GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType)
+              GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
    ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
@@ -87,95 +108,129 @@ blend_replace(GLcontext *ctx, GLuint n, const GLubyte mask[],
    (void) ctx;
    (void) n;
    (void) mask;
-   (void) rgba;
-   (void) dest;
+   (void) src;
+   (void) dst;
 }
 
 
 /**
- * Common transparency blending mode.
+ * Common transparency blending mode:
+ * glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA).
  */
 static void _BLENDAPI
 blend_transparency_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                         GLchan rgba[][4], CONST GLchan dest[][4],
-                         GLenum chanType)
+                         GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
+   GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
+   const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
    GLuint i;
+
    ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);
    ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);
    ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);
    ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);
+   ASSERT(chanType == GL_UNSIGNED_BYTE);
+
    (void) ctx;
 
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         const GLchan t = rgba[i][ACOMP];  /* t in [0, CHAN_MAX] */
+         const GLint t = rgba[i][ACOMP];  /* t is in [0, 255] */
          if (t == 0) {
             /* 0% alpha */
-            rgba[i][RCOMP] = dest[i][RCOMP];
-            rgba[i][GCOMP] = dest[i][GCOMP];
-            rgba[i][BCOMP] = dest[i][BCOMP];
-            rgba[i][ACOMP] = dest[i][ACOMP];
-         }
-         else if (t == CHAN_MAX) {
-            /* 100% alpha, no-op */
+            COPY_4UBV(rgba[i], dest[i]);
          }
-         else {
-#if 0
-            /* This is pretty close, but Glean complains */
-            const GLint s = CHAN_MAX - t;
-            const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s + 1) >> 8;
-            const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s + 1) >> 8;
-            const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s + 1) >> 8;
-            const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s + 1) >> 8;
-#elif 0
-            /* This is slower but satisfies Glean */
-            const GLint s = CHAN_MAX - t;
-            const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) / 255;
-            const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) / 255;
-            const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) / 255;
-            const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) / 255;
-#else
-#if CHAN_BITS == 8
-            /* This satisfies Glean and should be reasonably fast */
-            /* Contributed by Nathan Hand */
-#if 0
-#define DIV255(X)  (((X) << 8) + (X) + 256) >> 16
-#else
-	    GLint temp;
-#define DIV255(X)  (temp = (X), ((temp << 8) + temp + 256) >> 16)
-#endif
+         else if (t != 255) {
+	    GLint divtemp;
             const GLint r = DIV255((rgba[i][RCOMP] - dest[i][RCOMP]) * t) + dest[i][RCOMP];
             const GLint g = DIV255((rgba[i][GCOMP] - dest[i][GCOMP]) * t) + dest[i][GCOMP];
             const GLint b = DIV255((rgba[i][BCOMP] - dest[i][BCOMP]) * t) + dest[i][BCOMP];
             const GLint a = DIV255((rgba[i][ACOMP] - dest[i][ACOMP]) * t) + dest[i][ACOMP]; 
+            ASSERT(r <= 255);
+            ASSERT(g <= 255);
+            ASSERT(b <= 255);
+            ASSERT(a <= 255);
+            rgba[i][RCOMP] = (GLubyte) r;
+            rgba[i][GCOMP] = (GLubyte) g;
+            rgba[i][BCOMP] = (GLubyte) b;
+            rgba[i][ACOMP] = (GLubyte) a;
+         }
+      }
+   }
+}
 
-#undef DIV255
-#elif CHAN_BITS == 16
-            const GLfloat tt = (GLfloat) t / CHAN_MAXF;
-            const GLint r = (GLint) ((rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]);
-            const GLint g = (GLint) ((rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]);
-            const GLint b = (GLint) ((rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]);
-            const GLint a = (GLint) ((rgba[i][ACOMP] - dest[i][ACOMP]) * tt + dest[i][ACOMP]);
-#else /* CHAN_BITS == 32 */
-            const GLfloat tt = (GLfloat) t / CHAN_MAXF;
-            const GLfloat r = (rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP];
-            const GLfloat g = (rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP];
-            const GLfloat b = (rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP];
-            const GLfloat a = CLAMP( rgba[i][ACOMP], 0.0F, CHAN_MAXF ) * t +
-                              CLAMP( dest[i][ACOMP], 0.0F, CHAN_MAXF ) * (1.0F - t);
-#endif
-#endif
-            ASSERT(r <= CHAN_MAX);
-            ASSERT(g <= CHAN_MAX);
-            ASSERT(b <= CHAN_MAX);
-            ASSERT(a <= CHAN_MAX);
-            rgba[i][RCOMP] = (GLchan) r;
-            rgba[i][GCOMP] = (GLchan) g;
-            rgba[i][BCOMP] = (GLchan) b;
-            rgba[i][ACOMP] = (GLchan) a;
+
+static void _BLENDAPI
+blend_transparency_ushort(GLcontext *ctx, GLuint n, const GLubyte mask[],
+                          GLvoid *src, const GLvoid *dst, GLenum chanType)
+{
+   GLushort (*rgba)[4] = (GLushort (*)[4]) src;
+   const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
+   GLuint i;
+
+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
+   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);
+   ASSERT(chanType == GL_UNSIGNED_SHORT);
+
+   (void) ctx;
+
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         const GLint t = rgba[i][ACOMP];
+         if (t == 0) {
+            /* 0% alpha */
+            COPY_4V(rgba[i], dest[i]);
+         }
+         else if (t != 65535) {
+            const GLfloat tt = (GLfloat) t / 65535.0F;
+            GLushort r = (GLushort) ((rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]);
+            GLushort g = (GLushort) ((rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]);
+            GLushort b = (GLushort) ((rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]);
+            GLushort a = (GLushort) ((rgba[i][ACOMP] - dest[i][ACOMP]) * tt + dest[i][ACOMP]);
+            ASSIGN_4V(rgba[i], r, g, b, a);
+         }
+      }
+   }
+}
+
+
+static void _BLENDAPI
+blend_transparency_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
+                         GLvoid *src, const GLvoid *dst, GLenum chanType)
+{
+   GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
+   const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
+   GLuint i;
+
+   ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
+   ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
+   ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA);
+   ASSERT(chanType == GL_FLOAT);
+
+   (void) ctx;
+
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         const GLfloat t = rgba[i][ACOMP];  /* t in [0, 1] */
+         if (t == 0.0F) {
+            /* 0% alpha */
+            COPY_4V(rgba[i], dest[i]);
+         }
+         else if (t != 1.0F) {
+            GLfloat r = (rgba[i][RCOMP] - dest[i][RCOMP]) * t + dest[i][RCOMP];
+            GLfloat g = (rgba[i][GCOMP] - dest[i][GCOMP]) * t + dest[i][GCOMP];
+            GLfloat b = (rgba[i][BCOMP] - dest[i][BCOMP]) * t + dest[i][BCOMP];
+            GLfloat a = (rgba[i][ACOMP] - dest[i][ACOMP]) * t + dest[i][ACOMP];
+            ASSIGN_4V(rgba[i], r, g, b, a);
          }
       }
    }
@@ -184,38 +239,65 @@ blend_transparency_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
 
 
 /**
- * Add src and dest.
+ * Add src and dest: glBlendFunc(GL_ONE, GL_ONE).
+ * Any chanType ok.
  */
 static void _BLENDAPI
-blend_add_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType)
+blend_add(GLcontext *ctx, GLuint n, const GLubyte mask[],
+          GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
    GLuint i;
+
    ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD);
    ASSERT(ctx->Color.BlendSrcRGB == GL_ONE);
    ASSERT(ctx->Color.BlendDstRGB == GL_ONE);
    (void) ctx;
 
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-#if CHAN_TYPE == GL_FLOAT
-         /* don't RGB clamp to max */
-         GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, CHAN_MAXF) + dest[i][ACOMP];
-         rgba[i][RCOMP] += dest[i][RCOMP];
-         rgba[i][GCOMP] += dest[i][GCOMP];
-         rgba[i][BCOMP] += dest[i][BCOMP];
-         rgba[i][ACOMP] = (GLchan) MIN2( a, CHAN_MAXF );
-#else
-         GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
-         GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
-         GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
-         GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
-         rgba[i][RCOMP] = (GLchan) MIN2( r, CHAN_MAX );
-         rgba[i][GCOMP] = (GLchan) MIN2( g, CHAN_MAX );
-         rgba[i][BCOMP] = (GLchan) MIN2( b, CHAN_MAX );
-         rgba[i][ACOMP] = (GLchan) MIN2( a, CHAN_MAX );
-#endif
+   if (chanType == GL_UNSIGNED_BYTE) {
+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
+            GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
+            GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
+            GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
+            rgba[i][RCOMP] = (GLubyte) MIN2( r, 255 );
+            rgba[i][GCOMP] = (GLubyte) MIN2( g, 255 );
+            rgba[i][BCOMP] = (GLubyte) MIN2( b, 255 );
+            rgba[i][ACOMP] = (GLubyte) MIN2( a, 255 );
+         }
+      }
+   }
+   else if (chanType == GL_UNSIGNED_SHORT) {
+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
+            GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
+            GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
+            GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
+            rgba[i][RCOMP] = (GLshort) MIN2( r, 255 );
+            rgba[i][GCOMP] = (GLshort) MIN2( g, 255 );
+            rgba[i][BCOMP] = (GLshort) MIN2( b, 255 );
+            rgba[i][ACOMP] = (GLshort) MIN2( a, 255 );
+         }
+      }
+   }
+   else {
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
+      ASSERT(chanType == GL_FLOAT);
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            /* don't RGB clamp to max */
+            rgba[i][RCOMP] += dest[i][RCOMP];
+            rgba[i][GCOMP] += dest[i][GCOMP];
+            rgba[i][BCOMP] += dest[i][BCOMP];
+            rgba[i][ACOMP] += dest[i][ACOMP];
+         }
       }
    }
 }
@@ -223,57 +305,106 @@ blend_add_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
 
 
 /**
- * Blend min function  (for GL_EXT_blend_minmax)
+ * Blend min function.
+ * Any chanType ok.
  */
 static void _BLENDAPI
-blend_min_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType)
+blend_min(GLcontext *ctx, GLuint n, const GLubyte mask[],
+          GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
    GLuint i;
    ASSERT(ctx->Color.BlendEquationRGB == GL_MIN);
    ASSERT(ctx->Color.BlendEquationA == GL_MIN);
    (void) ctx;
 
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         rgba[i][RCOMP] = (GLchan) MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
-         rgba[i][GCOMP] = (GLchan) MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
-         rgba[i][BCOMP] = (GLchan) MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
-#if CHAN_TYPE == GL_FLOAT
-         rgba[i][ACOMP] = (GLchan) MIN2(CLAMP(rgba[i][ACOMP], 0.0F, CHAN_MAXF),
-                                        dest[i][ACOMP]);
-#else
-         rgba[i][ACOMP] = (GLchan) MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
-#endif
+   if (chanType == GL_UNSIGNED_BYTE) {
+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
+            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
+            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
+            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
+         }
+      }
+   }
+   else if (chanType == GL_UNSIGNED_SHORT) {
+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
+            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
+            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
+            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
+         }
+      }
+   }
+   else {
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
+      ASSERT(chanType == GL_FLOAT);
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
+            rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
+            rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
+            rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
+         }
       }
    }
 }
 
 
-
 /**
- * Blend max function  (for GL_EXT_blend_minmax)
+ * Blend max function.
+ * Any chanType ok.
  */
 static void _BLENDAPI
-blend_max_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType)
+blend_max(GLcontext *ctx, GLuint n, const GLubyte mask[],
+          GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
    GLuint i;
    ASSERT(ctx->Color.BlendEquationRGB == GL_MAX);
    ASSERT(ctx->Color.BlendEquationA == GL_MAX);
    (void) ctx;
 
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         rgba[i][RCOMP] = (GLchan) MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
-         rgba[i][GCOMP] = (GLchan) MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
-         rgba[i][BCOMP] = (GLchan) MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
-#if CHAN_TYPE == GL_FLOAT
-         rgba[i][ACOMP] = (GLchan) MAX2(CLAMP(rgba[i][ACOMP], 0.0F, CHAN_MAXF),
-                                        dest[i][ACOMP]);
-#else
-         rgba[i][ACOMP] = (GLchan) MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
-#endif
+   if (chanType == GL_UNSIGNED_BYTE) {
+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
+            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
+            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
+            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
+         }
+      }
+   }
+   else if (chanType == GL_UNSIGNED_SHORT) {
+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
+            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
+            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
+            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
+         }
+      }
+   }
+   else {
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
+      ASSERT(chanType == GL_FLOAT);
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
+            rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
+            rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
+            rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
+         }
       }
    }
 }
@@ -282,59 +413,68 @@ blend_max_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
 
 /**
  * Modulate:  result = src * dest
+ * Any chanType ok.
  */
 static void _BLENDAPI
-blend_modulate_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                     GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType)
+blend_modulate(GLcontext *ctx, GLuint n, const GLubyte mask[],
+               GLvoid *src, const GLvoid *dst, GLenum chanType)
 {
    GLuint i;
    (void) ctx;
 
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-#if CHAN_TYPE == GL_FLOAT
-         rgba[i][RCOMP] = rgba[i][RCOMP] * dest[i][RCOMP];
-         rgba[i][GCOMP] = rgba[i][GCOMP] * dest[i][GCOMP];
-         rgba[i][BCOMP] = rgba[i][BCOMP] * dest[i][BCOMP];
-         rgba[i][ACOMP] = rgba[i][ACOMP] * dest[i][ACOMP];
-#elif CHAN_TYPE == GL_UNSIGNED_SHORT
-         GLint r = (rgba[i][RCOMP] * dest[i][RCOMP] + 65535) >> 16;
-         GLint g = (rgba[i][GCOMP] * dest[i][GCOMP] + 65535) >> 16;
-         GLint b = (rgba[i][BCOMP] * dest[i][BCOMP] + 65535) >> 16;
-         GLint a = (rgba[i][ACOMP] * dest[i][ACOMP] + 65535) >> 16;
-         rgba[i][RCOMP] = (GLchan) r;
-         rgba[i][GCOMP] = (GLchan) g;
-         rgba[i][BCOMP] = (GLchan) b;
-         rgba[i][ACOMP] = (GLchan) a;
-#else
-         GLint r = (rgba[i][RCOMP] * dest[i][RCOMP] + 255) >> 8;
-         GLint g = (rgba[i][GCOMP] * dest[i][GCOMP] + 255) >> 8;
-         GLint b = (rgba[i][BCOMP] * dest[i][BCOMP] + 255) >> 8;
-         GLint a = (rgba[i][ACOMP] * dest[i][ACOMP] + 255) >> 8;
-         rgba[i][RCOMP] = (GLchan) r;
-         rgba[i][GCOMP] = (GLchan) g;
-         rgba[i][BCOMP] = (GLchan) b;
-         rgba[i][ACOMP] = (GLchan) a;
-#endif
+   if (chanType == GL_UNSIGNED_BYTE) {
+      GLubyte (*rgba)[4] = (GLubyte (*)[4]) src;
+      const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+	    GLint divtemp;
+            rgba[i][RCOMP] = DIV255(rgba[i][RCOMP] * dest[i][RCOMP]);
+            rgba[i][GCOMP] = DIV255(rgba[i][GCOMP] * dest[i][GCOMP]);
+            rgba[i][BCOMP] = DIV255(rgba[i][BCOMP] * dest[i][BCOMP]);
+            rgba[i][ACOMP] = DIV255(rgba[i][ACOMP] * dest[i][ACOMP]);
+         }
+      }
+   }
+   else if (chanType == GL_UNSIGNED_SHORT) {
+      GLushort (*rgba)[4] = (GLushort (*)[4]) src;
+      const GLushort (*dest)[4] = (const GLushort (*)[4]) dst;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = (rgba[i][RCOMP] * dest[i][RCOMP] + 65535) >> 16;
+            rgba[i][GCOMP] = (rgba[i][GCOMP] * dest[i][GCOMP] + 65535) >> 16;
+            rgba[i][BCOMP] = (rgba[i][BCOMP] * dest[i][BCOMP] + 65535) >> 16;
+            rgba[i][ACOMP] = (rgba[i][ACOMP] * dest[i][ACOMP] + 65535) >> 16;
+         }
+      }
+   }
+   else {
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
+      const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
+      ASSERT(chanType == GL_FLOAT);
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            rgba[i][RCOMP] = rgba[i][RCOMP] * dest[i][RCOMP];
+            rgba[i][GCOMP] = rgba[i][GCOMP] * dest[i][GCOMP];
+            rgba[i][BCOMP] = rgba[i][BCOMP] * dest[i][BCOMP];
+            rgba[i][ACOMP] = rgba[i][ACOMP] * dest[i][ACOMP];
+         }
       }
    }
 }
 
 
-#if 0
 /**
  * Do any blending operation, using floating point.
  * \param n  number of pixels
  * \param mask  fragment writemask array
- * \param src  array of incoming (and modified) pixels
- * \param dst  array of pixels from the dest color buffer
+ * \param rgba  array of incoming (and modified) pixels
+ * \param dest  array of pixels from the dest color buffer
  */
 static void
 blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                    GLvoid *src, const GLvoid *dst, GLenum chanType)
+                    GLfloat rgba[][4], GLfloat dest[][4],
+                    GLenum chanType)
 {
-   GLfloat (*rgba)[4] = (GLfloat (*)[4]) src;
-   const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst;
    GLuint i;
 
    for (i = 0; i < n; i++) {
@@ -413,12 +553,12 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
             case GL_ONE_MINUS_CONSTANT_ALPHA:
                sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];
                break;
-            case GL_SRC_COLOR: /* GL_NV_blend_square */
+            case GL_SRC_COLOR:
                sR = Rs;
                sG = Gs;
                sB = Bs;
                break;
-            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
+            case GL_ONE_MINUS_SRC_COLOR:
                sR = 1.0F - Rs;
                sG = 1.0F - Gs;
                sB = 1.0F - Bs;
@@ -470,10 +610,10 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
             case GL_ONE_MINUS_CONSTANT_ALPHA:
                sA = 1.0F - ctx->Color.BlendColor[3];
                break;
-            case GL_SRC_COLOR: /* GL_NV_blend_square */
+            case GL_SRC_COLOR:
                sA = As;
                break;
-            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
+            case GL_ONE_MINUS_SRC_COLOR:
                sA = 1.0F - As;
                break;
             default:
@@ -529,12 +669,12 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
             case GL_ONE_MINUS_CONSTANT_ALPHA:
                dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];
                break;
-            case GL_DST_COLOR: /* GL_NV_blend_square */
+            case GL_DST_COLOR:
                dR = Rd;
                dG = Gd;
                dB = Bd;
                break;
-            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
+            case GL_ONE_MINUS_DST_COLOR:
                dR = 1.0F - Rd;
                dG = 1.0F - Gd;
                dB = 1.0F - Bd;
@@ -584,10 +724,10 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
             case GL_ONE_MINUS_CONSTANT_ALPHA:
                dA = 1.0F - ctx->Color.BlendColor[3];
                break;
-            case GL_DST_COLOR: /* GL_NV_blend_square */
+            case GL_DST_COLOR:
                dA = Ad;
                break;
-            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
+            case GL_ONE_MINUS_DST_COLOR:
                dA = 1.0F - Ad;
                break;
             default:
@@ -663,20 +803,21 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[],
          rgba[i][RCOMP] = MAX2( r, 0.0F );
          rgba[i][GCOMP] = MAX2( g, 0.0F );
          rgba[i][BCOMP] = MAX2( b, 0.0F );
-         rgba[i][ACOMP] = CLAMP( a, 0.0F, CHAN_MAXF );
+         rgba[i][ACOMP] = CLAMP( a, 0.0F, 1.0F );
 #else
          ASSIGN_4V(rgba[i], r, g, b, a);
 #endif
       }
    }
 }
-#endif
 
 
-#if 0 /* not ready yet */
+/**
+ * Do any blending operation, any chanType.
+ */
 static void
-blend_general2(GLcontext *ctx, GLuint n, const GLubyte mask[],
-               void *src, const void *dst, GLenum chanType)
+blend_general(GLcontext *ctx, GLuint n, const GLubyte mask[],
+              void *src, const void *dst, GLenum chanType)
 {
    GLfloat rgbaF[MAX_WIDTH][4], destF[MAX_WIDTH][4];
 
@@ -739,460 +880,18 @@ blend_general2(GLcontext *ctx, GLuint n, const GLubyte mask[],
       }
    }
    else {
-      blend_general_float(ctx, n, mask, (GLfloat (*)[4]) rgbaF,
-                          (const GLfloat (*)[4]) destF, chanType);
+      blend_general_float(ctx, n, mask, rgbaF, destF, chanType);
    }
 }
-#endif
-
-
-static void _BLENDAPI
-blend_general(GLcontext *ctx, GLuint n, const GLubyte mask[],
-              GLchan rgba[][4], CONST GLchan dest[][4],
-              GLenum chanType)
-{
-   const GLfloat rscale = 1.0F / CHAN_MAXF;
-   const GLfloat gscale = 1.0F / CHAN_MAXF;
-   const GLfloat bscale = 1.0F / CHAN_MAXF;
-   const GLfloat ascale = 1.0F / CHAN_MAXF;
-   GLuint i;
-
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-#if CHAN_TYPE == GL_FLOAT
-         GLfloat Rs, Gs, Bs, As;  /* Source colors */
-         GLfloat Rd, Gd, Bd, Ad;  /* Dest colors */
-#else
-         GLint Rs, Gs, Bs, As;  /* Source colors */
-         GLint Rd, Gd, Bd, Ad;  /* Dest colors */
-#endif
-         GLfloat sR, sG, sB, sA;  /* Source scaling */
-         GLfloat dR, dG, dB, dA;  /* Dest scaling */
-         GLfloat r, g, b, a;      /* result color */
 
-         /* Incoming/source Color */
-         Rs = rgba[i][RCOMP];
-         Gs = rgba[i][GCOMP];
-         Bs = rgba[i][BCOMP];
-         As = rgba[i][ACOMP];
-#if CHAN_TYPE == GL_FLOAT
-         /* clamp */
-         Rs = MIN2(Rs, CHAN_MAXF);
-         Gs = MIN2(Gs, CHAN_MAXF);
-         Bs = MIN2(Bs, CHAN_MAXF);
-         As = MIN2(As, CHAN_MAXF);
-#endif
-
-         /* Frame buffer/dest color */
-         Rd = dest[i][RCOMP];
-         Gd = dest[i][GCOMP];
-         Bd = dest[i][BCOMP];
-         Ad = dest[i][ACOMP];
-#if CHAN_TYPE == GL_FLOAT
-         /* clamp */
-         Rd = MIN2(Rd, CHAN_MAXF);
-         Gd = MIN2(Gd, CHAN_MAXF);
-         Bd = MIN2(Bd, CHAN_MAXF);
-         Ad = MIN2(Ad, CHAN_MAXF);
-#endif
-
-         /* Source RGB factor */
-         switch (ctx->Color.BlendSrcRGB) {
-            case GL_ZERO:
-               sR = sG = sB = 0.0F;
-               break;
-            case GL_ONE:
-               sR = sG = sB = 1.0F;
-               break;
-            case GL_DST_COLOR:
-               sR = (GLfloat) Rd * rscale;
-               sG = (GLfloat) Gd * gscale;
-               sB = (GLfloat) Bd * bscale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               sR = 1.0F - (GLfloat) Rd * rscale;
-               sG = 1.0F - (GLfloat) Gd * gscale;
-               sB = 1.0F - (GLfloat) Bd * bscale;
-               break;
-            case GL_SRC_ALPHA:
-               sR = sG = sB = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               sR = sG = sB = 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               sR = sG = sB = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_SRC_ALPHA_SATURATE:
-               if (As < CHAN_MAX - Ad) {
-                  sR = sG = sB = (GLfloat) As * ascale;
-               }
-               else {
-                  sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
-               }
-               break;
-            case GL_CONSTANT_COLOR:
-               sR = ctx->Color.BlendColor[0];
-               sG = ctx->Color.BlendColor[1];
-               sB = ctx->Color.BlendColor[2];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               sR = 1.0F - ctx->Color.BlendColor[0];
-               sG = 1.0F - ctx->Color.BlendColor[1];
-               sB = 1.0F - ctx->Color.BlendColor[2];
-               break;
-            case GL_CONSTANT_ALPHA:
-               sR = sG = sB = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_SRC_COLOR: /* GL_NV_blend_square */
-               sR = (GLfloat) Rs * rscale;
-               sG = (GLfloat) Gs * gscale;
-               sB = (GLfloat) Bs * bscale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
-               sR = 1.0F - (GLfloat) Rs * rscale;
-               sG = 1.0F - (GLfloat) Gs * gscale;
-               sB = 1.0F - (GLfloat) Bs * bscale;
-               break;
-            default:
-               /* this should never happen */
-               _mesa_problem(ctx, "Bad blend source RGB factor in blend_general");
-               return;
-         }
-
-         /* Source Alpha factor */
-         switch (ctx->Color.BlendSrcA) {
-            case GL_ZERO:
-               sA = 0.0F;
-               break;
-            case GL_ONE:
-               sA = 1.0F;
-               break;
-            case GL_DST_COLOR:
-               sA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               sA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_SRC_ALPHA:
-               sA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               sA = 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               sA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               sA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_SRC_ALPHA_SATURATE:
-               sA = 1.0;
-               break;
-            case GL_CONSTANT_COLOR:
-               sA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               sA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_CONSTANT_ALPHA:
-               sA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               sA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_SRC_COLOR: /* GL_NV_blend_square */
-               sA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
-               sA = 1.0F - (GLfloat) As * ascale;
-               break;
-            default:
-               /* this should never happen */
-               sA = 0.0F;
-               _mesa_problem(ctx, "Bad blend source A factor in blend_general");
-               return;
-         }
-
-         /* Dest RGB factor */
-         switch (ctx->Color.BlendDstRGB) {
-            case GL_ZERO:
-               dR = dG = dB = 0.0F;
-               break;
-            case GL_ONE:
-               dR = dG = dB = 1.0F;
-               break;
-            case GL_SRC_COLOR:
-               dR = (GLfloat) Rs * rscale;
-               dG = (GLfloat) Gs * gscale;
-               dB = (GLfloat) Bs * bscale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               dR = 1.0F - (GLfloat) Rs * rscale;
-               dG = 1.0F - (GLfloat) Gs * gscale;
-               dB = 1.0F - (GLfloat) Bs * bscale;
-               break;
-            case GL_SRC_ALPHA:
-               dR = dG = dB = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               dR = dG = dB = 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               dR = dG = dB = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               dR = dG = dB = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_CONSTANT_COLOR:
-               dR = ctx->Color.BlendColor[0];
-               dG = ctx->Color.BlendColor[1];
-               dB = ctx->Color.BlendColor[2];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               dR = 1.0F - ctx->Color.BlendColor[0];
-               dG = 1.0F - ctx->Color.BlendColor[1];
-               dB = 1.0F - ctx->Color.BlendColor[2];
-               break;
-            case GL_CONSTANT_ALPHA:
-               dR = dG = dB = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_DST_COLOR: /* GL_NV_blend_square */
-               dR = (GLfloat) Rd * rscale;
-               dG = (GLfloat) Gd * gscale;
-               dB = (GLfloat) Bd * bscale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
-               dR = 1.0F - (GLfloat) Rd * rscale;
-               dG = 1.0F - (GLfloat) Gd * gscale;
-               dB = 1.0F - (GLfloat) Bd * bscale;
-               break;
-            default:
-               /* this should never happen */
-               dR = dG = dB = 0.0F;
-               _mesa_problem(ctx, "Bad blend dest RGB factor in blend_general");
-               return;
-         }
-
-         /* Dest Alpha factor */
-         switch (ctx->Color.BlendDstA) {
-            case GL_ZERO:
-               dA = 0.0F;
-               break;
-            case GL_ONE:
-               dA = 1.0F;
-               break;
-            case GL_SRC_COLOR:
-               dA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               dA = 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_SRC_ALPHA:
-               dA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               dA = 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               dA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               dA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_CONSTANT_COLOR:
-               dA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               dA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_CONSTANT_ALPHA:
-               dA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               dA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_DST_COLOR: /* GL_NV_blend_square */
-               dA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
-               dA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            default:
-               /* this should never happen */
-               dA = 0.0F;
-               _mesa_problem(ctx, "Bad blend dest A factor in blend_general");
-               return;
-         }
-
-         /* Due to round-off problems we have to clamp against zero. */
-         /* Optimization: we don't have to do this for all src & dst factors */
-         if (dA < 0.0F)  dA = 0.0F;
-         if (dR < 0.0F)  dR = 0.0F;
-         if (dG < 0.0F)  dG = 0.0F;
-         if (dB < 0.0F)  dB = 0.0F;
-         if (sA < 0.0F)  sA = 0.0F;
-         if (sR < 0.0F)  sR = 0.0F;
-         if (sG < 0.0F)  sG = 0.0F;
-         if (sB < 0.0F)  sB = 0.0F;
-
-         ASSERT( sR <= 1.0 );
-         ASSERT( sG <= 1.0 );
-         ASSERT( sB <= 1.0 );
-         ASSERT( sA <= 1.0 );
-         ASSERT( dR <= 1.0 );
-         ASSERT( dG <= 1.0 );
-         ASSERT( dB <= 1.0 );
-         ASSERT( dA <= 1.0 );
-
-         /* compute blended color */
-#if CHAN_TYPE == GL_FLOAT
-         switch (ctx->Color.BlendEquationRGB) {
-         case GL_FUNC_ADD:
-            r = Rs * sR + Rd * dR;
-            g = Gs * sG + Gd * dG;
-            b = Bs * sB + Bd * dB;
-            a = As * sA + Ad * dA;
-            break;
-         case GL_FUNC_SUBTRACT:
-            r = Rs * sR - Rd * dR;
-            g = Gs * sG - Gd * dG;
-            b = Bs * sB - Bd * dB;
-            a = As * sA - Ad * dA;
-            break;
-         case GL_FUNC_REVERSE_SUBTRACT:
-            r = Rd * dR - Rs * sR;
-            g = Gd * dG - Gs * sG;
-            b = Bd * dB - Bs * sB;
-            a = Ad * dA - As * sA;
-            break;
-         case GL_MIN:
-	    r = MIN2( Rd, Rs );
-	    g = MIN2( Gd, Gs );
-	    b = MIN2( Bd, Bs );
-            break;
-         case GL_MAX:
-	    r = MAX2( Rd, Rs );
-	    g = MAX2( Gd, Gs );
-	    b = MAX2( Bd, Bs );
-            break;
-         default:
-            /* should never get here */
-            r = g = b = 0.0F;  /* silence uninitialized var warning */
-            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
-            return;
-         }
-
-         switch (ctx->Color.BlendEquationA) {
-         case GL_FUNC_ADD:
-            a = As * sA + Ad * dA;
-            break;
-         case GL_FUNC_SUBTRACT:
-            a = As * sA - Ad * dA;
-            break;
-         case GL_FUNC_REVERSE_SUBTRACT:
-            a = Ad * dA - As * sA;
-            break;
-         case GL_MIN:
-	    a = MIN2( Ad, As );
-            break;
-         case GL_MAX:
-	    a = MAX2( Ad, As );
-            break;
-         default:
-            /* should never get here */
-            a = 0.0F;  /* silence uninitialized var warning */
-            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
-            return;
-         }
-
-         /* final clamping */
-         rgba[i][RCOMP] = MAX2( r, 0.0F );
-         rgba[i][GCOMP] = MAX2( g, 0.0F );
-         rgba[i][BCOMP] = MAX2( b, 0.0F );
-         rgba[i][ACOMP] = CLAMP( a, 0.0F, CHAN_MAXF );
-#else
-         switch (ctx->Color.BlendEquationRGB) {
-         case GL_FUNC_ADD:
-            r = Rs * sR + Rd * dR + 0.5F;
-            g = Gs * sG + Gd * dG + 0.5F;
-            b = Bs * sB + Bd * dB + 0.5F;
-            break;
-         case GL_FUNC_SUBTRACT:
-            r = Rs * sR - Rd * dR + 0.5F;
-            g = Gs * sG - Gd * dG + 0.5F;
-            b = Bs * sB - Bd * dB + 0.5F;
-            break;
-         case GL_FUNC_REVERSE_SUBTRACT:
-            r = Rd * dR - Rs * sR + 0.5F;
-            g = Gd * dG - Gs * sG + 0.5F;
-            b = Bd * dB - Bs * sB + 0.5F;
-            break;
-         case GL_MIN:
-	    r = MIN2( Rd, Rs );
-	    g = MIN2( Gd, Gs );
-	    b = MIN2( Bd, Bs );
-            break;
-         case GL_MAX:
-	    r = MAX2( Rd, Rs );
-	    g = MAX2( Gd, Gs );
-	    b = MAX2( Bd, Bs );
-            break;
-         default:
-            /* should never get here */
-            r = g = b = 0.0F;  /* silence uninitialized var warning */
-            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
-            return;
-         }
-
-         switch (ctx->Color.BlendEquationA) {
-         case GL_FUNC_ADD:
-            a = As * sA + Ad * dA + 0.5F;
-            break;
-         case GL_FUNC_SUBTRACT:
-            a = As * sA - Ad * dA + 0.5F;
-            break;
-         case GL_FUNC_REVERSE_SUBTRACT:
-            a = Ad * dA - As * sA + 0.5F;
-            break;
-         case GL_MIN:
-	    a = MIN2( Ad, As );
-            break;
-         case GL_MAX:
-	    a = MAX2( Ad, As );
-            break;
-         default:
-            /* should never get here */
-            a = 0.0F;  /* silence uninitialized var warning */
-            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
-            return;
-         }
-
-         /* final clamping */
-         rgba[i][RCOMP] = (GLchan) (GLint) CLAMP( r, 0.0F, CHAN_MAXF );
-         rgba[i][GCOMP] = (GLchan) (GLint) CLAMP( g, 0.0F, CHAN_MAXF );
-         rgba[i][BCOMP] = (GLchan) (GLint) CLAMP( b, 0.0F, CHAN_MAXF );
-         rgba[i][ACOMP] = (GLchan) (GLint) CLAMP( a, 0.0F, CHAN_MAXF );
-#endif
-      }
-   }
-}
 
 
 /**
  * Analyze current blending parameters to pick fastest blending function.
  * Result: the ctx->Color.BlendFunc pointer is updated.
  */
-void _swrast_choose_blend_func( GLcontext *ctx )
+void
+_swrast_choose_blend_func(GLcontext *ctx, GLenum chanType)
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
    const GLenum eq = ctx->Color.BlendEquationRGB;
@@ -1207,22 +906,22 @@ void _swrast_choose_blend_func( GLcontext *ctx )
    else if (eq == GL_MIN) {
       /* Note: GL_MIN ignores the blending weight factors */
 #if defined(USE_MMX_ASM)
-      if ( cpu_has_mmx ) {
+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
          swrast->BlendFunc = _mesa_mmx_blend_min;
       }
       else
 #endif
-         swrast->BlendFunc = blend_min_ubyte;
+         swrast->BlendFunc = blend_min;
    }
    else if (eq == GL_MAX) {
       /* Note: GL_MAX ignores the blending weight factors */
 #if defined(USE_MMX_ASM)
-      if ( cpu_has_mmx ) {
+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
          swrast->BlendFunc = _mesa_mmx_blend_max;
       }
       else
 #endif
-         swrast->BlendFunc = blend_max_ubyte;
+         swrast->BlendFunc = blend_max;
    }
    else if (srcRGB != srcA || dstRGB != dstA) {
       swrast->BlendFunc = blend_general;
@@ -1230,21 +929,28 @@ void _swrast_choose_blend_func( GLcontext *ctx )
    else if (eq == GL_FUNC_ADD && srcRGB == GL_SRC_ALPHA
             && dstRGB == GL_ONE_MINUS_SRC_ALPHA) {
 #if defined(USE_MMX_ASM)
-      if ( cpu_has_mmx ) {
+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
          swrast->BlendFunc = _mesa_mmx_blend_transparency;
       }
       else
 #endif
-	 swrast->BlendFunc = blend_transparency_ubyte;
+      {
+         if (chanType == GL_UNSIGNED_BYTE)
+            swrast->BlendFunc = blend_transparency_ubyte;
+         else if (chanType == GL_UNSIGNED_SHORT)
+            swrast->BlendFunc = blend_transparency_ushort;
+         else
+            swrast->BlendFunc = blend_transparency_float;
+      }
    }
    else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ONE) {
 #if defined(USE_MMX_ASM)
-      if ( cpu_has_mmx ) {
+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
          swrast->BlendFunc = _mesa_mmx_blend_add;
       }
       else
 #endif
-         swrast->BlendFunc = blend_add_ubyte;
+         swrast->BlendFunc = blend_add;
    }
    else if (((eq == GL_FUNC_ADD || eq == GL_FUNC_REVERSE_SUBTRACT)
 	     && (srcRGB == GL_ZERO && dstRGB == GL_SRC_COLOR))
@@ -1252,15 +958,15 @@ void _swrast_choose_blend_func( GLcontext *ctx )
 	    ((eq == GL_FUNC_ADD || eq == GL_FUNC_SUBTRACT)
 	     && (srcRGB == GL_DST_COLOR && dstRGB == GL_ZERO))) {
 #if defined(USE_MMX_ASM)
-      if ( cpu_has_mmx ) {
+      if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) {
          swrast->BlendFunc = _mesa_mmx_blend_modulate;
       }
       else
 #endif
-         swrast->BlendFunc = blend_modulate_ubyte;
+         swrast->BlendFunc = blend_modulate;
    }
    else if (eq == GL_FUNC_ADD && srcRGB == GL_ZERO && dstRGB == GL_ONE) {
-      swrast->BlendFunc = blend_noop_ubyte;
+      swrast->BlendFunc = blend_noop;
    }
    else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ZERO) {
       swrast->BlendFunc = blend_replace;
@@ -1292,6 +998,5 @@ _swrast_blend_span(GLcontext *ctx, struct gl_renderbuffer *rb,
    rbPixels = _swrast_get_dest_rgba(ctx, rb, span);
 
    swrast->BlendFunc(ctx, span->end, span->array->mask,
-                     span->array->rgba, (const GLchan (*)[4]) rbPixels,
-                     span->array->ChanType);
+                     span->array->rgba, rbPixels, span->array->ChanType);
 }
diff --git a/src/mesa/swrast/s_blend.h b/src/mesa/swrast/s_blend.h
index 8baa8cd71d..5b8e3b7592 100644
--- a/src/mesa/swrast/s_blend.h
+++ b/src/mesa/swrast/s_blend.h
@@ -37,7 +37,7 @@ _swrast_blend_span(GLcontext *ctx, struct gl_renderbuffer *rb,
 
 
 extern void
-_swrast_choose_blend_func(GLcontext *ctx);
+_swrast_choose_blend_func(GLcontext *ctx, GLenum chanType);
 
 
 #endif
diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c
index bb096be75a..950561b5fc 100644
--- a/src/mesa/swrast/s_context.c
+++ b/src/mesa/swrast/s_context.c
@@ -291,6 +291,7 @@ _swrast_validate_triangle( GLcontext *ctx,
 
    _swrast_validate_derived( ctx );
    swrast->choose_triangle( ctx );
+   ASSERT(swrast->Triangle);
 
    if (ctx->Texture._EnabledUnits == 0
        && NEED_SECONDARY_COLOR(ctx)
@@ -314,6 +315,7 @@ _swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
 
    _swrast_validate_derived( ctx );
    swrast->choose_line( ctx );
+   ASSERT(swrast->Line);
 
    if (ctx->Texture._EnabledUnits == 0
        && NEED_SECONDARY_COLOR(ctx)
@@ -355,13 +357,13 @@ _swrast_validate_point( GLcontext *ctx, const SWvertex *v0 )
  */
 static void _ASMAPI
 _swrast_validate_blend_func(GLcontext *ctx, GLuint n, const GLubyte mask[],
-                            GLchan src[][4], CONST GLchan dst[][4],
+                            GLvoid *src, const GLvoid *dst,
                             GLenum chanType )
 {
    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 
-   _swrast_validate_derived( ctx );
-   _swrast_choose_blend_func( ctx );
+   _swrast_validate_derived( ctx ); /* why is this needed? */
+   _swrast_choose_blend_func( ctx, chanType );
 
    swrast->BlendFunc( ctx, n, mask, src, dst, chanType );
 }
diff --git a/src/mesa/swrast/s_context.h b/src/mesa/swrast/s_context.h
index 0f3df3b48a..b044790214 100644
--- a/src/mesa/swrast/s_context.h
+++ b/src/mesa/swrast/s_context.h
@@ -251,7 +251,7 @@ typedef void (*texture_sample_func)(GLcontext *ctx,
 
 typedef void (_ASMAPIP blend_func)( GLcontext *ctx, GLuint n,
                                     const GLubyte mask[],
-                                    GLchan src[][4], CONST GLchan dst[][4],
+                                    GLvoid *src, const GLvoid *dst,
                                     GLenum chanType);
 
 typedef void (*swrast_point_func)( GLcontext *ctx, const SWvertex *);
diff --git a/src/mesa/swrast/s_span.c b/src/mesa/swrast/s_span.c
index 72b14ebf3a..8c4ee3e909 100644
--- a/src/mesa/swrast/s_span.c
+++ b/src/mesa/swrast/s_span.c
@@ -149,62 +149,218 @@ _swrast_span_default_texcoords( GLcontext *ctx, struct sw_span *span )
 }
 
 
-/* Fill in the span.color.rgba array from the interpolation values */
+/**
+ * Interpolate colors to fill in the span->array->color array.
+ * \param specular  if true, interpolate specular, else interpolate rgba.
+ */
 static void
-interpolate_colors(GLcontext *ctx, struct sw_span *span)
+interpolate_colors(GLcontext *ctx, struct sw_span *span, GLboolean specular)
 {
    const GLuint n = span->end;
-   GLchan (*rgba)[4] = span->array->rgba;
    GLuint i;
    (void) ctx;
 
-   ASSERT((span->interpMask & SPAN_RGBA)  &&
-	  !(span->arrayMask & SPAN_RGBA));
+   if (!specular) {
+      ASSERT((span->interpMask & SPAN_RGBA)  &&
+             !(span->arrayMask & SPAN_RGBA));
+   }
 
    if (span->interpMask & SPAN_FLAT) {
       /* constant color */
-      GLchan color[4];
-      color[RCOMP] = FixedToChan(span->red);
-      color[GCOMP] = FixedToChan(span->green);
-      color[BCOMP] = FixedToChan(span->blue);
-      color[ACOMP] = FixedToChan(span->alpha);
-      for (i = 0; i < n; i++) {
-         COPY_CHAN4(span->array->rgba[i], color);
+      switch (span->array->ChanType) {
+      case GL_UNSIGNED_BYTE:
+         {
+            GLubyte (*rgba)[4] = specular
+               ? span->array->color.sz1.spec : span->array->color.sz1.rgba;
+            GLubyte color[4];
+            if (specular) {
+               color[RCOMP] = FixedToInt(span->specRed);
+               color[GCOMP] = FixedToInt(span->specGreen);
+               color[BCOMP] = FixedToInt(span->specBlue);
+               color[ACOMP] = 0;
+            }
+            else {
+               color[RCOMP] = FixedToInt(span->red);
+               color[GCOMP] = FixedToInt(span->green);
+               color[BCOMP] = FixedToInt(span->blue);
+               color[ACOMP] = FixedToInt(span->alpha);
+            }
+            for (i = 0; i < n; i++) {
+               COPY_4UBV(rgba[i], color);
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT:
+         {
+            GLushort (*rgba)[4] = specular
+               ? span->array->color.sz2.spec : span->array->color.sz2.rgba;
+            GLushort color[4];
+            if (specular) {
+               color[RCOMP] = FixedToInt(span->specRed);
+               color[GCOMP] = FixedToInt(span->specGreen);
+               color[BCOMP] = FixedToInt(span->specBlue);
+               color[ACOMP] = 0;
+            }
+            else {
+               color[RCOMP] = FixedToInt(span->red);
+               color[GCOMP] = FixedToInt(span->green);
+               color[BCOMP] = FixedToInt(span->blue);
+               color[ACOMP] = FixedToInt(span->alpha);
+            }
+            for (i = 0; i < n; i++) {
+               COPY_4V(rgba[i], color);
+            }
+         }
+         break;
+      case GL_FLOAT:
+         {
+            GLfloat (*rgba)[4] = specular ? 
+               span->array->color.sz4.spec : span->array->color.sz4.rgba;
+            GLfloat color[4];
+            ASSERT(CHAN_TYPE == GL_FLOAT);
+            if (specular) {
+               color[RCOMP] = span->specRed;
+               color[GCOMP] = span->specGreen;
+               color[BCOMP] = span->specBlue;
+               color[ACOMP] = 0.0F;
+            }
+            else {
+               color[RCOMP] = span->red;
+               color[GCOMP] = span->green;
+               color[BCOMP] = span->blue;
+               color[ACOMP] = span->alpha;
+            }
+            for (i = 0; i < n; i++) {
+               COPY_4V(rgba[i], color);
+            }
+         }
+         break;
+      default:
+         _mesa_problem(ctx, "bad datatype in interpolate_colors");
       }
    }
    else {
       /* interpolate */
-#if CHAN_TYPE == GL_FLOAT
-      GLfloat r = span->red;
-      GLfloat g = span->green;
-      GLfloat b = span->blue;
-      GLfloat a = span->alpha;
-      const GLfloat dr = span->redStep;
-      const GLfloat dg = span->greenStep;
-      const GLfloat db = span->blueStep;
-      const GLfloat da = span->alphaStep;
-#else
-      GLfixed r = span->red;
-      GLfixed g = span->green;
-      GLfixed b = span->blue;
-      GLfixed a = span->alpha;
-      const GLint dr = span->redStep;
-      const GLint dg = span->greenStep;
-      const GLint db = span->blueStep;
-      const GLint da = span->alphaStep;
-#endif
-      for (i = 0; i < n; i++) {
-         rgba[i][RCOMP] = FixedToChan(r);
-         rgba[i][GCOMP] = FixedToChan(g);
-         rgba[i][BCOMP] = FixedToChan(b);
-         rgba[i][ACOMP] = FixedToChan(a);
-         r += dr;
-         g += dg;
-         b += db;
-         a += da;
+      switch (span->array->ChanType) {
+      case GL_UNSIGNED_BYTE:
+         {
+            GLubyte (*rgba)[4] = specular
+               ? span->array->color.sz1.spec : span->array->color.sz1.rgba;
+            GLfixed r, g, b, a;
+            GLint dr, dg, db, da;
+            if (specular) {
+               r = span->specRed;
+               g = span->specGreen;
+               b = span->specBlue;
+               a = 0;
+               dr = span->specRedStep;
+               dg = span->specGreenStep;
+               db = span->specBlueStep;
+               da = 0;
+            }
+            else {
+               r = span->red;
+               g = span->green;
+               b = span->blue;
+               a = span->alpha;
+               dr = span->redStep;
+               dg = span->greenStep;
+               db = span->blueStep;
+               da = span->alphaStep;
+            }
+            for (i = 0; i < n; i++) {
+               rgba[i][RCOMP] = FixedToChan(r);
+               rgba[i][GCOMP] = FixedToChan(g);
+               rgba[i][BCOMP] = FixedToChan(b);
+               rgba[i][ACOMP] = FixedToChan(a);
+               r += dr;
+               g += dg;
+               b += db;
+               a += da;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT:
+         {
+            GLushort (*rgba)[4] = specular
+               ? span->array->color.sz2.spec : span->array->color.sz2.rgba;
+            GLfixed r, g, b, a;
+            GLint dr, dg, db, da;
+            if (specular) {
+               r = span->specRed;
+               g = span->specGreen;
+               b = span->specBlue;
+               a = 0;
+               dr = span->specRedStep;
+               dg = span->specGreenStep;
+               db = span->specBlueStep;
+               da = 0;
+            }
+            else {
+               r = span->red;
+               g = span->green;
+               b = span->blue;
+               a = span->alpha;
+               dr = span->redStep;
+               dg = span->greenStep;
+               db = span->blueStep;
+               da = span->alphaStep;
+            }
+            for (i = 0; i < n; i++) {
+               rgba[i][RCOMP] = FixedToChan(r);
+               rgba[i][GCOMP] = FixedToChan(g);
+               rgba[i][BCOMP] = FixedToChan(b);
+               rgba[i][ACOMP] = FixedToChan(a);
+               r += dr;
+               g += dg;
+               b += db;
+               a += da;
+            }
+         }
+         break;
+      case GL_FLOAT:
+         {
+            GLfloat (*rgba)[4] = specular ? 
+               span->array->color.sz4.spec : span->array->color.sz4.rgba;
+            GLfloat r, g, b, a, dr, dg, db, da;
+            if (specular) {
+               r = span->specRed;
+               g = span->specGreen;
+               b = span->specBlue;
+               a = 0.0F;
+               dr = span->specRedStep;
+               dg = span->specGreenStep;
+               db = span->specBlueStep;
+               da = 0.0F;
+            }
+            else {
+               r = span->red;
+               g = span->green;
+               b = span->blue;
+               a = span->alpha;
+               dr = span->redStep;
+               dg = span->greenStep;
+               db = span->blueStep;
+               da = span->alphaStep;
+            }
+            ASSERT(CHAN_TYPE == GL_FLOAT);
+            for (i = 0; i < n; i++) {
+               rgba[i][RCOMP] = r;
+               rgba[i][GCOMP] = g;
+               rgba[i][BCOMP] = b;
+               rgba[i][ACOMP] = a;
+               r += dr;
+               g += dg;
+               b += db;
+               a += da;
+            }
+         }
+         break;
+      default:
+         _mesa_problem(ctx, "bad datatype in interpolate_colors");
       }
    }
-   span->arrayMask |= SPAN_RGBA;
+   span->arrayMask |= (specular ? SPAN_SPEC : SPAN_RGBA);
 }
 
 
@@ -240,48 +396,6 @@ interpolate_indexes(GLcontext *ctx, struct sw_span *span)
 }
 
 
-/* Fill in the span.->array->spec array from the interpolation values */
-static void
-interpolate_specular(GLcontext *ctx, struct sw_span *span)
-{
-   (void) ctx;
-   if (span->interpMask & SPAN_FLAT) {
-      /* constant color */
-      const GLchan r = FixedToChan(span->specRed);
-      const GLchan g = FixedToChan(span->specGreen);
-      const GLchan b = FixedToChan(span->specBlue);
-      GLuint i;
-      for (i = 0; i < span->end; i++) {
-         span->array->spec[i][RCOMP] = r;
-         span->array->spec[i][GCOMP] = g;
-         span->array->spec[i][BCOMP] = b;
-      }
-   }
-   else {
-      /* interpolate */
-#if CHAN_TYPE == GL_FLOAT
-      GLfloat r = span->specRed;
-      GLfloat g = span->specGreen;
-      GLfloat b = span->specBlue;
-#else
-      GLfixed r = span->specRed;
-      GLfixed g = span->specGreen;
-      GLfixed b = span->specBlue;
-#endif
-      GLuint i;
-      for (i = 0; i < span->end; i++) {
-         span->array->spec[i][RCOMP] = FixedToChan(r);
-         span->array->spec[i][GCOMP] = FixedToChan(g);
-         span->array->spec[i][BCOMP] = FixedToChan(b);
-         r += span->specRedStep;
-         g += span->specGreenStep;
-         b += span->specBlueStep;
-      }
-   }
-   span->arrayMask |= SPAN_SPEC;
-}
-
-
 /* Fill in the span.array.fog values from the interpolation values */
 static void
 interpolate_fog(const GLcontext *ctx, struct sw_span *span)
@@ -1040,28 +1154,160 @@ _swrast_write_index_span( GLcontext *ctx, struct sw_span *span)
  * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
  */
 static void
-add_colors(GLuint n, GLchan rgba[][4], GLchan specular[][4] )
+add_specular(GLcontext *ctx, struct sw_span *span)
 {
-   GLuint i;
-   for (i = 0; i < n; i++) {
-#if CHAN_TYPE == GL_FLOAT
-      /* no clamping */
-      rgba[i][RCOMP] += specular[i][RCOMP];
-      rgba[i][GCOMP] += specular[i][GCOMP];
-      rgba[i][BCOMP] += specular[i][BCOMP];
-#else
-      GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
-      GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
-      GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
-      rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
-      rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
-      rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
-#endif
+   switch (span->array->ChanType) {
+   case GL_UNSIGNED_BYTE:
+      {
+         GLubyte (*rgba)[4] = span->array->color.sz1.rgba;
+         GLubyte (*spec)[4] = span->array->color.sz1.spec;
+         GLuint i;
+         for (i = 0; i < span->end; i++) {
+            GLint r = rgba[i][RCOMP] + spec[i][RCOMP];
+            GLint g = rgba[i][GCOMP] + spec[i][GCOMP];
+            GLint b = rgba[i][BCOMP] + spec[i][BCOMP];
+            GLint a = rgba[i][ACOMP] + spec[i][ACOMP];
+            rgba[i][RCOMP] = MIN2(r, 255);
+            rgba[i][GCOMP] = MIN2(g, 255);
+            rgba[i][BCOMP] = MIN2(b, 255);
+            rgba[i][ACOMP] = MIN2(a, 255);
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort (*rgba)[4] = span->array->color.sz2.rgba;
+         GLushort (*spec)[4] = span->array->color.sz2.spec;
+         GLuint i;
+         for (i = 0; i < span->end; i++) {
+            GLint r = rgba[i][RCOMP] + spec[i][RCOMP];
+            GLint g = rgba[i][GCOMP] + spec[i][GCOMP];
+            GLint b = rgba[i][BCOMP] + spec[i][BCOMP];
+            GLint a = rgba[i][ACOMP] + spec[i][ACOMP];
+            rgba[i][RCOMP] = MIN2(r, 65535);
+            rgba[i][GCOMP] = MIN2(g, 65535);
+            rgba[i][BCOMP] = MIN2(b, 65535);
+            rgba[i][ACOMP] = MIN2(a, 65535);
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat (*rgba)[4] = span->array->color.sz4.rgba;
+         GLfloat (*spec)[4] = span->array->color.sz4.spec;
+         GLuint i;
+         for (i = 0; i < span->end; i++) {
+            rgba[i][RCOMP] += spec[i][RCOMP];
+            rgba[i][GCOMP] += spec[i][GCOMP];
+            rgba[i][BCOMP] += spec[i][BCOMP];
+            rgba[i][ACOMP] += spec[i][ACOMP];
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "Invalid datatype in add_specular");
    }
 }
 
 
 /**
+ * Convert the span's color arrays to the given type.
+ */
+static void
+convert_color_type(GLcontext *ctx, struct sw_span *span, GLenum newType)
+{
+   const GLubyte *mask = span->array->mask;
+   GLubyte (*rgba1)[4] = span->array->color.sz1.rgba;
+   GLushort (*rgba2)[4] = span->array->color.sz2.rgba;
+   GLfloat (*rgba4)[4] = span->array->color.sz4.rgba;
+
+   ASSERT(span->array->ChanType != newType);
+
+   switch (span->array->ChanType) {
+   case GL_UNSIGNED_BYTE:
+      if (newType == GL_UNSIGNED_SHORT) {
+         GLuint i;
+         for (i = 0; i < span->end; i++) {
+            if (mask[i]) {
+               rgba2[i][RCOMP] = UBYTE_TO_USHORT(rgba1[i][RCOMP]);
+               rgba2[i][GCOMP] = UBYTE_TO_USHORT(rgba1[i][GCOMP]);
+               rgba2[i][BCOMP] = UBYTE_TO_USHORT(rgba1[i][BCOMP]);
+               rgba2[i][ACOMP] = UBYTE_TO_USHORT(rgba1[i][ACOMP]);
+            }
+         }
+      }
+      else {
+         GLuint i;
+         ASSERT(newType == GL_FLOAT);
+         for (i = 0; i < span->end; i++) {
+            if (mask[i]) {
+               rgba4[i][RCOMP] = UBYTE_TO_FLOAT(rgba1[i][RCOMP]);
+               rgba4[i][GCOMP] = UBYTE_TO_FLOAT(rgba1[i][GCOMP]);
+               rgba4[i][BCOMP] = UBYTE_TO_FLOAT(rgba1[i][BCOMP]);
+               rgba4[i][ACOMP] = UBYTE_TO_FLOAT(rgba1[i][ACOMP]);
+            }
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      if (newType == GL_UNSIGNED_BYTE) {
+         GLuint i;
+         for (i = 0; i < span->end; i++) {
+            if (mask[i]) {
+               rgba1[i][RCOMP] = USHORT_TO_UBYTE(rgba2[i][RCOMP]);
+               rgba1[i][GCOMP] = USHORT_TO_UBYTE(rgba2[i][GCOMP]);
+               rgba1[i][BCOMP] = USHORT_TO_UBYTE(rgba2[i][BCOMP]);
+               rgba1[i][ACOMP] = USHORT_TO_UBYTE(rgba2[i][ACOMP]);
+            }
+         }
+      }
+      else {
+         GLuint i;
+         ASSERT(newType == GL_FLOAT);
+         for (i = 0; i < span->end; i++) {
+            if (mask[i]) {
+               rgba4[i][RCOMP] = USHORT_TO_FLOAT(rgba2[i][RCOMP]);
+               rgba4[i][GCOMP] = USHORT_TO_FLOAT(rgba2[i][GCOMP]);
+               rgba4[i][BCOMP] = USHORT_TO_FLOAT(rgba2[i][BCOMP]);
+               rgba4[i][ACOMP] = USHORT_TO_FLOAT(rgba2[i][ACOMP]);
+            }
+         }
+      }
+      break;
+   case GL_FLOAT:
+      if (newType == GL_UNSIGNED_BYTE) {
+         GLuint i;
+         for (i = 0; i < span->end; i++) {
+            if (mask[i]) {
+               UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][RCOMP], rgba4[i][RCOMP]);
+               UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][GCOMP], rgba4[i][GCOMP]);
+               UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][BCOMP], rgba4[i][BCOMP]);
+               UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][ACOMP], rgba4[i][ACOMP]);
+            }
+         }
+      }
+      else {
+         GLuint i;
+         ASSERT(newType == GL_UNSIGNED_SHORT);
+         for (i = 0; i < span->end; i++) {
+            if (mask[i]) {
+               UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][RCOMP], rgba4[i][RCOMP]);
+               UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][GCOMP], rgba4[i][GCOMP]);
+               UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][BCOMP], rgba4[i][BCOMP]);
+               UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][ACOMP], rgba4[i][ACOMP]);
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "Invalid datatype in convert_color_type");
+   }
+   span->array->ChanType = newType;
+}
+
+
+
+/**
  * Apply all the per-fragment operations to a span.
  * This now includes texturing (_swrast_write_texture_span() is history).
  * This function may modify any of the array values in the span.
@@ -1144,10 +1390,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span)
    if (!deferredTexture) {
       /* Now we need the rgba array, fill it in if needed */
       if ((span->interpMask & SPAN_RGBA) && (span->arrayMask & SPAN_RGBA) == 0)
-         interpolate_colors(ctx, span);
+         interpolate_colors(ctx, span, GL_FALSE);
 
       if (span->interpMask & SPAN_SPEC)
-         interpolate_specular(ctx, span);
+         interpolate_colors(ctx, span, GL_TRUE);
 
       if (span->interpMask & SPAN_FOG)
          interpolate_fog(ctx, span);
@@ -1232,10 +1478,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span)
    if (deferredTexture) {
       /* Now we need the rgba array, fill it in if needed */
       if ((span->interpMask & SPAN_RGBA) && (span->arrayMask & SPAN_RGBA) == 0)
-         interpolate_colors(ctx, span);
+         interpolate_colors(ctx, span, GL_FALSE);
 
       if (span->interpMask & SPAN_SPEC)
-         interpolate_specular(ctx, span);
+         interpolate_colors(ctx, span, GL_TRUE);
 
       if (span->interpMask & SPAN_FOG)
          interpolate_fog(ctx, span);
@@ -1264,10 +1510,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span)
           (ctx->Light.Enabled &&
            ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {
          if (span->interpMask & SPAN_SPEC) {
-            interpolate_specular(ctx, span);
+            interpolate_colors(ctx, span, GL_TRUE);
          }
          if (span->arrayMask & SPAN_SPEC) {
-            add_colors( span->end, span->array->rgba, span->array->spec );
+            add_specular(ctx, span);
          }
          else {
             /* We probably added the base/specular colors during the
@@ -1316,14 +1562,20 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span)
       GLchan rgbaSave[MAX_WIDTH][4];
       GLuint buf;
 
+      if (numDrawBuffers > 0) {
+         if (fb->_ColorDrawBuffers[output][0]->DataType
+             != span->array->ChanType) {
+            convert_color_type(ctx, span,
+                               fb->_ColorDrawBuffers[output][0]->DataType);
+         }
+      }
+
       if (numDrawBuffers > 1) {
          /* save colors for second, third renderbuffer writes */
          _mesa_memcpy(rgbaSave, span->array->rgba,
                       4 * span->end * sizeof(GLchan));
       }
 
-      /* XXX check that span's ChanType == rb's DataType, convert if needed */
-
       for (buf = 0; buf < numDrawBuffers; buf++) {
          struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[output][buf];
          ASSERT(rb->_BaseFormat == GL_RGBA);