first big check-in of new Mesa 3.3 code

1 files changed, 337 insertions, 1181 deletions

diff --git a/src/mesa/main/image.c b/src/mesa/main/image.c
index 582fa5c147e..87a5c4800a6 100644
--- a/src/mesa/main/image.c
+++ b/src/mesa/main/image.c
@@ -1,8 +1,8 @@
-/* $Id: image.c,v 1.13 1999/11/08 07:36:44 brianp Exp $ */
+/* $Id: image.c,v 1.14 1999/11/11 01:22:27 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
+ * Version:  3.3
  * 
  * Copyright (C) 1999  Brian Paul   All Rights Reserved.
  * 
@@ -25,20 +25,14 @@
  */
 
 
-
 #ifdef PC_HEADER
 #include "all.h"
 #else
-#ifndef XFree86Server
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#else
-#include "GL/xf86glx.h"
-#endif
+#include "glheader.h"
 #include "context.h"
 #include "image.h"
 #include "macros.h"
+#include "mem.h"
 #include "mmath.h"
 #include "pixel.h"
 #include "types.h"
@@ -47,6 +41,26 @@
 
 
 /*
+ * These are the image packing parameters for Mesa's internal images.
+ * That is, _mesa_unpack_image() returns image data in this format.
+ * When we execute image commands (glDrawPixels, glTexImage, etc)
+ * from within display lists we have to be sure to set the current
+ * unpacking params to these values!
+ */
+struct gl_pixelstore_attrib _mesa_native_packing = {
+   1,            /* Alignment */
+   0,            /* RowLength */
+   0,            /* SkipPixels */
+   0,            /* SkipRows */
+   0,            /* ImageHeight */
+   0,            /* SkipImages */
+   GL_FALSE,     /* SwapBytes */
+   GL_FALSE      /* LsbFirst */
+};
+
+
+
+/*
  * Flip the 8 bits in each byte of the given array.
  */
 void gl_flip_bytes( GLubyte *p, GLuint n )
@@ -207,7 +221,6 @@ GLint gl_components_in_format( GLenum format )
       case GL_BLUE:
       case GL_ALPHA:
       case GL_LUMINANCE:
-      case GL_INTENSITY:
          return 1;
       case GL_LUMINANCE_ALPHA:
 	 return 2;
@@ -477,441 +490,6 @@ GLvoid *gl_pixel_addr_in_image( const struct gl_pixelstore_attrib *packing,
 
 
 /*
- * Allocate a new gl_image.  All fields are initialized to zero.
- */
-static struct gl_image *alloc_image( void )
-{
-   return CALLOC_STRUCT(gl_image);
-}
-
-
-
-/*
- * Allocate a new gl_image with the error flag set.
- */
-static struct gl_image *alloc_error_image( GLint width, GLint height,
-                                           GLint depth, GLenum format,
-                                           GLenum type )
-{
-   struct gl_image *image = alloc_image();
-   if (image) {
-      image->Width = width;
-      image->Height = height;
-      image->Depth = depth;
-      image->Format = format;
-      image->Type = type;
-      image->ErrorFlag = GL_TRUE;
-   }
-   return image;
-}
-
-
-
-/*
- * Free a gl_image.
- */
-void gl_free_image( struct gl_image *image )
-{
-   if (image->Data) {
-      FREE(image->Data);
-   }
-   FREE(image);
-}
-
-
-
-/*
- * Do error checking on an image.  If there's an error, register it and
- * return GL_TRUE, else return GL_FALSE.
- */
-GLboolean gl_image_error_test( GLcontext *ctx, const struct gl_image *image,
-                               const char *msg )
-{
-   if (!image) {
-      gl_error( ctx, GL_OUT_OF_MEMORY, msg );        
-      return GL_TRUE;
-   }
-   if (image->Width <= 0 || image->Height <= 0 || image->Depth <= 0) {
-      gl_error( ctx, GL_INVALID_VALUE, msg );
-      return GL_TRUE;
-   }
-   else if (!gl_is_legal_format_and_type(image->Format, image->Type)) {
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-
-/*
- * Unpack a depth-buffer image storing values as GLshort, GLuint, or GLfloats.
- * Input:  type - datatype of src depth image
- * Return pointer to a new gl_image structure.
- *
- * Notes:  if the source image type is GLushort then the gl_image will
- * also store GLushorts.  If the src image type is GLuint then the gl_image
- * will also store GLuints.  For all other src image types the gl_image
- * will store GLfloats.  The integer cases can later be optimized.
- */
-static struct gl_image *
-unpack_depth_image( GLcontext *ctx, GLenum type, GLint width, GLint height,
-                    const GLvoid *pixels,
-                    const struct gl_pixelstore_attrib *packing)
-
-{
-   struct gl_image *image;
-   GLfloat *fDst;
-   GLushort *sDst;
-   GLuint *iDst;
-   GLint i, j;
-   GLboolean errorType;
-
-   errorType = type != GL_BYTE &&
-               type != GL_UNSIGNED_BYTE &&
-               type != GL_SHORT &&
-               type != GL_UNSIGNED_SHORT &&
-               type != GL_INT &&
-               type != GL_UNSIGNED_INT &&
-               type != GL_FLOAT;
-
-   image = alloc_image();
-   if (image) {
-      image->Width = width;
-      image->Height = height;
-      image->Depth = 1;
-      image->Components = 1;
-      image->Format = GL_DEPTH_COMPONENT;
-      if (errorType) {
-         image->Type = type;
-         image->Data = NULL;
-      }
-      if (type==GL_UNSIGNED_SHORT) {
-         image->Type = GL_UNSIGNED_SHORT;
-         image->Data = MALLOC( width * height * sizeof(GLushort));
-      }
-      else if (type==GL_UNSIGNED_INT) {
-         image->Type = GL_UNSIGNED_INT;
-         image->Data = MALLOC( width * height * sizeof(GLuint));
-      }
-      else {
-         image->Type = GL_FLOAT;
-         image->Data = MALLOC( width * height * sizeof(GLfloat));
-      }
-      image->RefCount = 0;
-      if (!image->Data)
-         return image;
-   }
-   else {
-      return NULL;
-   }
-
-   if (errorType)
-      return image;
-
-   fDst = (GLfloat *) image->Data;
-   sDst = (GLushort *) image->Data;
-   iDst = (GLuint *) image->Data;
-
-   for (i=0;i<height;i++) {
-      GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
-                                            width, height,
-                                            GL_DEPTH_COMPONENT, type,
-                                            0, i, 0 );
-      if (!src) {
-         return image;
-      }
-
-      switch (type) {
-         case GL_BYTE:
-            assert(image->Type == GL_FLOAT);
-            for (j=0; j<width; j++) {
-               *fDst++ = BYTE_TO_FLOAT(((GLbyte*)src)[j]);
-            }
-            break;
-         case GL_UNSIGNED_BYTE:
-            assert(image->Type == GL_FLOAT);
-            for (j=0; j<width; j++) {
-               *fDst++ = UBYTE_TO_FLOAT(((GLubyte*)src)[j]);
-            }
-            break;
-         case GL_UNSIGNED_SHORT:
-            assert(image->Type == GL_UNSIGNED_SHORT);
-            MEMCPY( sDst, src, width * sizeof(GLushort) );
-            if (packing->SwapBytes) {
-               gl_swap2( sDst, width );
-            }
-            sDst += width;
-            break;
-         case GL_SHORT:
-            assert(image->Type == GL_FLOAT);
-            if (packing->SwapBytes) {
-               for (j=0;j<width;j++) {
-                  GLshort value = ((GLshort*)src)[j];
-                  value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
-                  *fDst++ = SHORT_TO_FLOAT(value);
-               }
-            }
-            else {
-               for (j=0;j<width;j++) {
-                  *fDst++ = SHORT_TO_FLOAT(((GLshort*)src)[j]);
-               }
-            }
-            break;
-         case GL_INT:
-            assert(image->Type == GL_FLOAT);
-            if (packing->SwapBytes) {
-               for (j=0;j<width;j++) {
-                  GLint value = ((GLint*)src)[j];
-                  value = ((value >> 24) & 0x000000ff) |
-                          ((value >> 8)  & 0x0000ff00) |
-                          ((value << 8)  & 0x00ff0000) |
-                          ((value << 24) & 0xff000000);
-                  *fDst++ = INT_TO_FLOAT(value);
-               }
-            }
-            else {
-               for (j=0;j<width;j++) {
-                  *fDst++ = INT_TO_FLOAT(((GLint*)src)[j]);
-               }
-            }
-            iDst += width;
-            break;
-         case GL_UNSIGNED_INT:
-            assert(image->Type == GL_UNSIGNED_INT);
-            MEMCPY( iDst, src, width * sizeof(GLuint) );
-            if (packing->SwapBytes) {
-               gl_swap4( iDst, width );
-            }
-            iDst += width;
-            break;
-         case GL_FLOAT:
-            assert(image->Type == GL_FLOAT);
-            MEMCPY( fDst, src, width * sizeof(GLfloat) );
-            if (packing->SwapBytes) {
-               gl_swap4( (GLuint*) fDst, width );
-            }
-            fDst += width;
-            break;
-         default:
-            gl_problem(ctx, "unpack_depth_image type" );
-            return image;
-      }
-   }
-
-   return image;
-}
-
-
-
-/*
- * Unpack a stencil image.  Store as GLubytes in a gl_image structure.
- * Return:  pointer to new gl_image structure.
- */
-static struct gl_image *
-unpack_stencil_image( GLcontext *ctx, GLenum type, GLint width, GLint height,
-                      const GLvoid *pixels,
-                      const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_image *image;
-   GLubyte *dst;
-   GLint i, j;
-   GLboolean errorType;
-
-   assert(sizeof(GLstencil) == sizeof(GLubyte));
-
-   errorType = type != GL_BYTE &&
-               type != GL_UNSIGNED_BYTE &&
-               type != GL_SHORT &&
-               type != GL_UNSIGNED_SHORT &&
-               type != GL_INT &&
-               type != GL_UNSIGNED_INT &&
-               type != GL_FLOAT &&
-               type != GL_BITMAP;
-
-   image = alloc_image();
-   if (image) {
-      image->Width = width;
-      image->Height = height;
-      image->Depth = 1;
-      image->Components = 1;
-      image->Format = GL_STENCIL_INDEX;
-      if (errorType) {
-         image->Type = type;
-         image->Data = NULL;
-      }
-      else {
-         image->Type = GL_UNSIGNED_BYTE;
-         image->Data = MALLOC( width * height * sizeof(GLubyte));
-      }
-      image->RefCount = 0;
-      if (!image->Data)
-         return image;
-   }
-   else {
-      return NULL;
-   }
-
-   if (errorType)
-      return image; /* error will be generated later */
-
-   dst = (GLubyte *) image->Data;
-
-   for (i=0;i<height;i++) {
-      GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
-                                            width, height,
-                                            GL_STENCIL_INDEX, type,
-                                            0, i, 0 );
-      if (!src) {
-         return image;
-      }
-
-      switch (type) {
-         case GL_UNSIGNED_BYTE:
-         case GL_BYTE:
-            MEMCPY( dst, src, width * sizeof(GLubyte) );
-            dst += width * sizeof(GLubyte);
-            break;
-         case GL_UNSIGNED_SHORT:
-         case GL_SHORT:
-            if (packing->SwapBytes) {
-               /* grab upper byte */
-               for (j=0; j < width; j++) {
-                  *dst++ = (((GLushort*)src)[j] & 0xff00) >> 8;
-               }
-            }
-            else {
-               for (j=0; j < width; j++) {
-                  *dst++ = (((GLushort*)src)[j]) & 0xff;
-               }
-            }
-            break;
-         case GL_INT:
-            if (packing->SwapBytes) {
-               /* grab upper byte */
-               for (j=0; j < width; j++) {
-                  *dst++ = (((GLuint*)src)[j] & 0xff000000) >> 8;
-               }
-            }
-            else {
-               for (j=0; j < width; j++) {
-                  *dst++ = (((GLuint*)src)[j]) & 0xff;
-               }
-            }
-            break;
-         case GL_UNSIGNED_INT:
-            if (packing->SwapBytes) {
-               /* grab upper byte */
-               for (j=0; j < width; j++) {
-                  *dst++ = (((GLuint*)src)[j] & 0xff000000) >> 8;
-               }
-            }
-            else {
-               for (j=0; j < width; j++) {
-                  *dst++ = (((GLuint*)src)[j]) & 0xff;
-               }
-            }
-            break;
-         case GL_FLOAT:
-            if (packing->SwapBytes) {
-               for (j=0; j < width; j++) {
-                  GLfloat fvalue;
-                  GLint value = ((GLuint*)src)[j];
-                  value = ((value & 0xff000000) >> 24)
-                     | ((value & 0x00ff0000) >> 8)
-                     | ((value & 0x0000ff00) << 8)
-                     | ((value & 0x000000ff) << 24);
-                  fvalue = *((GLfloat*) &value);
-                  *dst++ = ((GLint) fvalue) & 0xff;
-               }
-            }
-            else {
-               for (j=0; j < width; j++) {
-                  GLfloat fvalue = ((GLfloat *)src)[j];
-                  *dst++ = ((GLint) fvalue) & 0xff;
-               }
-            }
-            break;
-         default:
-            gl_problem(ctx, "unpack_stencil_image type" );
-            return image;
-      }
-   }
-
-   return image;
-}
-
-
-
-/*
- * Unpack a bitmap, return a new gl_image struct.
- */
-static struct gl_image *
-unpack_bitmap( GLenum format, GLint width, GLint height,
-               const GLvoid *pixels,
-               const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_image *image;
-   GLint bytes, i, width_in_bytes;
-   GLubyte *buffer, *dst;
-
-   assert(format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX);
-
-   /* Alloc dest storage */
-   bytes = ((width+7)/8 * height);
-   if (bytes>0 && pixels!=NULL) {
-      buffer = (GLubyte *) MALLOC( bytes );
-      if (!buffer) {
-         return NULL;
-      }
-      /* Copy/unpack pixel data to buffer */
-      width_in_bytes = CEILING( width, 8 );
-      dst = buffer;
-      for (i=0; i<height; i++) {
-         GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
-                                               width, height,
-                                               GL_COLOR_INDEX, GL_BITMAP,
-                                               0, i, 0 );
-         if (!src) {
-            FREE(buffer);
-            return NULL;
-         }
-         MEMCPY( dst, src, width_in_bytes );
-         dst += width_in_bytes;
-      }
-      /* Bit flipping */
-      if (packing->LsbFirst) {
-         gl_flip_bytes( buffer, bytes );
-      }
-   }
-   else {
-      /* a 'null' bitmap */
-      buffer = NULL;
-   }
-   
-   image = alloc_image();
-   if (image) {
-      image->Width = width;
-      image->Height = height;
-      image->Depth = 1;
-      image->Components = 0;
-      image->Format = format;
-      image->Type = GL_BITMAP;
-      image->Data = buffer;
-      image->RefCount = 0;
-   }
-   else {
-      FREE( buffer );
-      return NULL;
-   }
-
-   return image;
-}
-
-
-
-/*
  * Unpack a 32x32 pixel polygon stipple from user memory using the
  * current pixel unpack settings.
  */
@@ -963,701 +541,6 @@ void gl_pack_polygon_stipple( const GLcontext *ctx,
 
 
 /*
- * Unpack an RGBA or CI image and store it as unsigned bytes
- */
-static struct gl_image *
-unpack_ubyte_image( GLint width, GLint height,
-                    GLint depth, GLenum format, const GLvoid *pixels,
-                    const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_image *image;
-   GLint width_in_bytes;
-   GLint components;
-   GLubyte *buffer, *dst;
-   GLint i, d;
-
-   components = gl_components_in_format( format );
-
-   width_in_bytes = width * components * sizeof(GLubyte);
-   buffer = (GLubyte *) MALLOC( height * width_in_bytes * depth );
-   if (!buffer) {
-      return NULL;
-   }
-
-   /* Copy/unpack pixel data to buffer */
-   dst = buffer;
-   for (d=0; d<depth; d++ ) {
-      for (i=0;i<height;i++) {
-         GLubyte *src = (GLubyte *) gl_pixel_addr_in_image( packing,
-                       pixels, width, height, format, GL_UNSIGNED_BYTE,
-                       d, i, 0 );
-         if (!src) {
-            FREE(buffer);
-            return NULL;
-         }
-         MEMCPY( dst, src, width_in_bytes );
-         dst += width_in_bytes;
-      }
-   }
-   
-   if (format == GL_BGR) {
-      /* swap order of every ubyte triplet from BGR to RGB */
-      for (i=0; i<width*height; i++) {
-         GLubyte b = buffer[i*3+0];
-         GLubyte r = buffer[i*3+2];
-         buffer[i*3+0] = r;
-         buffer[i*3+2] = b;
-      }
-   }
-   else if (format == GL_BGRA) {
-      /* swap order of every ubyte quadruplet from BGRA to RGBA */
-      for (i=0; i<width*height; i++) {
-         GLubyte b = buffer[i*4+0];
-         GLubyte r = buffer[i*4+2];
-         buffer[i*4+0] = r;
-         buffer[i*4+2] = b;
-      }
-   }
-   else if (format == GL_ABGR_EXT) {
-      /* swap order of every ubyte quadruplet from ABGR to RGBA */
-      for (i=0; i<width*height; i++) {
-         GLubyte a = buffer[i*4+0];
-         GLubyte b = buffer[i*4+1];
-         GLubyte g = buffer[i*4+2];
-         GLubyte r = buffer[i*4+3];
-         buffer[i*4+0] = r;
-         buffer[i*4+1] = g;
-         buffer[i*4+2] = b;
-         buffer[i*4+3] = a;
-      }
-   }
-
-
-   image = alloc_image();
-   if (image) {
-      image->Width = width;
-      image->Height = height;
-      image->Depth = depth;
-      image->Components = components;
-      if (format == GL_BGR)
-         image->Format = GL_RGB;
-      else if (format == GL_BGRA)
-         image->Format = GL_RGBA;
-      else if (format == GL_ABGR_EXT)
-         image->Format = GL_RGBA;
-      else
-         image->Format = format;
-      image->Type = GL_UNSIGNED_BYTE;
-      image->Data = buffer;
-      image->RefCount = 0;
-   }
-   else {
-      FREE( buffer );
-   }
-
-   return image;
-}
-
-
-
-/*
- * Unpack a color image storing image as GLfloats
- */
-static struct gl_image *
-unpack_float_image( GLcontext *ctx, GLint width, GLint height, GLint depth,
-                    GLenum format, GLenum type, const GLvoid *pixels,
-                    const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_image *image;
-   GLfloat *dst;
-   GLint elems_per_row;
-   GLint components;
-   GLint i, j, d;
-   GLboolean normalize;
-
-   assert(type != GL_BITMAP);
-
-   components = gl_components_in_format( format );
-   assert(components > 0);  /* should have been caught earlier */
-
-   if (!gl_is_legal_format_and_type( format, type )) {
-      /* bad pixel type for format, make dummy image */
-      image = alloc_image();
-      if (image) {
-         image->Width = width;
-         image->Height = height;
-         image->Depth = depth;
-         image->Components = components;
-         image->Format = format;
-         image->Type = type;
-         image->Data = NULL;
-         image->RefCount = 0;
-      }
-      return image;
-   }
-
-   elems_per_row = width * components;
-
-   image = alloc_image();
-   if (image) {
-      image->Width = width;
-      image->Height = height;
-      image->Depth = depth;
-      image->Components = components;
-      if (format == GL_BGR)
-         image->Format = GL_RGB;
-      else if (format == GL_BGRA)
-         image->Format = GL_RGBA;
-      else if (format == GL_ABGR_EXT)
-         image->Format = GL_RGBA;
-      else
-         image->Format = format;
-      image->Type = GL_FLOAT;
-      image->Data = MALLOC( elems_per_row * height * depth * sizeof(GLfloat));
-      image->RefCount = 0;
-      if (!image->Data)
-         return image;
-   }
-   else {
-      return NULL;
-   }
-
-   normalize = (format != GL_COLOR_INDEX) && (format != GL_STENCIL_INDEX);
-
-   dst = (GLfloat *) image->Data;
-
-   for (d=0; d<depth; d++) {
-      for (i=0;i<height;i++) {
-         GLvoid *src = gl_pixel_addr_in_image( packing, pixels,
-                                               width, height,
-                                               format, type,
-                                               d, i, 0 );
-         if (!src) {
-            return image;
-         }
-
-         switch (type) {
-            case GL_UNSIGNED_BYTE:
-               {
-                  GLubyte *ubsrc = (GLubyte *) src;
-                  if (normalize) {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = UBYTE_TO_FLOAT(ubsrc[j]);
-                     }
-                  }
-                  else {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = (GLfloat) ubsrc[j];
-                     }
-                  }
-               }
-               break;
-            case GL_BYTE:
-               if (normalize) {
-                  for (j=0;j<elems_per_row;j++) {
-                     *dst++ = BYTE_TO_FLOAT(((GLbyte*)src)[j]);
-                  }
-               }
-               else {
-                  for (j=0;j<elems_per_row;j++) {
-                     *dst++ = (GLfloat) ((GLbyte*)src)[j];
-                  }
-               }
-               break;
-            case GL_UNSIGNED_SHORT:
-               if (packing->SwapBytes) {
-                  for (j=0;j<elems_per_row;j++) {
-                     GLushort value = ((GLushort*)src)[j];
-                     value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
-                     if (normalize) {
-                        *dst++ = USHORT_TO_FLOAT(value);
-                     }
-                     else {
-                        *dst++ = (GLfloat) value;
-                     }
-                  }
-               }
-               else {
-                  if (normalize) {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = USHORT_TO_FLOAT(((GLushort*)src)[j]);
-                     }
-                  }
-                  else {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = (GLfloat) ((GLushort*)src)[j];
-                     }
-                  }
-               }
-               break;
-            case GL_SHORT:
-               if (packing->SwapBytes) {
-                  for (j=0;j<elems_per_row;j++) {
-                     GLshort value = ((GLshort*)src)[j];
-                     value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
-                     if (normalize) {
-                        *dst++ = SHORT_TO_FLOAT(value);
-                     }
-                     else {
-                        *dst++ = (GLfloat) value;
-                     }
-                  }
-               }
-               else {
-                  if (normalize) {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = SHORT_TO_FLOAT(((GLshort*)src)[j]);
-                     }
-                  }
-                  else {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = (GLfloat) ((GLshort*)src)[j];
-                     }
-                  }
-               }
-               break;
-            case GL_UNSIGNED_INT:
-               if (packing->SwapBytes) {
-                  GLuint value;
-                  for (j=0;j<elems_per_row;j++) {
-                     value = ((GLuint*)src)[j];
-                     value = ((value & 0xff000000) >> 24)
-                           | ((value & 0x00ff0000) >> 8)
-                           | ((value & 0x0000ff00) << 8)
-                           | ((value & 0x000000ff) << 24);
-                     if (normalize) {
-                        *dst++ = UINT_TO_FLOAT(value);
-                     }
-                     else {
-                        *dst++ = (GLfloat) value;
-                     }
-                  }
-               }
-               else {
-                  if (normalize) {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = UINT_TO_FLOAT(((GLuint*)src)[j]);
-                     }
-                  }
-                  else {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = (GLfloat) ((GLuint*)src)[j];
-                     }
-                  }
-               }
-               break;
-            case GL_INT:
-               if (packing->SwapBytes) {
-                  GLint value;
-                  for (j=0;j<elems_per_row;j++) {
-                     value = ((GLint*)src)[j];
-                     value = ((value & 0xff000000) >> 24)
-                           | ((value & 0x00ff0000) >> 8)
-                           | ((value & 0x0000ff00) << 8)
-                           | ((value & 0x000000ff) << 24);
-                     if (normalize) {
-                        *dst++ = INT_TO_FLOAT(value);
-                     }
-                     else {
-                        *dst++ = (GLfloat) value;
-                     }
-                  }
-               }
-               else {
-                  if (normalize) {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = INT_TO_FLOAT(((GLint*)src)[j]);
-                     }
-                  }
-                  else {
-                     for (j=0;j<elems_per_row;j++) {
-                        *dst++ = (GLfloat) ((GLint*)src)[j];
-                     }
-                  }
-               }
-               break;
-            case GL_FLOAT:
-               if (packing->SwapBytes) {
-                  GLint value;
-                  for (j=0;j<elems_per_row;j++) {
-                     value = ((GLuint*)src)[j];
-                     value = ((value & 0xff000000) >> 24)
-                           | ((value & 0x00ff0000) >> 8)
-                           | ((value & 0x0000ff00) << 8)
-                           | ((value & 0x000000ff) << 24);
-                     *dst++ = *((GLfloat*) &value);
-                  }
-               }
-               else {
-                  MEMCPY( dst, src, elems_per_row*sizeof(GLfloat) );
-                  dst += elems_per_row;
-               }
-               break;
-            case GL_UNSIGNED_BYTE_3_3_2:
-               {
-                  GLubyte *ubsrc = (GLubyte *) src;
-                  for (j=0;j<width;j++) {
-                     GLubyte p = ubsrc[j];
-                     *dst++ = ((p >> 5)      ) * (1.0F / 7.0F); /* red */
-                     *dst++ = ((p >> 2) & 0x7) * (1.0F / 7.0F); /* green */
-                     *dst++ = ((p     ) & 0x3) * (1.0F / 3.0F); /* blue */
-                  }
-               }
-               break;
-            case GL_UNSIGNED_BYTE_2_3_3_REV:
-               {
-                  GLubyte *ubsrc = (GLubyte *) src;
-                  for (j=0;j<width;j++) {
-                     GLubyte p = ubsrc[j];
-                     *dst++ = ((p     ) & 0x7) * (1.0F / 7.0F); /* red */
-                     *dst++ = ((p >> 3) & 0x7) * (1.0F / 7.0F); /* green */
-                     *dst++ = ((p >> 6)      ) * (1.0F / 3.0F); /* blue */
-                  }
-               }
-               break;
-            case GL_UNSIGNED_SHORT_5_6_5:
-               {
-                  GLushort *ussrc = (GLushort *) src;
-                  for (j=0;j<width;j++) {
-                     GLushort p = ussrc[j];
-                     *dst++ = ((p >> 11)       ) * (1.0F / 31.0F); /* red */
-                     *dst++ = ((p >>  5) & 0x3f) * (1.0F / 63.0F); /* green */
-                     *dst++ = ((p      ) & 0x1f) * (1.0F / 31.0F); /* blue */
-                  }
-               }
-               break;
-            case GL_UNSIGNED_SHORT_5_6_5_REV:
-               {
-                  GLushort *ussrc = (GLushort *) src;
-                  for (j=0;j<width;j++) {
-                     GLushort p = ussrc[j];
-                     *dst++ = ((p      ) & 0x1f) * (1.0F / 31.0F); /* red */
-                     *dst++ = ((p >>  5) & 0x3f) * (1.0F / 63.0F); /* green */
-                     *dst++ = ((p >> 11)       ) * (1.0F / 31.0F); /* blue */
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4:
-               {
-                  GLushort *ussrc = (GLushort *) src;
-                  for (j=0;j<width;j++) {
-                     GLushort p = ussrc[j];
-                     *dst++ = ((p >> 12)      ) * (1.0F / 15.0F); /* red */
-                     *dst++ = ((p >>  8) & 0xf) * (1.0F / 15.0F); /* green */
-                     *dst++ = ((p >>  4) & 0xf) * (1.0F / 15.0F); /* blue */
-                     *dst++ = ((p      ) & 0xf) * (1.0F / 15.0F); /* alpha */
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-               {
-                  GLushort *ussrc = (GLushort *) src;
-                  for (j=0;j<width;j++) {
-                     GLushort p = ussrc[j];
-                     *dst++ = ((p      ) & 0xf) * (1.0F / 15.0F); /* red */
-                     *dst++ = ((p >>  4) & 0xf) * (1.0F / 15.0F); /* green */
-                     *dst++ = ((p >>  8) & 0xf) * (1.0F / 15.0F); /* blue */
-                     *dst++ = ((p >> 12)      ) * (1.0F / 15.0F); /* alpha */
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_SHORT_5_5_5_1:
-               {
-                  GLushort *ussrc = (GLushort *) src;
-                  for (j=0;j<width;j++) {
-                     GLushort p = ussrc[j];
-                     *dst++ = ((p >> 11)       ) * (1.0F / 31.0F); /* red */
-                     *dst++ = ((p >>  6) & 0x1f) * (1.0F / 31.0F); /* green */
-                     *dst++ = ((p >>  1) & 0x1f) * (1.0F / 31.0F); /* blue */
-                     *dst++ = ((p      ) & 0x1)  * (1.0F /  1.0F); /* alpha */
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-               {
-                  GLushort *ussrc = (GLushort *) src;
-                  for (j=0;j<width;j++) {
-                     GLushort p = ussrc[j];
-                     *dst++ = ((p      ) & 0x1f) * (1.0F / 31.0F); /* red */
-                     *dst++ = ((p >>  5) & 0x1f) * (1.0F / 31.0F); /* green */
-                     *dst++ = ((p >> 10) & 0x1f) * (1.0F / 31.0F); /* blue */
-                     *dst++ = ((p >> 15)       ) * (1.0F /  1.0F); /* alpha */
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_INT_8_8_8_8:
-               {
-                  GLuint *uisrc = (GLuint *) src;
-                  for (j=0;j<width;j++) {
-                     GLuint p = uisrc[j];
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_INT_8_8_8_8_REV:
-               {
-                  GLuint *uisrc = (GLuint *) src;
-                  for (j=0;j<width;j++) {
-                     GLuint p = uisrc[j];
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
-                     *dst++ = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       ); 
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_INT_10_10_10_2:
-               {
-                  GLuint *uisrc = (GLuint *) src;
-                  for (j=0;j<width;j++) {
-                     GLuint p = uisrc[j];
-                     *dst++ = ((p >> 22)        ) * (1.0F / 1023.0F); /* r */
-                     *dst++ = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); /* g */
-                     *dst++ = ((p >>  2) & 0x3ff) * (1.0F / 1023.0F); /* b */
-                     *dst++ = ((p      ) & 0x3  ) * (1.0F /    3.0F); /* a */
-                  }
-               }
-               break;
-	    case GL_UNSIGNED_INT_2_10_10_10_REV:
-               {
-                  GLuint *uisrc = (GLuint *) src;
-                  for (j=0;j<width;j++) {
-                     GLuint p = uisrc[j];
-                     *dst++ = ((p      ) & 0x3ff) * (1.0F / 1023.0F); /* r*/
-                     *dst++ = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F); /* g */
-                     *dst++ = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F); /* b */
-                     *dst++ = ((p >> 30)        ) * (1.0F /    3.0F); /* a */
-                  }
-               }
-               break;
-            default:
-               gl_problem(ctx, "unpack_float_image type" );
-               return image;
-         }
-      }
-   }
-
-   if (format == GL_BGR) {
-      /* swap order of every float triplet from BGR to RGBA */
-      GLfloat *buffer = (GLfloat *) image->Data;
-      for (i=0; i<width*height*depth; i++) {
-         GLfloat b = buffer[i*3+0];
-         GLfloat r = buffer[i*3+2];
-         buffer[i*3+0] = r;
-         buffer[i*3+2] = b;
-      }
-   }
-   else if (format == GL_BGRA) {
-      /* swap order of every float quadruplet from BGRA to RGBA */
-      GLfloat *buffer = (GLfloat *) image->Data;
-      for (i=0; i<width*height*depth; i++) {
-         GLfloat b = buffer[i*4+0];
-         GLfloat r = buffer[i*4+2];
-         buffer[i*4+0] = r;
-         buffer[i*4+2] = b;
-      }
-   }
-   else if (format == GL_ABGR_EXT) {
-      /* swap order of every float quadruplet from ABGR to RGBA */
-      GLfloat *buffer = (GLfloat *) image->Data;
-      for (i=0; i<width*height*depth; i++) {
-         GLfloat a = buffer[i*4+0];
-         GLfloat b = buffer[i*4+1];
-         GLfloat g = buffer[i*4+2];
-         GLfloat r = buffer[i*4+3];
-         buffer[i*4+0] = r;
-         buffer[i*4+1] = g;
-         buffer[i*4+2] = b;
-         buffer[i*4+3] = a;
-      }
-   }
-
-   return image;
-}
-
-
-
-/*
- * Unpack a bitmap image, using current glPixelStore parameters,
- * making a new gl_image.
- */
-struct gl_image *gl_unpack_bitmap( GLcontext *ctx,
-                                   GLsizei width, GLsizei height,
-                                   const GLubyte *bitmap,
-                                   const struct gl_pixelstore_attrib *packing )
-{
-   return gl_unpack_image( ctx, width, height,
-                           GL_COLOR_INDEX, GL_BITMAP, bitmap, packing );
-}
-
-
-
-/*
- * Unpack a 2-D image from user's buffer.  Return pointer to new
- * gl_image struct.
- *
- * Input:  width, height - size in pixels
- *         format - format of incoming pixel data
- *         type - datatype of incoming pixel data
- *         pixels - pointer to unpacked image in user buffer
- */
-struct gl_image *gl_unpack_image( GLcontext *ctx,
-                                  GLint width, GLint height,
-                                  GLenum format, GLenum type,
-                                  const GLvoid *pixels,
-                                  const struct gl_pixelstore_attrib *packing )
-{ 
-   return gl_unpack_image3D( ctx, width, height, 1,
-                             format, type, pixels, packing );
-}
-
-
-
-/* 
- * Unpack a 1, 2 or 3-D image from user-supplied address, returning a
- * pointer to a new gl_image struct.
- * This function is always called by a higher-level unpack function such
- * as gl_unpack_texsubimage() or gl_unpack_bitmap().
- *
- * Input:  width, height, depth - size in pixels
- *         format - format of incoming pixel data
- *         type - datatype of incoming pixel data
- *         pixels - pointer to unpacked image.
- */
-struct gl_image *gl_unpack_image3D( GLcontext *ctx,
-                                    GLint width, GLint height, GLint depth,
-                                    GLenum format, GLenum type,
-                                    const GLvoid *pixels,
-                                    const struct gl_pixelstore_attrib *packing)
-{
-   if (width <= 0 || height <= 0 || depth <= 0) {
-      return alloc_error_image(width, height, depth, format, type);
-   }
-
-   if (type==GL_BITMAP) {
-      if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
-         return alloc_error_image(width, height, depth, format, type);
-      }
-      else {
-         return unpack_bitmap( format, width, height, pixels, packing );
-      }
-   }
-   else if (format==GL_DEPTH_COMPONENT) {
-      /* TODO: pack as GLdepth values (GLushort or GLuint) */
-      return unpack_depth_image( ctx, type, width, height, pixels, packing );
-   }
-   else if (format==GL_STENCIL_INDEX) {
-      /* TODO: pack as GLstencil (GLubyte or GLushort) */
-      return unpack_stencil_image( ctx, type, width, height, pixels, packing );
-   }
-   else if (type==GL_UNSIGNED_BYTE) {
-      /* upack, convert to GLubytes */
-      return unpack_ubyte_image( width, height, depth, format, pixels, packing );
-   }
-   else {
-      /* upack, convert to floats */
-      return unpack_float_image( ctx, width, height, depth,
-                                 format, type, pixels, packing );
-   }
-
-   /* never get here */
-   /*return NULL;*/
-}
-
-
-/*
- * Apply pixel-transfer operations (scale, bias, mapping) to a single row
- * of a gl_image.  Put resulting color components into result array.
- */
-void gl_scale_bias_map_image_data( const GLcontext *ctx,
-                                   const struct gl_image *image,
-                                   GLint row, GLubyte result[] )
-{
-   GLint start, i;
-
-   assert(ctx);
-   assert(image);
-   assert(result);
-   assert(row >= 0);
-
-   start = row * image->Width * image->Components;
-
-   for (i=0; i < image->Width; i++) {
-      GLint pos = start+i;
-      GLfloat red, green, blue, alpha;
-      if (image->Type == GL_UNSIGNED_BYTE) {
-         const GLubyte *data = (GLubyte *) image->Data;
-         switch (image->Format) {
-            case GL_RED:
-               red   = data[pos] * (1.0F/255.0F);
-               green = 0;
-               blue  = 0;
-               alpha = 0;
-               break;
-            case GL_RGB:
-               red   = data[pos*3+0] * (1.0F/255.0F);
-               green = data[pos*3+1] * (1.0F/255.0F);
-               blue  = data[pos*3+2] * (1.0F/255.0F);
-               alpha = 0;
-               break;
-            default:
-               gl_problem(ctx, "bad image format in gl_scale...image_data");
-               return;
-         }
-      }
-      else if (image->Type == GL_FLOAT) {
-         const GLubyte *data = (GLubyte *) image->Data;
-         switch (image->Format) {
-            case GL_RED:
-               red   = data[pos];
-               green = 0;
-               blue  = 0;
-               alpha = 0;
-               break;
-            case GL_RGB:
-               red   = data[pos*3+0];
-               green = data[pos*3+1];
-               blue  = data[pos*3+2];
-               alpha = 0;
-               break;
-            default:
-               gl_problem(ctx, "bad image format in gl_scale...image_data");
-               return;
-         }
-      }
-      else {
-         gl_problem(ctx, "Bad image type in gl_scale_...image_data");
-         return;
-      }
-
-      assert(red   >= 0.0 && red   <= 1.0);
-      assert(green >= 0.0 && green <= 1.0);
-      assert(blue  >= 0.0 && blue  <= 1.0);
-      assert(alpha >= 0.0 && alpha <= 1.0);
-
-      /*
-      if (scale or bias) {
-
-
-      }
-      if (mapping) {
-
-      }
-      */
-
-      result[i*4+0] = (GLubyte) (red   * 255.0);
-      result[i*4+1] = (GLubyte) (green * 255.0);
-      result[i*4+2] = (GLubyte) (blue  * 255.0);
-      result[i*4+3] = (GLubyte) (alpha * 255.0);
-   }
-}
-
-
-
-/*
  * Pack the given RGBA span into client memory at 'dest' address
  * in the given pixel format and type.
  * Optionally apply the enabled pixel transfer ops.
@@ -1678,14 +561,14 @@ void gl_pack_rgba_span( const GLcontext *ctx,
                         const struct gl_pixelstore_attrib *packing,
                         GLboolean applyTransferOps )
 {
+   applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA || ctx->Pixel.MapColorFlag);
+
    /* Test for optimized case first */
-   if (!ctx->Pixel.ScaleOrBiasRGBA && !ctx->Pixel.MapColorFlag &&
-       format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
+   if (!applyTransferOps && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
       /* common simple case */
       MEMCPY( destination, rgba, n * 4 * sizeof(GLubyte) );
    }
-   else if (!ctx->Pixel.ScaleOrBiasRGBA && !ctx->Pixel.MapColorFlag &&
-       format == GL_RGB && type == GL_UNSIGNED_BYTE) {
+   else if (!applyTransferOps && format == GL_RGB && type == GL_UNSIGNED_BYTE) {
       /* common simple case */
       GLint i;
       GLubyte *dest = (GLubyte *) destination;
@@ -1697,6 +580,7 @@ void gl_pack_rgba_span( const GLcontext *ctx,
       }
    }
    else {
+      /* general solution */
       GLfloat red[MAX_WIDTH], green[MAX_WIDTH], blue[MAX_WIDTH];
       GLfloat alpha[MAX_WIDTH], luminance[MAX_WIDTH];
       const GLfloat rscale = 1.0F / 255.0F;
@@ -2470,11 +1354,6 @@ void gl_pack_rgba_span( const GLcontext *ctx,
 }
 
 
-
-/*
- * New (3.3) functions
- */
-
 #define SWAP2BYTE(VALUE)			\
    {						\
       GLubyte *bytes = (GLubyte *) &(VALUE);	\
@@ -2679,16 +1558,6 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4],
    GLint stride;
    GLint rComp, bComp, gComp, aComp;
 
-   if (0)
-   {
-      int i;
-      for (i = 0; i<n;i++) {
-         rgba[i][0] = rgba[i][1] = rgba[i][2] = rgba[i][3] = 0;
-      }
-      return;
-   }
-
-
    ASSERT(srcFormat == GL_RED ||
           srcFormat == GL_GREEN ||
           srcFormat == GL_BLUE ||
@@ -2710,17 +1579,10 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4],
           srcType == GL_INT ||
           srcType == GL_FLOAT ||
           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+          srcType == GL_UNSIGNED_INT_10_10_10_2);
 
    switch (srcFormat) {
       case GL_RED:
@@ -2810,10 +1672,6 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4],
          return;
    }
 
-   assert(redIndex >= -1 && redIndex <= 4);
-   assert(greenIndex >= -1 && greenIndex <= 4);
-   assert(blueIndex >= -1 && blueIndex <= 4);
-   assert(alphaIndex >= -1 && alphaIndex <= 4);
 
 #define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION)		\
    if ((INDEX) < 0) {							\
@@ -3228,22 +2086,16 @@ _mesa_unpack_ubyte_color_span( const GLcontext *ctx,
           srcType == GL_INT ||
           srcType == GL_FLOAT ||
           srcType == GL_UNSIGNED_BYTE_3_3_2 ||
-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
           srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
           srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
           srcType == GL_UNSIGNED_INT_8_8_8_8 ||
-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+          srcType == GL_UNSIGNED_INT_10_10_10_2);
 
    /* this is intended for RGBA mode */
-   ASSERT(ctx->Visual->RGBAflag);
+   assert(ctx->Visual->RGBAflag);
 
    applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA ||
+                        ctx->Pixel.MapColorFlag ||
                         ctx->Pixel.MapColorFlag);
 
    /* Try simple cases first */
@@ -3426,6 +2278,7 @@ _mesa_unpack_ubyte_color_span( const GLcontext *ctx,
 
 
       /* Now return the GLubyte data in the requested dstFormat */
+
       if (dstRedIndex >= 0) {
          GLubyte *dst = dest;
          GLuint i;
@@ -3589,6 +2442,206 @@ _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
 
 
 /*
+ * Unpack a row of stencil data from a client buffer according to
+ * the pixel unpacking parameters.  Apply pixel transfer ops if enabled
+ * and applyTransferOps is true.
+ * This is (or will be) used by glDrawPixels
+ *
+ * Args:  ctx - the context
+ *        n - number of pixels
+ *        dstType - destination datatype
+ *        dest - destination array
+ *        srcType - source pixel type
+ *        source - source data pointer
+ *        unpacking - pixel unpacking parameters
+ *        applyTransferOps - apply offset/bias/lookup ops?
+ */
+void
+_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
+                           GLenum dstType, GLvoid *dest,
+                           GLenum srcType, const GLvoid *source,
+                           const struct gl_pixelstore_attrib *unpacking,
+                           GLboolean applyTransferOps )
+{
+   ASSERT(srcType == GL_BITMAP ||
+          srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_FLOAT);
+
+   ASSERT(dstType == GL_UNSIGNED_BYTE ||
+          dstType == GL_UNSIGNED_SHORT ||
+          dstType == GL_UNSIGNED_INT);
+
+   applyTransferOps &= (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapColorFlag);
+
+   /*
+    * Try simple cases first
+    */
+   if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
+       && dstType == GL_UNSIGNED_BYTE) {
+      MEMCPY(dest, source, n * sizeof(GLubyte));
+   }
+   else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
+            && dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
+      MEMCPY(dest, source, n * sizeof(GLuint));
+   }
+   else {
+      /*
+       * general solution
+       */
+      GLuint indexes[MAX_WIDTH];
+      assert(n <= MAX_WIDTH);
+
+      extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
+                           unpacking);
+
+      if (applyTransferOps) {
+         if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
+            /* shift and offset indexes */
+            gl_shift_and_offset_ci(ctx, n, indexes);
+         }
+
+         if (ctx->Pixel.MapStencilFlag) {
+            /* Apply stencil lookup table */
+            GLuint mask = ctx->Pixel.MapStoSsize - 1;
+            GLuint i;
+            for (i=0;i<n;i++) {
+               indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
+            }
+         }
+      }
+
+      /* convert to dest type */
+      switch (dstType) {
+         case GL_UNSIGNED_BYTE:
+            {
+               GLubyte *dst = (GLubyte *) dest;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  dst[i] = (GLubyte) (indexes[i] & 0xff);
+               }
+            }
+            break;
+         case GL_UNSIGNED_SHORT:
+            {
+               GLuint *dst = (GLuint *) dest;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  dst[i] = (GLushort) (indexes[i] & 0xffff);
+               }
+            }
+            break;
+         case GL_UNSIGNED_INT:
+            MEMCPY(dest, indexes, n * sizeof(GLuint));
+            break;
+         default:
+            gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
+      }
+   }
+}
+
+
+
+void
+_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest,
+                         GLenum srcType, const GLvoid *source,
+                         const struct gl_pixelstore_attrib *unpacking,
+                         GLboolean applyTransferOps )
+{
+   GLfloat *depth = MALLOC(n * sizeof(GLfloat));
+   if (!depth)
+      return;
+
+   switch (srcType) {
+      case GL_BYTE:
+         {
+            GLuint i;
+            const GLubyte *src = (const GLubyte *) source;
+            for (i = 0; i < n; i++) {
+               depth[i] = BYTE_TO_FLOAT(src[i]);
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE:
+         {
+            GLuint i;
+            const GLubyte *src = (const GLubyte *) source;
+            for (i = 0; i < n; i++) {
+               depth[i] = UBYTE_TO_FLOAT(src[i]);
+            }
+         }
+         break;
+      case GL_SHORT:
+         {
+            GLuint i;
+            const GLshort *src = (const GLshort *) source;
+            for (i = 0; i < n; i++) {
+               depth[i] = SHORT_TO_FLOAT(src[i]);
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT:
+         {
+            GLuint i;
+            const GLushort *src = (const GLushort *) source;
+            for (i = 0; i < n; i++) {
+               depth[i] = USHORT_TO_FLOAT(src[i]);
+            }
+         }
+         break;
+      case GL_INT:
+         {
+            GLuint i;
+            const GLint *src = (const GLint *) source;
+            for (i = 0; i < n; i++) {
+               depth[i] = INT_TO_FLOAT(src[i]);
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT:
+         {
+            GLuint i;
+            const GLuint *src = (const GLuint *) source;
+            for (i = 0; i < n; i++) {
+               depth[i] = UINT_TO_FLOAT(src[i]);
+            }
+         }
+         break;
+      case GL_FLOAT:
+         MEMCPY(depth, source, n * sizeof(GLfloat));
+         break;
+      default:
+         gl_problem(NULL, "bad type in _mesa_unpack_depth_span()");
+         return;
+   }
+
+
+   /* apply depth scale and bias */
+   if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+      }
+   }
+
+   /* clamp depth values to [0,1] and convert from floats to integers */
+   {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * DEPTH_SCALE);
+      }
+   }
+
+   FREE(depth);
+}
+
+
+
+/*
  * Unpack image data.  Apply byteswapping, byte flipping (bitmap).
  * Return all image data in a contiguous block.
  */
@@ -3656,3 +2709,106 @@ _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
       return destBuffer;
    }
 }
+
+
+/*
+ * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
+ * order with row alignment = 1 byte.
+ */
+GLvoid *
+_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
+                     const struct gl_pixelstore_attrib *packing )
+{
+   GLint bytes, row, width_in_bytes;
+   GLubyte *buffer, *dst;
+
+   if (!pixels)
+      return NULL;
+
+   /* Alloc dest storage */
+   bytes = ((width + 7) / 8 * height);
+   buffer = (GLubyte *) MALLOC( bytes );
+   if (!buffer)
+      return NULL;
+
+
+   width_in_bytes = CEILING( width, 8 );
+   dst = buffer;
+   for (row = 0; row < height; row++) {
+      GLubyte *src = gl_pixel_addr_in_image( packing, pixels, width, height,
+                                             GL_COLOR_INDEX, GL_BITMAP,
+                                             0, row, 0 );
+      if (!src) {
+         FREE(buffer);
+         return NULL;
+      }
+
+      if (packing->SkipPixels == 0) {
+         MEMCPY( dst, src, width_in_bytes );
+         if (packing->LsbFirst) {
+            gl_flip_bytes( dst, width_in_bytes );
+         }
+      }
+      else {
+         /* handling SkipPixels is a bit tricky (no pun intended!) */
+         GLint i;
+         if (packing->LsbFirst) {
+            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 128) {
+                  srcMask = 1;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask << 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+         else {
+            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 1) {
+                  srcMask = 128;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask >> 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+      }
+      dst += width_in_bytes;
+   }
+
+   return buffer;
+}