Lots of GLchan datatype changes.

Added GLvector4us datatype in math/m_vector.[ch]
Added _math_trans_4us() in math/m_translate.[ch]
Choose GLvector4ub, GLvector4us, GLvector4f at compile time based on CHAN_BITS.
Made Driver.ClearColor() and Driver.ClearIndex() optional driver functions.
Changed args to Driver.ClearColor(), updated drivers.
Reordered files in Makefile.X11

15 files changed, 706 insertions, 638 deletions

diff --git a/src/mesa/drivers/ggi/ggimesa.c b/src/mesa/drivers/ggi/ggimesa.c
index cc22ba32b7e..6bcb2d17cd5 100644
--- a/src/mesa/drivers/ggi/ggimesa.c
+++ b/src/mesa/drivers/ggi/ggimesa.c
@@ -97,17 +97,16 @@ static void gl_ggiSetColor(GLcontext *ctx, GLubyte red, GLubyte green,
 	GGICTX->color = col;
 }
 
-static void gl_ggiSetClearColor(GLcontext *ctx, GLubyte red, GLubyte green,
-				GLubyte blue, GLubyte alpha)
+static void gl_ggiSetClearColor(GLcontext *ctx, const GLchan color[4])
 {
 	ggi_color rgb;
 	ggi_pixel col;
 	
 	GGIMESADPRINT_CORE("gl_ggiSetClearColor() called\n");
 	
-	rgb.r = (uint16)red << SHIFT;
-	rgb.g = (uint16)green << SHIFT;
-	rgb.b = (uint16)blue << SHIFT;
+	rgb.r = (uint16)color[0] << SHIFT;
+	rgb.g = (uint16)color[1] << SHIFT;
+	rgb.b = (uint16)color[2] << SHIFT;
 	col = ggiMapColor(VIS, &rgb);
 	ggiSetGCForeground(VIS, col);
 	GGICTX->clearcolor = col;
diff --git a/src/mesa/drivers/glide/fxdd.c b/src/mesa/drivers/glide/fxdd.c
index fe918a7eac3..d854ba9950f 100644
--- a/src/mesa/drivers/glide/fxdd.c
+++ b/src/mesa/drivers/glide/fxdd.c
@@ -128,22 +128,19 @@ static void fxDDBufferSize(GLcontext *ctx, GLuint *width, GLuint *height)
 
 
 /* Implements glClearColor() */
-static void fxDDClearColor(GLcontext *ctx, GLubyte red, GLubyte green,
-                           GLubyte blue, GLubyte alpha )
+static void fxDDClearColor(GLcontext *ctx, const GLchan color[4])
 {
   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
   GLubyte col[4];
 
-
-
-  ASSIGN_4V( col, red, green, blue, 255 );
-
   if (MESA_VERBOSE&VERBOSE_DRIVER) {
-    fprintf(stderr,"fxmesa: fxDDClearColor(%d,%d,%d,%d)\n",red,green,blue,alpha);
+    fprintf(stderr,"fxmesa: fxDDClearColor(%d,%d,%d,%d)\n",
+            color[0], color[1], color[2], color[3]);
   }
 
-  fxMesa->clearC=FXCOLOR4( col );
-  fxMesa->clearA=alpha;
+  ASSIGN_4V( col, color[0], color[1], color[2], 255 );
+  fxMesa->clearC = FXCOLOR4( col );
+  fxMesa->clearA = color[3];
 }
 
 
diff --git a/src/mesa/drivers/osmesa/osmesa.c b/src/mesa/drivers/osmesa/osmesa.c
index a5c58598677..36e306cf6ec 100644
--- a/src/mesa/drivers/osmesa/osmesa.c
+++ b/src/mesa/drivers/osmesa/osmesa.c
@@ -1,10 +1,10 @@
-/* $Id: osmesa.c,v 1.40 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: osmesa.c,v 1.41 2001/01/24 00:04:58 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  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"),
@@ -41,6 +41,7 @@
 #include "glheader.h"
 #include "GL/osmesa.h"
 #include "context.h"
+#include "colormac.h"
 #include "depth.h"
 #include "macros.h"
 #include "mem.h"
@@ -75,13 +76,12 @@ struct osmesa_context {
    GLenum format;		/* either GL_RGBA or GL_COLOR_INDEX */
    void *buffer;		/* the image buffer */
    GLint width, height;		/* size of image buffer */
-   GLuint clearpixel;		/* pixel for clearing the color buffer */
    GLint rowlength;		/* number of pixels per row */
    GLint userRowLength;		/* user-specified number of pixels per row */
    GLint rshift, gshift;	/* bit shifts for RGBA formats */
    GLint bshift, ashift;
-   GLint rind, gind, bind;	/* index offsets for RGBA formats */
-   void *rowaddr[MAX_HEIGHT];	/* address of first pixel in each image row */
+   GLint rInd, gInd, bInd, aInd;/* index offsets for RGBA formats */
+   GLchan *rowaddr[MAX_HEIGHT];	/* address of first pixel in each image row */
    GLboolean yup;		/* TRUE  -> Y increases upward */
 				/* FALSE -> Y increases downward */
 };
@@ -132,16 +132,16 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
 {
    OSMesaContext osmesa;
    GLint rshift, gshift, bshift, ashift;
-   GLint rind, gind, bind;
+   GLint rind, gind, bind, aind;
    GLint indexBits, redBits, greenBits, blueBits, alphaBits;
    GLboolean rgbmode;
    GLboolean swalpha;
-   GLuint i4 = 1;
-   GLubyte *i1 = (GLubyte *) &i4;
-   GLint little_endian = *i1;
+   const GLuint i4 = 1;
+   const GLubyte *i1 = (GLubyte *) &i4;
+   const GLint little_endian = *i1;
 
    swalpha = GL_FALSE;
-   rind = gind = bind = 0;
+   rind = gind = bind = aind = 0;
    if (format==OSMESA_COLOR_INDEX) {
       indexBits = 8;
       rshift = gshift = bshift = ashift = 0;
@@ -153,6 +153,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       greenBits = 8;
       blueBits = 8;
       alphaBits = 8;
+      rind = 0;
+      gind = 1;
+      bind = 2;
+      aind = 3;
       if (little_endian) {
          rshift = 0;
          gshift = 8;
@@ -173,6 +177,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       greenBits = 8;
       blueBits = 8;
       alphaBits = 8;
+      rind = 2;
+      gind = 1;
+      bind = 0;
+      aind = 3;
       if (little_endian) {
          ashift = 0;
          rshift = 8;
@@ -193,6 +201,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       greenBits = 8;
       blueBits = 8;
       alphaBits = 8;
+      rind = 1;
+      gind = 2;
+      bind = 3;
+      aind = 0;
       if (little_endian) {
          bshift = 0;
          gshift = 8;
@@ -217,9 +229,9 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       gshift = 8;
       rshift = 16;
       ashift = 24;
-      bind = 2;
-      gind = 1;
       rind = 0;
+      gind = 1;
+      bind = 2;
       rgbmode = GL_TRUE;
       swalpha = GL_TRUE;
    }
@@ -233,9 +245,9 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       gshift = 8;
       rshift = 16;
       ashift = 24;
-      bind = 0;
-      gind = 1;
       rind = 2;
+      gind = 1;
+      bind = 0;
       rgbmode = GL_TRUE;
       swalpha = GL_TRUE;
    }
@@ -295,7 +307,6 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       osmesa->buffer = NULL;
       osmesa->width = 0;
       osmesa->height = 0;
-      osmesa->clearpixel = 0;
       osmesa->userRowLength = 0;
       osmesa->rowlength = 0;
       osmesa->yup = GL_TRUE;
@@ -303,9 +314,10 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       osmesa->gshift = gshift;
       osmesa->bshift = bshift;
       osmesa->ashift = ashift;
-      osmesa->rind = rind;
-      osmesa->gind = gind;
-      osmesa->bind = bind;
+      osmesa->rInd = rind;
+      osmesa->gInd = gind;
+      osmesa->bInd = bind;
+      osmesa->aInd = aind;
 
 
       /* Initialize the software rasterizer and helper modules.
@@ -349,56 +361,35 @@ void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx )
  */
 static void compute_row_addresses( OSMesaContext ctx )
 {
-   GLint i;
+   GLint bytesPerPixel, bytesPerRow, i;
+   GLubyte *origin = (GLubyte *) ctx->buffer;
+
+   if (ctx->format == OSMESA_COLOR_INDEX) {
+      /* CI mode */
+      bytesPerPixel = 1 * sizeof(GLchan);
+   }
+   else if ((ctx->format == OSMESA_RGB) || (ctx->format == OSMESA_BGR)) {
+      /* RGB mode */
+      bytesPerPixel = 3 * sizeof(GLchan);
+   }
+   else {
+      /* RGBA mode */
+      bytesPerPixel = 4 * sizeof(GLchan);
+   }
+
+   bytesPerRow = ctx->rowlength * bytesPerPixel;
 
    if (ctx->yup) {
       /* Y=0 is bottom line of window */
-      if (ctx->format==OSMESA_COLOR_INDEX) {
-         /* 1-byte CI mode */
-         GLubyte *origin = (GLubyte *) ctx->buffer;
-         for (i=0;i<MAX_HEIGHT;i++) {
-            ctx->rowaddr[i] = origin + i * ctx->rowlength;
-         }
-      }
-      else {
-         if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) {
-            /* 3-byte RGB mode */
-            GLubyte *origin = (GLubyte *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + (i * (ctx->rowlength*3));
-            }
-         } else {
-            /* 4-byte RGBA mode */
-            GLuint *origin = (GLuint *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + i * ctx->rowlength;
-            }
-         }
+      for (i = 0; i < MAX_HEIGHT; i++) {
+         ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + i * bytesPerRow);
       }
    }
    else {
       /* Y=0 is top line of window */
-      if (ctx->format==OSMESA_COLOR_INDEX) {
-         /* 1-byte CI mode */
-         GLubyte *origin = (GLubyte *) ctx->buffer;
-         for (i=0;i<MAX_HEIGHT;i++) {
-            ctx->rowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength;
-         }
-      }
-      else {
-         if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) {
-            /* 3-byte RGB mode */
-            GLubyte *origin = (GLubyte *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + ((ctx->height-i-1) * (ctx->rowlength*3));
-            }
-         } else {
-            /* 4-byte RGBA mode */
-            GLuint *origin = (GLuint *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength;
-            }
-         }
+      for (i = 0; i < MAX_HEIGHT; i++) {
+         GLint j = ctx->height - i - 1;
+         ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + j * bytesPerRow);
       }
    }
 }
@@ -435,8 +426,9 @@ GLboolean GLAPIENTRY
 OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
                    GLsizei width, GLsizei height )
 {
-   if (!ctx || !buffer || type!=GL_UNSIGNED_BYTE
-       || width<1 || height<1 || width>MAX_WIDTH || height>MAX_HEIGHT) {
+   if (!ctx || !buffer || type != CHAN_TYPE ||
+       width < 1 || height < 1 ||
+       width > MAX_WIDTH || height > MAX_HEIGHT) {
       return GL_FALSE;
    }
 
@@ -596,25 +588,39 @@ OSMesaGetColorBuffer( OSMesaContext c, GLint *width,
 /*
  * Useful macros:
  */
-#define PACK_RGBA(R,G,B,A)  (  ((R) << osmesa->rshift) \
-                             | ((G) << osmesa->gshift) \
-                             | ((B) << osmesa->bshift) \
-                             | ((A) << osmesa->ashift) )
 
-#define PACK_RGBA2(R,G,B,A)  (  ((R) << rshift) \
-                              | ((G) << gshift) \
-                              | ((B) << bshift) \
-                              | ((A) << ashift) )
+#define PACK_RGBA(DST, R, G, B, A)	\
+do {					\
+   (DST)[osmesa->rInd] = R;		\
+   (DST)[osmesa->gInd] = G;		\
+   (DST)[osmesa->bInd] = B;		\
+   (DST)[osmesa->aInd] = A;		\
+} while (0)
+
+#define PACK_RGB(DST, R, G, B)  \
+do {				\
+   (DST)[0] = R;		\
+   (DST)[1] = G;		\
+   (DST)[2] = B;		\
+} while (0)
 
-#define UNPACK_RED(P)      (((P) >> osmesa->rshift) & 0xff)
-#define UNPACK_GREEN(P)    (((P) >> osmesa->gshift) & 0xff)
-#define UNPACK_BLUE(P)     (((P) >> osmesa->bshift) & 0xff)
-#define UNPACK_ALPHA(P)    (((P) >> osmesa->ashift) & 0xff)
+#define PACK_BGR(DST, R, G, B)  \
+do {				\
+   (DST)[0] = B;		\
+   (DST)[1] = G;		\
+   (DST)[2] = R;		\
+} while (0)
 
-#define PIXELADDR1(X,Y)  ((GLubyte *) osmesa->rowaddr[Y] + (X))
-#define PIXELADDR3(X,Y)  ((GLubyte *) osmesa->rowaddr[Y] + ((X)*3))
-#define PIXELADDR4(X,Y)  ((GLuint *)  osmesa->rowaddr[Y] + (X))
 
+#define UNPACK_RED(P)      ( ((GLchan *) &(P))[osmesa->rInd] )
+#define UNPACK_GREEN(P)    ( ((GLchan *) &(P))[osmesa->gInd] )
+#define UNPACK_BLUE(P)     ( ((GLchan *) &(P))[osmesa->bInd] )
+#define UNPACK_ALPHA(P)    ( ((GLchan *) &(P))[osmesa->aInd] )
+
+
+#define PIXELADDR1(X,Y)  (osmesa->rowaddr[Y] + (X))
+#define PIXELADDR3(X,Y)  (osmesa->rowaddr[Y] + 3 * (X))
+#define PIXELADDR4(X,Y)  (osmesa->rowaddr[Y] + 4 * (X))
 
 
 
@@ -638,23 +644,6 @@ static void set_read_buffer( GLcontext *ctx, GLframebuffer *buffer, GLenum mode
 }
 
 
-static void clear_index( GLcontext *ctx, GLuint index )
-{
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   osmesa->clearpixel = index;
-}
-
-
-
-static void clear_color( GLcontext *ctx,
-                         GLchan r, GLchan g, GLchan b, GLchan a )
-{
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   osmesa->clearpixel = PACK_RGBA( r, g, b, a );
-}
-
-
-
 static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
                          GLint x, GLint y, GLint width, GLint height )
 {
@@ -669,65 +658,102 @@ static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
    ASSERT((mask & (DD_FRONT_RIGHT_BIT | DD_BACK_LEFT_BIT | DD_BACK_RIGHT_BIT)) == 0);
 
    if (mask & DD_FRONT_LEFT_BIT) {
-      if (osmesa->format==OSMESA_COLOR_INDEX) {
+      if (osmesa->format == OSMESA_COLOR_INDEX) {
          if (all) {
             /* Clear whole CI buffer */
-            MEMSET(osmesa->buffer, osmesa->clearpixel,
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+            MEMSET(osmesa->buffer, ctx->Color.ClearIndex,
                    osmesa->rowlength * osmesa->height);
+#else
+            const GLint n = osmesa->rowlength * osmesa->height;
+            GLchan *buffer = (GLchan *) osmesa->buffer;
+            GLint i;
+            for (i = 0; i < n; i ++) {
+               buffer[i] = ctx->Color.ClearIndex;
+            }
+#endif
          }
          else {
             /* Clear part of CI buffer */
+            const GLchan clearIndex = (GLchan) ctx->Color.ClearIndex;
             GLint i, j;
-            for (i=0;i<height;i++) {
-               GLubyte *ptr1 = PIXELADDR1( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  *ptr1++ = osmesa->clearpixel;
+            for (i = 0; i < height; i++) {
+               GLchan *ptr1 = PIXELADDR1(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  *ptr1++ = clearIndex;
                }
             }
          }
       }
-      else if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR)) {
-         GLubyte rval = UNPACK_RED(osmesa->clearpixel);
-         GLubyte gval = UNPACK_GREEN(osmesa->clearpixel);
-         GLubyte bval = UNPACK_BLUE(osmesa->clearpixel);
-         GLint   rind = osmesa->rind;
-         GLint   gind = osmesa->gind;
-         GLint   bind = osmesa->bind;
+      else if (osmesa->format == OSMESA_RGB) {
+         const GLchan r = ctx->Color.ClearColor[0];
+         const GLchan g = ctx->Color.ClearColor[1];
+         const GLchan b = ctx->Color.ClearColor[2];
          if (all) {
-            GLuint  i, n;
-            GLubyte *ptr3 = (GLubyte *) osmesa->buffer;
             /* Clear whole RGB buffer */
-            n = osmesa->rowlength * osmesa->height;
-            for (i=0;i<n;i++) {
-               ptr3[rind] = rval;
-               ptr3[gind] = gval;
-               ptr3[bind] = bval;
+            GLuint n = osmesa->rowlength * osmesa->height;
+            GLchan *ptr3 = (GLchan *) osmesa->buffer;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               PACK_RGB(ptr3, r, g, b);
                ptr3 += 3;
             }
          }
          else {
             /* Clear part of RGB buffer */
             GLint i, j;
-            for (i=0;i<height;i++) {
-               GLubyte *ptr3 = PIXELADDR3( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  ptr3[rind] = rval;
-                  ptr3[gind] = gval;
-                  ptr3[bind] = bval;
+            for (i = 0; i < height; i++) {
+               GLchan *ptr3 = PIXELADDR3(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  PACK_RGB(ptr3, r, g, b);
+                  ptr3 += 3;
+               }
+            }
+         }
+      }
+      else if (osmesa->format == OSMESA_BGR) {
+         const GLchan r = ctx->Color.ClearColor[0];
+         const GLchan g = ctx->Color.ClearColor[1];
+         const GLchan b = ctx->Color.ClearColor[2];
+         if (all) {
+            /* Clear whole RGB buffer */
+            const GLint n = osmesa->rowlength * osmesa->height;
+            GLchan *ptr3 = (GLchan *) osmesa->buffer;
+            GLint i;
+            for (i = 0; i < n; i++) {
+               PACK_BGR(ptr3, r, g, b);
+               ptr3 += 3;
+            }
+         }
+         else {
+            /* Clear part of RGB buffer */
+            GLint i, j;
+            for (i = 0; i < height; i++) {
+               GLchan *ptr3 = PIXELADDR3(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  PACK_BGR(ptr3, r, g, b);
                   ptr3 += 3;
                }
             }
          }
       }
       else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+         /* 4-byte pixel value */
+         GLuint clearPixel;
+         GLchan *clr = (GLchan *) &clearPixel;
+         clr[osmesa->rInd] = ctx->Color.ClearColor[0];
+         clr[osmesa->gInd] = ctx->Color.ClearColor[1];
+         clr[osmesa->bInd] = ctx->Color.ClearColor[2];
+         clr[osmesa->aInd] = ctx->Color.ClearColor[3];
          if (all) {
             /* Clear whole RGBA buffer */
-            GLuint i, n, *ptr4;
-            n = osmesa->rowlength * osmesa->height;
-            ptr4 = (GLuint *) osmesa->buffer;
-            if (osmesa->clearpixel) {
-               for (i=0;i<n;i++) {
-                  *ptr4++ = osmesa->clearpixel;
+            const GLuint n = osmesa->rowlength * osmesa->height;
+            GLuint *ptr4 = (GLuint *) osmesa->buffer;
+            GLuint i;
+            if (clearPixel) {
+               for (i = 0; i < n; i++) {
+                  *ptr4++ = clearPixel;
                }
             }
             else {
@@ -737,13 +763,41 @@ static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
          else {
             /* Clear part of RGBA buffer */
             GLint i, j;
-            for (i=0;i<height;i++) {
-               GLuint *ptr4 = PIXELADDR4( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  *ptr4++ = osmesa->clearpixel;
+            for (i = 0; i < height; i++) {
+               GLuint *ptr4 = (GLuint *) PIXELADDR4(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  *ptr4++ = clearPixel;
+               }
+            }
+         }
+#else
+         const GLchan r = ctx->Color.ClearColor[0];
+         const GLchan g = ctx->Color.ClearColor[1];
+         const GLchan b = ctx->Color.ClearColor[2];
+         const GLchan a = ctx->Color.ClearColor[3];
+         if (all) {
+            /* Clear whole RGBA buffer */
+            const GLuint n = osmesa->rowlength * osmesa->height;
+            GLchan *p = (GLchan *) osmesa->buffer;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               PACK_RGBA(p, r, g, b, a);
+               p += 4;
+            }
+         }
+         else {
+            /* Clear part of RGBA buffer */
+            GLint i, j;
+            for (i = 0; i < height; i++) {
+               GLchan *p = PIXELADDR4(x, (y + i));
+               for (j = 0; j < width; j++) {
+                  PACK_RGBA(p, r, g, b, a);
+                  p += 4;
                }
             }
          }
+
+#endif
       }
    }
    /* have Mesa clear all other buffers */
@@ -765,44 +819,42 @@ static void buffer_size( GLcontext *ctx, GLuint *width, GLuint *height )
 /**********************************************************************/
 
 /* Write RGBA pixels to an RGBA (or permuted) buffer. */
-static void write_rgba_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             CONST GLchan rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                 CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
    if (mask) {
-      for (i=0;i<n;i++,ptr4++) {
+      for (i = 0; i < n; i++, p += 4) {
          if (mask[i]) {
-            *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+            PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                         rgba[i][BCOMP], rgba[i][ACOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr4++) {
-         *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+      for (i = 0; i < n; i++, p += 4) {
+         PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                      rgba[i][BCOMP], rgba[i][ACOMP]);
       }
    }
 }
 
 
 /* Write RGBA pixels to an RGBA buffer.  This is the fastest span-writer. */
-static void write_rgba_span_rgba( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-                                  CONST GLchan rgba[][4],
-                                  const GLubyte mask[] )
+static void
+write_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      CONST GLchan rgba[][4], const GLubyte mask[] )
 {
    OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
    const GLuint *rgba4 = (const GLuint *) rgba;
    GLuint i;
+   ASSERT(CHAN_TYPE == GL_UNSIGNED_BYTE);
    if (mask) {
-      for (i=0;i<n;i++) {
+      for (i = 0; i < n; i++) {
          if (mask[i]) {
             ptr4[i] = rgba4[i];
          }
@@ -815,130 +867,120 @@ static void write_rgba_span_rgba( const GLcontext *ctx,
 
 
 /* Write RGB pixels to an RGBA (or permuted) buffer. */
-static void write_rgb_span( const GLcontext *ctx,
-                            GLuint n, GLint x, GLint y,
-                            CONST GLchan rgb[][3], const GLubyte mask[] )
+static void
+write_rgb_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                CONST GLchan rgb[][3], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
    if (mask) {
-      for (i=0;i<n;i++,ptr4++) {
+      for (i = 0; i < n; i++, p+=4) {
          if (mask[i]) {
-            *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+            PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr4++) {
-         *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
+      for (i = 0; i < n; i++, p+=4) {
+         PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
       }
    }
 }
 
 
 
-static void write_monocolor_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  const GLchan color[4], const GLubyte mask[] )
+static void
+write_monocolor_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      const GLchan color[4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLuint pixel = PACK_RGBA(color[RCOMP], color[GCOMP],
-                                  color[BCOMP], color[ACOMP]);
-   GLuint *ptr4 = PIXELADDR4(x,y);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   for (i=0;i<n;i++,ptr4++) {
+   for (i = 0; i < n; i++, p += 4) {
       if (mask[i]) {
-         *ptr4 = pixel;
+         PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
       }
    }
 }
 
 
 
-static void write_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-                               CONST GLchan rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_pixels( const GLcontext *ctx, GLuint n,
+                   const GLint x[], const GLint y[],
+                   CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+         GLchan *p = PIXELADDR4(x[i], y[i]);
+         PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                      rgba[i][BCOMP], rgba[i][ACOMP]);
       }
    }
 }
 
 
 
-static void write_monocolor_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    const GLchan color[4],
-                                    const GLubyte mask[] )
+static void
+write_monocolor_pixels( const GLcontext *ctx, GLuint n,
+                        const GLint x[], const GLint y[],
+                        const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLuint pixel = PACK_RGBA(color[RCOMP], color[GCOMP],
-                                  color[BCOMP], color[ACOMP]);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         *ptr4 = pixel;
+         GLchan *p = PIXELADDR4(x[i], y[i]);
+         PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
       }
    }
 }
 
 
-static void read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                             GLchan rgba[][4] )
+static void
+read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                GLchan rgba[][4] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLuint *ptr4 = PIXELADDR4(x,y);
-   for (i=0;i<n;i++) {
-      GLuint pixel = *ptr4++;
-      rgba[i][RCOMP] = UNPACK_RED(pixel);
-      rgba[i][GCOMP] = UNPACK_GREEN(pixel);
-      rgba[i][BCOMP] = UNPACK_BLUE(pixel);
-      rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+   GLchan *p = PIXELADDR4(x, y);
+   for (i = 0; i < n; i++, p += 4) {
+      rgba[i][RCOMP] = UNPACK_RED(p);
+      rgba[i][GCOMP] = UNPACK_GREEN(p);
+      rgba[i][BCOMP] = UNPACK_BLUE(p);
+      rgba[i][ACOMP] = UNPACK_ALPHA(p);
    }
 }
 
 
 /* Read RGBA pixels from an RGBA buffer */
-static void read_rgba_span_rgba( const GLcontext *ctx,
-                                 GLuint n, GLint x, GLint y,
-                                 GLchan rgba[][4] )
+static void
+read_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     GLchan rgba[][4] )
 {
    OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLuint *ptr4 = PIXELADDR4(x,y);
+   GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
    MEMCPY( rgba, ptr4, n * 4 * sizeof(GLchan) );
 }
 
 
-static void read_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLchan rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels( const GLcontext *ctx,
+                  GLuint n, const GLint x[], const GLint y[],
+                  GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         GLuint pixel = *ptr4;
-         rgba[i][RCOMP] = UNPACK_RED(pixel);
-         rgba[i][GCOMP] = UNPACK_GREEN(pixel);
-         rgba[i][BCOMP] = UNPACK_BLUE(pixel);
-         rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+         const GLchan *p = PIXELADDR4(x[i], y[i]);
+         rgba[i][RCOMP] = UNPACK_RED(p);
+         rgba[i][GCOMP] = UNPACK_GREEN(p);
+         rgba[i][BCOMP] = UNPACK_BLUE(p);
+         rgba[i][ACOMP] = UNPACK_ALPHA(p);
       }
    }
 }
@@ -947,164 +989,212 @@ static void read_rgba_pixels( const GLcontext *ctx,
 /*****                3 byte RGB pixel support funcs              *****/
 /**********************************************************************/
 
-/* Write RGBA pixels to an RGB or BGR buffer. */
-static void write_rgba_span3( const GLcontext *ctx,
-                              GLuint n, GLint x, GLint y,
-                              CONST GLchan rgba[][4], const GLubyte mask[] )
+/* Write RGBA pixels to an RGB buffer. */
+static void
+write_rgba_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
    if (mask) {
-      for (i=0;i<n;i++,ptr3+=3) {
+      for (i = 0; i < n; i++, p += 3) {
          if (mask[i]) {
-            ptr3[rind] = rgba[i][RCOMP];
-            ptr3[gind] = rgba[i][GCOMP];
-            ptr3[bind] = rgba[i][BCOMP];
+            PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr3+=3) {
-         ptr3[rind] = rgba[i][RCOMP];
-         ptr3[gind] = rgba[i][GCOMP];
-         ptr3[bind] = rgba[i][BCOMP];
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
-/* Write RGB pixels to an RGB or BGR buffer. */
-static void write_rgb_span3( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             CONST GLchan rgb[][3], const GLubyte mask[] )
+/* Write RGBA pixels to an BGR buffer. */
+static void
+write_rgba_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     CONST GLchan rgba[][4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLint rind = osmesa->rind;
-   const GLint gind = osmesa->gind;
-   const GLint bind = osmesa->bind;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
    if (mask) {
-      for (i=0;i<n;i++,ptr3+=3) {
+      for (i = 0; i < n; i++, p += 3) {
          if (mask[i]) {
-            ptr3[rind] = rgb[i][RCOMP];
-            ptr3[gind] = rgb[i][GCOMP];
-            ptr3[bind] = rgb[i][BCOMP];
+            PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr3+=3) {
-         ptr3[rind] = rgb[i][RCOMP];
-         ptr3[gind] = rgb[i][GCOMP];
-         ptr3[bind] = rgb[i][BCOMP];
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
+/* Write RGB pixels to an RGB buffer. */
+static void
+write_rgb_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    CONST GLchan rgb[][3], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   if (mask) {
+      for (i = 0; i < n; i++, p += 3) {
+         if (mask[i]) {
+            PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
 
-static void write_monocolor_span3( const GLcontext *ctx,
-                                   GLuint n, GLint x, GLint y,
-                                   const GLchan color[4], const GLubyte mask[] )
+/* Write RGB pixels to an BGR buffer. */
+static void
+write_rgb_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    CONST GLchan rgb[][3], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLubyte rval = color[RCOMP];
-   const GLubyte gval = color[GCOMP];
-   const GLubyte bval = color[BCOMP];
-   const GLint   rind = osmesa->rind;
-   const GLint   gind = osmesa->gind;
-   const GLint   bind = osmesa->bind;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   for (i=0;i<n;i++,ptr3+=3) {
+   if (mask) {
+      for (i = 0; i < n; i++, p += 3) {
+         if (mask[i]) {
+            PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
+
+
+static void
+write_monocolor_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLchan color[4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   for (i = 0; i < n; i++, p += 3) {
+      if (mask[i]) {
+         PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+      }
+   }
+}
+
+static void
+write_monocolor_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLchan color[4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   for (i = 0; i < n; i++, p += 3) {
       if (mask[i]) {
-         ptr3[rind] = rval;
-         ptr3[gind] = gval;
-         ptr3[bind] = bval;
+         PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void write_rgba_pixels3( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-                                CONST GLchan rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_pixels_RGB( const GLcontext *ctx, GLuint n,
+                       const GLint x[], const GLint y[],
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = (const OSMesaContext) ctx;
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+static void
+write_rgba_pixels_BGR( const GLcontext *ctx, GLuint n,
+                       const GLint x[], const GLint y[],
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = (const OSMesaContext) ctx;
+   GLuint i;
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         ptr3[rind] = rgba[i][RCOMP];
-         ptr3[gind] = rgba[i][GCOMP];
-         ptr3[bind] = rgba[i][BCOMP];
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
-static void write_monocolor_pixels3( const GLcontext *ctx,
-                                     GLuint n, const GLint x[],
-                                     const GLint y[],
-                                     const GLchan color[4],
-                                     const GLubyte mask[] )
+static void
+write_monocolor_pixels_RGB( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLchan color[4], const GLubyte mask[] )
 {
    const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   const GLint rind = osmesa->rind;
-   const GLint gind = osmesa->gind;
-   const GLint bind = osmesa->bind;
-   const GLubyte rval = color[RCOMP];
-   const GLubyte gval = color[GCOMP];
-   const GLubyte bval = color[BCOMP];
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         ptr3[rind] = rval;
-         ptr3[gind] = gval;
-         ptr3[bind] = bval;
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void read_rgba_span3( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             GLchan rgba[][4] )
+static void
+write_monocolor_pixels_BGR( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+      }
+   }
+}
+
+static void
+read_rgba_span3( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                 GLchan rgba[][4] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   const GLubyte *ptr3 = PIXELADDR3( x, y);
-   for (i=0;i<n;i++,ptr3+=3) {
-      rgba[i][RCOMP] = ptr3[rind];
-      rgba[i][GCOMP] = ptr3[gind];
-      rgba[i][BCOMP] = ptr3[bind];
-      rgba[i][ACOMP] = 0;
+   const GLchan *p = PIXELADDR3(x, y);
+   for (i = 0; i < n; i++, p += 3) {
+      rgba[i][RCOMP] = UNPACK_RED(p);
+      rgba[i][GCOMP] = UNPACK_GREEN(p);
+      rgba[i][BCOMP] = UNPACK_BLUE(p);
+      rgba[i][ACOMP] = 255;
    }
 }
 
-static void read_rgba_pixels3( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLchan rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels3( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         const GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         rgba[i][RCOMP] = ptr3[rind];
-         rgba[i][GCOMP] = ptr3[gind];
-         rgba[i][BCOMP] = ptr3[bind];
-         rgba[i][ACOMP] = 0;
+         const GLchan *p = PIXELADDR3(x[i], y[i]);
+         rgba[i][RCOMP] = UNPACK_RED(p);
+         rgba[i][GCOMP] = UNPACK_GREEN(p);
+         rgba[i][BCOMP] = UNPACK_BLUE(p);
+         rgba[i][ACOMP] = 255;
       }
    }
 }
@@ -1115,115 +1205,119 @@ static void read_rgba_pixels3( const GLcontext *ctx,
 /**********************************************************************/
 
 /* Write 32-bit color index to buffer */
-static void write_index32_span( const GLcontext *ctx,
-                                GLuint n, GLint x, GLint y,
-                                const GLuint index[], const GLubyte mask[] )
+static void
+write_index32_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    const GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    if (mask) {
       for (i=0;i<n;i++,ptr1++) {
          if (mask[i]) {
-            *ptr1 = (GLubyte) index[i];
+            *ptr1 = (GLchan) index[i];
          }
       }
    }
    else {
       for (i=0;i<n;i++,ptr1++) {
-         *ptr1 = (GLubyte) index[i];
+         *ptr1 = (GLchan) index[i];
       }
    }
 }
 
 
 /* Write 8-bit color index to buffer */
-static void write_index8_span( const GLcontext *ctx,
-                               GLuint n, GLint x, GLint y,
-                               const GLubyte index[], const GLubyte mask[] )
+static void
+write_index8_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                   const GLubyte index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    if (mask) {
       for (i=0;i<n;i++,ptr1++) {
          if (mask[i]) {
-            *ptr1 = (GLubyte) index[i];
+            *ptr1 = (GLchan) index[i];
          }
       }
    }
    else {
-      MEMCPY( ptr1, index, n );
+      MEMCPY(ptr1, index, n * sizeof(GLchan));
    }
 }
 
 
-static void write_monoindex_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  GLuint colorIndex, const GLubyte mask[] )
+static void
+write_monoindex_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      GLuint colorIndex, const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    for (i=0;i<n;i++,ptr1++) {
       if (mask[i]) {
-         *ptr1 = (GLubyte) colorIndex;
+         *ptr1 = (GLchan) colorIndex;
       }
    }
 }
 
 
-static void write_index_pixels( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-			        const GLuint index[], const GLubyte mask[] )
+static void
+write_index_pixels( const GLcontext *ctx,
+                    GLuint n, const GLint x[], const GLint y[],
+                    const GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i]) {
-         GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
-         *ptr1 = (GLubyte) index[i];
+         GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+         *ptr1 = (GLchan) index[i];
       }
    }
 }
 
 
-static void write_monoindex_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    GLuint colorIndex, const GLubyte mask[] )
+static void
+write_monoindex_pixels( const GLcontext *ctx,
+                        GLuint n, const GLint x[], const GLint y[],
+                        GLuint colorIndex, const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i]) {
-         GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
-         *ptr1 = (GLubyte) colorIndex;
+         GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+         *ptr1 = (GLchan) colorIndex;
       }
    }
 }
 
 
-static void read_index_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y, GLuint index[] )
+static void
+read_index_span( const GLcontext *ctx,
+                 GLuint n, GLint x, GLint y, GLuint index[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   const GLubyte *ptr1 = PIXELADDR1(x,y);
+   const GLchan *ptr1 = (const GLchan *) PIXELADDR1(x, y);
    for (i=0;i<n;i++,ptr1++) {
       index[i] = (GLuint) *ptr1;
    }
 }
 
 
-static void read_index_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLuint index[], const GLubyte mask[] )
+static void
+read_index_pixels( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i] ) {
-         const GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
+         const GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
          index[i] = (GLuint) *ptr1;
       }
    }
@@ -1239,16 +1333,19 @@ static void read_index_pixels( const GLcontext *ctx,
 /*
  * Draw a flat-shaded, RGB line into an osmesa buffer.
  */
-static void flat_rgba_line( GLcontext *ctx,
-                            const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_rgba_line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *color = (GLubyte*) vert0->color;
-   unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLchan *color = vert0->color;
 
 #define INTERP_XY 1
 #define CLIP_HACK 1
-#define PLOT(X,Y) { GLuint *ptr4 = PIXELADDR4(X,Y); *ptr4 = pixel; }
+#define PLOT(X, Y)						\
+do {								\
+   GLchan *p = PIXELADDR4(X, Y);				\
+   PACK_RGBA(p, color[0], color[1], color[2], color[3]);	\
+} while (0)
 
 #ifdef WIN32
 #include "..\swrast\s_linetemp.h"
@@ -1261,23 +1358,26 @@ static void flat_rgba_line( GLcontext *ctx,
 /*
  * Draw a flat-shaded, Z-less, RGB line into an osmesa buffer.
  */
-static void flat_rgba_z_line( GLcontext *ctx,
-			      const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_rgba_z_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLubyte *color = (GLubyte*) vert0->color;
-   unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLchan *color = vert0->color;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define CLIP_HACK 1
-#define PLOT(X,Y)				\
-	if (Z < *zPtr) {			\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);	\
-	   *ptr4 = pixel;			\
-	   *zPtr = Z;				\
-	}
+#define PLOT(X, Y)					\
+do {							\
+   if (Z < *zPtr) {					\
+      GLchan *p = PIXELADDR4(X, Y);			\
+      PACK_RGBA(p, color[RCOMP], color[GCOMP],		\
+                   color[BCOMP], color[ACOMP]);		\
+      *zPtr = Z;					\
+   }							\
+} while (0)
+
 
 #ifdef WIN32
 #include "..\swrast\s_linetemp.h"
@@ -1289,24 +1389,26 @@ static void flat_rgba_z_line( GLcontext *ctx,
 
 /*
  * Draw a flat-shaded, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_line( GLcontext *ctx,
-				  const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_line( GLcontext *ctx,
+                      const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = vert0->color[3];
-   GLint msavalue = 255 - avalue;
-   GLint rvalue = vert0->color[0]*avalue;
-   GLint gvalue = vert0->color[1]*avalue;
-   GLint bvalue = vert0->color[2]*avalue;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 255 - avalue;
+   const GLint rvalue = vert0->color[0]*avalue;
+   const GLint gvalue = vert0->color[1]*avalue;
+   const GLint bvalue = vert0->color[2]*avalue;
 
 #define INTERP_XY 1
 #define CLIP_HACK 1
 #define PLOT(X,Y)					\
-   { GLuint *ptr4 = PIXELADDR4(X,Y);			\
+   { GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);		\
      GLuint  pixel = 0;					\
      pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\
      pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\
@@ -1324,19 +1426,21 @@ static void flat_blend_rgba_line( GLcontext *ctx,
 
 /*
  * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_z_line( GLcontext *ctx,
-				    const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_z_line( GLcontext *ctx,
+                        const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = vert0->color[3];
-   GLint msavalue = 256 - avalue;
-   GLint rvalue = vert0->color[0]*avalue;
-   GLint gvalue = vert0->color[1]*avalue;
-   GLint bvalue = vert0->color[2]*avalue;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 256 - avalue;
+   const GLint rvalue = vert0->color[0]*avalue;
+   const GLint gvalue = vert0->color[1]*avalue;
+   const GLint bvalue = vert0->color[2]*avalue;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
@@ -1344,7 +1448,7 @@ static void flat_blend_rgba_z_line( GLcontext *ctx,
 #define CLIP_HACK 1
 #define PLOT(X,Y)							\
 	if (Z < *zPtr) {						\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);				\
+	   GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);			\
 	   GLuint  pixel = 0;						\
 	   pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);	\
 	   pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);	\
@@ -1362,19 +1466,21 @@ static void flat_blend_rgba_z_line( GLcontext *ctx,
 
 /*
  * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_z_line_write( GLcontext *ctx,
-					  const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_z_line_write( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = vert0->color[3];
-   GLint msavalue = 256 - avalue;
-   GLint rvalue = vert0->color[0]*avalue;
-   GLint gvalue = vert0->color[1]*avalue;
-   GLint bvalue = vert0->color[2]*avalue;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 256 - avalue;
+   const GLint rvalue = vert0->color[0]*avalue;
+   const GLint gvalue = vert0->color[1]*avalue;
+   const GLint bvalue = vert0->color[2]*avalue;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
@@ -1382,7 +1488,7 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx,
 #define CLIP_HACK 1
 #define PLOT(X,Y)							\
 	if (Z < *zPtr) {						\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);				\
+	   GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);			\
 	   GLuint  pixel = 0;						\
 	   pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);	\
 	   pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);	\
@@ -1406,97 +1512,65 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx,
 static swrast_line_func
 osmesa_choose_line_function( GLcontext *ctx )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
 
+   if (CHAN_BITS != 8)                    return NULL;
    if (ctx->RenderMode != GL_RENDER)      return NULL;
    if (ctx->Line.SmoothFlag)              return NULL;
    if (ctx->Texture._ReallyEnabled)       return NULL;
-   if (ctx->Light.ShadeModel!=GL_FLAT)    return NULL;
-
-   if (ctx->Line.Width==1.0F
-       && ctx->Line.StippleFlag==GL_FALSE) {
-
-       if (swrast->_RasterMask==DEPTH_BIT
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_TRUE
-           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_rgba_z_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==0) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_rgba_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_TRUE
-           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_z_line_write;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_FALSE
-           && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_z_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (swrast->_RasterMask==BLEND_BIT
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_line;
-       		default:
-       			return NULL;
-           }
-       }
+   if (ctx->Light.ShadeModel != GL_FLAT)  return NULL;
+   if (ctx->Line.Width != 1.0F)           return NULL;
+   if (ctx->Line.StippleFlag)             return NULL;
+   if (ctx->Line.SmoothFlag)              return NULL;
+   if (osmesa->format != OSMESA_RGBA &&
+       osmesa->format != OSMESA_BGRA &&
+       osmesa->format != OSMESA_ARGB)     return NULL;
+
+   if (swrast->_RasterMask==DEPTH_BIT
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
+      return flat_rgba_z_line;
+   }
+
+   if (swrast->_RasterMask == 0) {
+      return flat_rgba_line;
+   }
+
+   if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return flat_blend_rgba_z_line_write;
+   }
+
+   if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_FALSE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return flat_blend_rgba_z_line;
+   }
 
+   if (swrast->_RasterMask==BLEND_BIT
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return flat_blend_rgba_line;
    }
+
    return NULL;
 }
 
@@ -1514,11 +1588,7 @@ static void smooth_rgba_z_triangle( GLcontext *ctx,
                                     const SWvertex *v1,
                                     const SWvertex *v2 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
 
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
@@ -1527,13 +1597,13 @@ static void smooth_rgba_z_triangle( GLcontext *ctx,
 #define INNER_LOOP( LEFT, RIGHT, Y )				\
 {								\
    GLint i, len = RIGHT-LEFT;					\
-   GLuint *img = PIXELADDR4(LEFT,Y);   				\
-   (void) fffog;                        \
-   for (i=0;i<len;i++,img++) {					\
+   GLchan *img = PIXELADDR4(LEFT, Y); 				\
+   (void) fffog;                        			\
+   for (i = 0; i < len; i++, img += 4) {			\
       GLdepth z = FixedToDepth(ffz);				\
       if (z < zRow[i]) {					\
-         *img = PACK_RGBA2( FixedToInt(ffr), FixedToInt(ffg),	\
-		            FixedToInt(ffb), FixedToInt(ffa) );	\
+         PACK_RGBA(img, FixedToInt(ffr), FixedToInt(ffg),	\
+		        FixedToInt(ffb), FixedToInt(ffa));	\
          zRow[i] = z;						\
       }								\
       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;  ffa += fdadx;\
@@ -1558,29 +1628,27 @@ static void flat_rgba_z_triangle( GLcontext *ctx,
                                   const SWvertex *v1,
                                   const SWvertex *v2 )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE			\
-   GLubyte r = v0->color[0];		\
-   GLubyte g = v0->color[1];		\
-   GLubyte b = v0->color[2];		\
-   GLubyte a = v0->color[3];		\
-   GLuint pixel = PACK_RGBA(r,g,b,a);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )	\
-{					\
-   GLint i, len = RIGHT-LEFT;		\
-   GLuint *img = PIXELADDR4(LEFT,Y);   	\
-   (void) fffog;                        \
-   for (i=0;i<len;i++,img++) {		\
-      GLdepth z = FixedToDepth(ffz);	\
-      if (z < zRow[i]) {		\
-         *img = pixel;			\
-         zRow[i] = z;			\
-      }					\
-      ffz += fdzdx;			\
-   }					\
+#define SETUP_CODE						\
+   GLuint pixel;						\
+   PACK_RGBA((GLchan *) &pixel, v0->color[0], v0->color[1],	\
+                                v0->color[2], v0->color[3]);
+
+#define INNER_LOOP( LEFT, RIGHT, Y )			\
+{							\
+   GLint i, len = RIGHT-LEFT;				\
+   GLuint *img = (GLuint *) PIXELADDR4(LEFT, Y);   	\
+   (void) fffog;                        		\
+   for (i=0;i<len;i++) {				\
+      GLdepth z = FixedToDepth(ffz);			\
+      if (z < zRow[i]) {				\
+         img[i] = pixel;				\
+         zRow[i] = z;					\
+      }							\
+      ffz += fdzdx;					\
+   }							\
 }
 #ifdef WIN32
 #include "..\swrast\s_tritemp.h"
@@ -1597,32 +1665,34 @@ static void flat_rgba_z_triangle( GLcontext *ctx,
 static swrast_tri_func
 osmesa_choose_triangle_function( GLcontext *ctx )
 {
-   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
-   if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR))
-      return (swrast_tri_func)NULL;
-
-   if (ctx->RenderMode != GL_RENDER)  return (swrast_tri_func) NULL;
-   if (ctx->Polygon.SmoothFlag)       return (swrast_tri_func) NULL;
-   if (ctx->Polygon.StippleFlag)      return (swrast_tri_func) NULL;
-   if (ctx->Texture._ReallyEnabled)   return (swrast_tri_func) NULL;
-
-   if (swrast->_RasterMask==DEPTH_BIT
-       && ctx->Depth.Func==GL_LESS
-       && ctx->Depth.Mask==GL_TRUE
-       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-       && osmesa->format!=OSMESA_COLOR_INDEX) {
-      if (ctx->Light.ShadeModel==GL_SMOOTH) {
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (CHAN_BITS != 8)                  return (swrast_tri_func) NULL;
+   if (ctx->RenderMode != GL_RENDER)    return (swrast_tri_func) NULL;
+   if (ctx->Polygon.SmoothFlag)         return (swrast_tri_func) NULL;
+   if (ctx->Polygon.StippleFlag)        return (swrast_tri_func) NULL;
+   if (ctx->Texture._ReallyEnabled)     return (swrast_tri_func) NULL;
+   if (osmesa->format != OSMESA_RGBA &&
+       osmesa->format != OSMESA_BGRA &&
+       osmesa->format != OSMESA_ARGB)   return (swrast_tri_func) NULL;
+
+   if (swrast->_RasterMask == DEPTH_BIT &&
+       ctx->Depth.Func == GL_LESS &&
+       ctx->Depth.Mask == GL_TRUE &&
+       ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
          return smooth_rgba_z_triangle;
       }
       else {
          return flat_rgba_z_triangle;
       }
    }
-   return (swrast_tri_func)NULL;
+   return (swrast_tri_func) NULL;
 }
 
+
+
 /* Override for the swrast triangle-selection function.  Try to use one
  * of our internal triangle functions, otherwise fall back to the
  * standard swrast functions.
@@ -1694,14 +1764,17 @@ static void osmesa_update_state( GLcontext *ctx, GLuint new_state )
 
    ASSERT((void *) osmesa == (void *) ctx->DriverCtx);
 
+   /*
+    * XXX these function pointers could be initialized just once during
+    * context creation since they don't depend on any state changes.
+    */
+
    ctx->Driver.GetString = get_string;
    ctx->Driver.UpdateState = osmesa_update_state;
 
    ctx->Driver.SetDrawBuffer = set_draw_buffer;
    ctx->Driver.SetReadBuffer = set_read_buffer;
 
-   ctx->Driver.ClearIndex = clear_index;
-   ctx->Driver.ClearColor = clear_color;
    ctx->Driver.Clear = clear;
 
    ctx->Driver.GetBufferSize = buffer_size;
@@ -1716,32 +1789,41 @@ static void osmesa_update_state( GLcontext *ctx, GLuint new_state )
    ctx->Driver.RenderFinish = _swsetup_RenderFinish;
 
    /* RGB(A) span/pixel functions */
-   if ((osmesa->format==OSMESA_RGB) || (osmesa->format==OSMESA_BGR)) {
-      /* 3 bytes / pixel in frame buffer */
-      ctx->Driver.WriteRGBASpan = write_rgba_span3;
-      ctx->Driver.WriteRGBSpan = write_rgb_span3;
-      ctx->Driver.WriteRGBAPixels = write_rgba_pixels3;
-      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span3;
-      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels3;
+   if (osmesa->format == OSMESA_RGB) {
+      ctx->Driver.WriteRGBASpan = write_rgba_span_RGB;
+      ctx->Driver.WriteRGBSpan = write_rgb_span_RGB;
+      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_RGB;
+      ctx->Driver.WriteRGBAPixels = write_rgba_pixels_RGB;
+      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_RGB;
+      ctx->Driver.ReadRGBASpan = read_rgba_span3;
+      ctx->Driver.ReadRGBAPixels = read_rgba_pixels3;
+   }
+   else if (osmesa->format == OSMESA_BGR) {
+      ctx->Driver.WriteRGBASpan = write_rgba_span_BGR;
+      ctx->Driver.WriteRGBSpan = write_rgb_span_BGR;
+      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_BGR;
+      ctx->Driver.WriteRGBAPixels = write_rgba_pixels_BGR;
+      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_BGR;
       ctx->Driver.ReadRGBASpan = read_rgba_span3;
       ctx->Driver.ReadRGBAPixels = read_rgba_pixels3;
    }
    else {
       /* 4 bytes / pixel in frame buffer */
-      if (osmesa->format==OSMESA_RGBA
-          && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3)
-         ctx->Driver.WriteRGBASpan = write_rgba_span_rgba;
-      else
-         ctx->Driver.WriteRGBASpan = write_rgba_span;
       ctx->Driver.WriteRGBSpan = write_rgb_span;
       ctx->Driver.WriteRGBAPixels = write_rgba_pixels;
       ctx->Driver.WriteMonoRGBASpan = write_monocolor_span;
       ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels;
-      if (osmesa->format==OSMESA_RGBA
-          && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3)
+      if (osmesa->format == OSMESA_RGBA &&
+          CHAN_TYPE == GL_UNSIGNED_BYTE &&
+          RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) {
+         /* special, fast case */
+         ctx->Driver.WriteRGBASpan = write_rgba_span_rgba;
          ctx->Driver.ReadRGBASpan = read_rgba_span_rgba;
-      else
+      }
+      else {
+         ctx->Driver.WriteRGBASpan = write_rgba_span;
          ctx->Driver.ReadRGBASpan = read_rgba_span;
+      }
       ctx->Driver.ReadRGBAPixels = read_rgba_pixels;
    }
 
diff --git a/src/mesa/drivers/svga/svgamesa15.c b/src/mesa/drivers/svga/svgamesa15.c
index 3332503d2b8..0f8ebd330ba 100644
--- a/src/mesa/drivers/svga/svgamesa15.c
+++ b/src/mesa/drivers/svga/svgamesa15.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa15.c,v 1.7 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa15.c,v 1.8 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -54,11 +54,9 @@ static unsigned long __svga_getpixel15(int x, int y)
     return shortBuffer[offset];
 }
 
-void __clear_color15( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color15( GLcontext *ctx, const GLchan color[4] )
 {
-   SVGAMesa->clear_hicolor=(red>>3)<<10 | (green>>3)<<5 | (blue>>3);  
+   SVGAMesa->clear_hicolor=(color[0]>>3)<<10 | (color[1]>>3)<<5 | (color[2]>>3);  
 /*   SVGAMesa->clear_hicolor=(red)<<10 | (green)<<5 | (blue);*/
 }   
 
diff --git a/src/mesa/drivers/svga/svgamesa15.h b/src/mesa/drivers/svga/svgamesa15.h
index 83591a610fb..f2c16d9f833 100644
--- a/src/mesa/drivers/svga/svgamesa15.h
+++ b/src/mesa/drivers/svga/svgamesa15.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa15.h,v 1.4 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa15.h,v 1.5 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_15_H
 #define SVGA_MESA_15_H
 
-extern void __clear_color15( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color15( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear15( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span15( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span15( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/svga/svgamesa16.c b/src/mesa/drivers/svga/svgamesa16.c
index 02d1251665f..20d1ed6fecb 100644
--- a/src/mesa/drivers/svga/svgamesa16.c
+++ b/src/mesa/drivers/svga/svgamesa16.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa16.c,v 1.7 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa16.c,v 1.8 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -56,11 +56,11 @@ static unsigned long __svga_getpixel16(int x, int y)
     return shortBuffer[offset];
 }
 
-void __clear_color16( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color16( GLcontext *ctx, const GLchan color[4] )
 {
-    SVGAMesa->clear_hicolor=(red>>3)<<11 | (green>>2)<<5 | (blue>>3); 
+    SVGAMesa->clear_hicolor = (color[0] >> 3) << 11 |
+                              (color[1] >> 2) << 5 |
+                              (color[2] >> 3); 
 /*    SVGAMesa->clear_hicolor=(red)<<11 | (green)<<5 | (blue); */
 }   
 
diff --git a/src/mesa/drivers/svga/svgamesa16.h b/src/mesa/drivers/svga/svgamesa16.h
index 94ddcf3a195..f18d559cdb2 100644
--- a/src/mesa/drivers/svga/svgamesa16.h
+++ b/src/mesa/drivers/svga/svgamesa16.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa16.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa16.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_16_H
 #define SVGA_MESA_16_H
 
-extern void __clear_color16( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color16( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear16( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span16( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span16( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/svga/svgamesa24.c b/src/mesa/drivers/svga/svgamesa24.c
index aa174df4cc4..0d0c8e74c8f 100644
--- a/src/mesa/drivers/svga/svgamesa24.c
+++ b/src/mesa/drivers/svga/svgamesa24.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa24.c,v 1.8 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa24.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -78,13 +78,11 @@ static unsigned long __svga_getpixel24(int x, int y)
     return rgbBuffer[offset].r<<16 | rgbBuffer[offset].g<<8 | rgbBuffer[offset].b;
 }
 
-void __clear_color24( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color24( GLcontext *ctx, const GLchan color[4] )
 {
-   SVGAMesa->clear_red = red;
-   SVGAMesa->clear_green = green;
-   SVGAMesa->clear_blue = blue;
+   SVGAMesa->clear_red = color[0];
+   SVGAMesa->clear_green = color[1];
+   SVGAMesa->clear_blue = color[2];
 /*   SVGAMesa->clear_truecolor = red<<16 | green<<8 | blue; */
 }
 
diff --git a/src/mesa/drivers/svga/svgamesa24.h b/src/mesa/drivers/svga/svgamesa24.h
index dc9382034bb..9707e993c33 100644
--- a/src/mesa/drivers/svga/svgamesa24.h
+++ b/src/mesa/drivers/svga/svgamesa24.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa24.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa24.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_24_H
 #define SVGA_MESA_24_H
 
-extern void __clear_color24( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color24( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear24( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span24( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span24( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/svga/svgamesa32.c b/src/mesa/drivers/svga/svgamesa32.c
index a56afdc86ce..88907c49c8d 100644
--- a/src/mesa/drivers/svga/svgamesa32.c
+++ b/src/mesa/drivers/svga/svgamesa32.c
@@ -1,4 +1,4 @@
-/* $Id: svgamesa32.c,v 1.8 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa32.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -74,11 +74,9 @@ static unsigned long __svga_getpixel32(int x, int y)
     return intBuffer[offset];
 }
 
-void __clear_color32( GLcontext *ctx,
-                      GLubyte red, GLubyte green,
-                      GLubyte blue, GLubyte alpha )
+void __clear_color32( GLcontext *ctx, const GLchan color[4] )
 {
-   SVGAMesa->clear_truecolor = red<<16 | green<<8 | blue;
+   SVGAMesa->clear_truecolor = (color[0] << 16) | (color[1] << 8) | color[2];
 }
 
 GLbitfield __clear32( GLcontext *ctx, GLbitfield mask, GLboolean all,
diff --git a/src/mesa/drivers/svga/svgamesa32.h b/src/mesa/drivers/svga/svgamesa32.h
index 36406249721..d24b95a6cd9 100644
--- a/src/mesa/drivers/svga/svgamesa32.h
+++ b/src/mesa/drivers/svga/svgamesa32.h
@@ -1,4 +1,4 @@
-/* $Id: svgamesa32.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa32.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -31,7 +31,7 @@
 #ifndef SVGA_MESA_32_H
 #define SVGA_MESA_32_H
 
-extern void __clear_color32( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color32( GLcontext *ctx, const GLchan color[4] );
 extern GLbitfield __clear32( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
 extern void __write_rgba_span32( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
 extern void __write_mono_rgba_span32( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
diff --git a/src/mesa/drivers/windows/wmesa.c b/src/mesa/drivers/windows/wmesa.c
index b55142e8add..74fea18030e 100644
--- a/src/mesa/drivers/windows/wmesa.c
+++ b/src/mesa/drivers/windows/wmesa.c
@@ -1,4 +1,4 @@
-/* $Id: wmesa.c,v 1.12 2000/11/17 21:01:47 brianp Exp $ */
+/* $Id: wmesa.c,v 1.13 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Windows (Win32) device driver for Mesa 3.4
@@ -366,10 +366,10 @@ static void clear_index(GLcontext* ctx, GLuint index)
 /*
 * Set the color used to clear the color buffer.
 */
-static void clear_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+static void clear_color( GLcontext* ctx, const GLchan color[4] )
 {
     STARTPROFILE
-        Current->clearpixel=RGB(r, g, b );
+        Current->clearpixel = RGB(color[0], color[1], color[2]);
     ENDPROFILE(clear_color)
 }
 
diff --git a/src/mesa/drivers/windows/wmesa_stereo.c b/src/mesa/drivers/windows/wmesa_stereo.c
index d3787909ee9..b0b6f811ddc 100644
--- a/src/mesa/drivers/windows/wmesa_stereo.c
+++ b/src/mesa/drivers/windows/wmesa_stereo.c
@@ -152,10 +152,10 @@ static void clear_index(GLcontext* ctx, GLuint index)
 /*

  * Set the color used to clear the color buffer.

  */

-static void clear_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )

+static void clear_color( GLcontext* ctx, const GLchan color[4] )

 {

   STARTPROFILE

-  Current->clearpixel=RGB(r, g, b );

+  Current->clearpixel = RGB(color[0], color[1], color[2]);

   ENDPROFILE(clear_color)

 }

 

diff --git a/src/mesa/drivers/x11/xm_dd.c b/src/mesa/drivers/x11/xm_dd.c
index 77e4ab58c4c..d6444a51461 100644
--- a/src/mesa/drivers/x11/xm_dd.c
+++ b/src/mesa/drivers/x11/xm_dd.c
@@ -1,4 +1,4 @@
-/* $Id: xm_dd.c,v 1.10 2001/01/16 05:29:43 keithw Exp $ */
+/* $Id: xm_dd.c,v 1.11 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -229,14 +229,15 @@ clear_index( GLcontext *ctx, GLuint index )
 
 
 static void
-clear_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color( GLcontext *ctx, const GLchan color[4] )
 {
    const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
-   xmesa->clearpixel = xmesa_color_to_pixel( xmesa, r, g, b, a,
+   xmesa->clearcolor[0] = color[0];
+   xmesa->clearcolor[1] = color[1];
+   xmesa->clearcolor[2] = color[2];
+   xmesa->clearcolor[3] = color[3];
+   xmesa->clearpixel = xmesa_color_to_pixel( xmesa, color[0], color[1],
+                                             color[2], color[3],
                                              xmesa->xm_visual->undithered_pf );
    _glthread_LOCK_MUTEX(_xmesa_lock);
    XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
diff --git a/src/mesa/drivers/x11/xm_span.c b/src/mesa/drivers/x11/xm_span.c
index 00c36af44c2..623762f2057 100644
--- a/src/mesa/drivers/x11/xm_span.c
+++ b/src/mesa/drivers/x11/xm_span.c
@@ -1,4 +1,4 @@
-/* $Id: xm_span.c,v 1.5 2001/01/08 04:06:20 keithw Exp $ */
+/* $Id: xm_span.c,v 1.6 2001/01/24 00:04:59 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -4152,17 +4152,14 @@ static void read_color_pixels( const GLcontext *ctx,
 
 
 static void
-clear_color_HPCR_ximage( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color_HPCR_ximage( GLcontext *ctx, const GLchan color[4] )
 {
    int i;
    const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
 
-   if (r == 0 && g == 0 && b == 0) {
+   COPY_4V(xmesa->clearcolor, color);
+
+   if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
       /* black is black */
       MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
               sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
@@ -4171,27 +4168,23 @@ clear_color_HPCR_ximage( GLcontext *ctx,
       /* build clear pattern */
       for (i=0; i<16; i++) {
          xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i]    =
-            DITHER_HPCR(i, 0, r, g, b);
+            DITHER_HPCR(i, 0, color[0], color[1], color[2]);
          xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i]    =
-            DITHER_HPCR(i, 1, r, g, b);
+            DITHER_HPCR(i, 1, color[0], color[1], color[2]);
       }
    }
 }
 
 
 static void
-clear_color_HPCR_pixmap( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color_HPCR_pixmap( GLcontext *ctx, const GLchan color[4] )
 {
    int i;
    const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
 
+   COPY_4V(xmesa->clearcolor, color);
 
-   if (0x0==r && 0x0==g && 0x0==b) {
+   if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
       /* black is black */
       for (i=0; i<16; i++) {
          XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
@@ -4200,8 +4193,10 @@ clear_color_HPCR_pixmap( GLcontext *ctx,
    }
    else {
       for (i=0; i<16; i++) {
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, DITHER_HPCR(i, 0, r, g, b));
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, DITHER_HPCR(i, 1, r, g, b));
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
+                       DITHER_HPCR(i, 0, color[0], color[1], color[2]));
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
+                       DITHER_HPCR(i, 1, color[0], color[1], color[2]));
       }
    }
    /* change tile pixmap content */